Airstream/com.raquo.airstream.core/BaseObservable

BaseObservable

trait BaseObservable[+Self <: ([_] =>> Observable[_]), +A] extends Source[A] with Named

This trait represents a reactive value that can be subscribed to.

It has only one direct subtype, Observable, which in turn has two direct subtypes, EventStream and Signal.

BaseObservable is the same as Observable, it just lives in a separate trait for technical reasons (the Self type param).

All Observables are lazy. An Observable starts when it gets its first observer (internal or external), and stops when it loses its last observer (again, internal or external).

Basic idea: Lazy Observable only holds references to those children that have any observers (either directly on themselves, or on any of their descendants). What this achieves:

Stream only propagates its value to children that (directly or not) have observers
Stream calculates its value only once regardless of how many observers / children it has) (so, all streams are "hot" observables)
Stream doesn't hold references to Streams that no one observes, allowing those Streams to be garbage collected if they are otherwise unreachable (which they should become when their subscriptions are killed by their owners)

trait Named

trait Source[A]

class Object

trait Matchable

class Any

trait EventStream[A]

trait WritableEventStream[A]

class CombineEventStreamN[A, Out]

class CombineEventStream2[T1, T2, Out]

class CombineEventStream3[T1, T2, T3, Out]

class CombineEventStream4[T1, T2, T3, T4, Out]

class CombineEventStream5[T1, T2, T3, T4, T5, Out]

class CombineEventStream6[T1, T2, T3, T4, T5, T6, Out]

class CombineEventStream7[T1, T2, T3, T4, T5, T6, T7, Out]

class CombineEventStream8[T1, T2, T3, T4, T5, T6, T7, T8, Out]

class CombineEventStream9[T1, T2, T3, T4, T5, T6, T7, T8, T9, Out]

class MergeEventStream[A]

class SampleCombineEventStreamN[A, Out]

class SampleCombineEventStream2[T0, T1, Out]

class SampleCombineEventStream3[T0, T1, T2, Out]

class SampleCombineEventStream4[T0, T1, T2, T3, Out]

class SampleCombineEventStream5[T0, T1, T2, T3, T4, Out]

class SampleCombineEventStream6[T0, T1, T2, T3, T4, T5, Out]

class SampleCombineEventStream7[T0, T1, T2, T3, T4, T5, T6, Out]

class SampleCombineEventStream8[T0, T1, T2, T3, T4, T5, T6, T7, Out]

class SampleCombineEventStream9[T0, T1, T2, T3, T4, T5, T6, T7, T8, Out]

class CustomStreamSource[A]

class DebuggerEventStream[A]

class EventBusStream[A]

class ConcurrentEventStream[A]

class ConcurrentFutureStream[A]

class SwitchEventStream[I, O]

class FilterEventStream[A]

class MapEventStream[I, O]

class SplitEventStream[M, Input, Output, Key]

class DebounceEventStream[A]

class DelayEventStream[A]

class FutureEventStream[A]

class PeriodicEventStream[A]

class SyncDelayEventStream[A]

class ThrottleEventStream[A]

class AjaxEventStream

trait Observable[A]

trait SingleParentObservable[I, O]

trait DebuggerObservable[A]

class DebuggerSignal[A]

class SwitchSignal[A]

class FoldLeftSignal[A, B]

class MapSignal[I, O]

class DerivedVarSignal[A, B]

class ObservedSignal[A]

class SignalFromEventStream[A]

trait Signal[A]

trait WritableSignal[A]

class CombineSignalN[A, Out]

class CombineSignal2[T1, T2, Out]

class CombineSignal3[T1, T2, T3, Out]

class CombineSignal4[T1, T2, T3, T4, Out]

class CombineSignal5[T1, T2, T3, T4, T5, Out]

class CombineSignal6[T1, T2, T3, T4, T5, T6, Out]

class CombineSignal7[T1, T2, T3, T4, T5, T6, T7, Out]

class CombineSignal8[T1, T2, T3, T4, T5, T6, T7, T8, Out]

class CombineSignal9[T1, T2, T3, T4, T5, T6, T7, T8, T9, Out]

class SampleCombineSignalN[A, Out]

class SampleCombineSignal2[T0, T1, Out]

class SampleCombineSignal3[T0, T1, T2, Out]

class SampleCombineSignal4[T0, T1, T2, T3, Out]

class SampleCombineSignal5[T0, T1, T2, T3, T4, Out]

class SampleCombineSignal6[T0, T1, T2, T3, T4, T5, Out]

class SampleCombineSignal7[T0, T1, T2, T3, T4, T5, T6, Out]

class SampleCombineSignal8[T0, T1, T2, T3, T4, T5, T6, T7, Out]

class SampleCombineSignal9[T0, T1, T2, T3, T4, T5, T6, T7, T8, Out]

class CustomSignalSource[A]

class Val[A]

class FutureSignal[A]

trait StrictSignal[A]

trait OwnedSignal[A]

trait SyncObservable[A]

trait CombineObservable[A]

trait WritableObservable[A]

trait CustomSource[A]

Value members

Abstract methods

Subscribe an external observer to this observable

Create a new observable that listens to this one and has a debugger attached.

Use the resulting observable in place of the original observable in your code. See docs for details.

There are more convenient methods available implicitly from DebuggableObservable and DebuggableSignal, such as debugLog(), debugSpyEvents(), etc.

Value Params

project: Note: guarded against exceptions

Total number of internal and external observers

Value Params

pf: Note: guarded against exceptions

Convert this to an observable that emits Failure(err) instead of erroring

Concrete methods

@inline

Value Params

compose: Note: guarded against exceptions

Create an external observer from a function and subscribe it to this observable.

Note: since you won't have a reference to the observer, you will need to call Subscription.kill() to unsubscribe

value is passed by name, so it will be evaluated whenever the Observable fires. Use it to sample mutable values (e.g. myInput.ref.value in Laminar).

Inherited methods

This is the method that subclasses override to preserve the user's ability to set custom display names.

Inherited from: Named

Inherited from: Named

Set the display name for this instance (observable or observer).

This method modifies the instance and returns this. It does not create a new instance.
New name you set will override the previous name, if any. This might change in the future. For the sake of sanity, don't call this more than once for the same instance.
If display name is set, toString will output it instead of the standard type@hashcode string

Inherited from: Named

Inherited from: Source

Override defaultDisplayName instead of this, if you need to.

Definition Classes: Named -> Any
Inherited from: Named