Signal

Creates a new signal of values of the type Z by applying a partial function which maps the original value of the type V to a value of the type Z. If the partial function doesn't work for the current value, the new signal will become empty until the next update. Basically, it's filter + map.

Combines the current values of this and another signal of the same or different types V and Z to produce a signal with the value of yet another type Y. Basically, zip + map.

A shortcut that checks if the current value (or the first value after initialization) is the given one.

The current value of the signal. If the signal requires some initial work before accessing its value for the first time, it will be done exactly one time. Subsequently, this method will simply return the current value.

Please note that this will return an option of the value type. You may get a None if the signal is not initialized yet or if it was temporarily cleared and awaits another update. Usually, it's safer to use head or future and work with a future of the value type instead. And if you need to know if the signal is currently empty, use empty.

A generalization of the orElse method where the fallback signal can have another value type. If the value of this signal is V and the value of the fallback signal is Z, the new signal will return an Either[Z, V]. When the parent signal is set, the value of the new signal will be Right(v). When the parent signal becomes empty, the value of the new signal will temporarily switch to Left(z) where z is the current value of the fallback signal. The moment the parent signal is set to a new value again, the new signal will switch back to Right(v). Only when both signals are empty, the new signal will become empty too.

Checks if the signal is currently empty. A signal is usually empty just after creation, if it was not initialized with a value, and it still waits for the first value to be sent to it. Or it can be a constant Signal.empty[V].

A shortcut that checks if the current value (or the first value after initialization) fulfills the given condition.

Creates a new Signal[V] which updates its value only if the new value of the original signal satisfies the filter, and changes to empty otherwise. Also, if the initial value of the original signal does not satisfy the filter, the new signal will start empty.

Creates a new Signal[Z] by mapping each event of the original Signal[V] to a new signal and switching to it. The usual use case is to create a new complex signal not as one big entity with the value being the result of computations based on a lot of data at once, but to break it into simpler signals connected by flatMaps. At each step the used signal produces an intermediate value and recomputing that value is not necessary again until the values used to compute that one are changed too.

Flattens a signal whose value type is also a signal.

A future with the current value of the signal. The future will finish immediately with the current value of the signal if the value is already set. If the signal is empty, the future will finish when the next update sets the value.

An alias to the future method.

Creates a new Signal[Z] by mapping the value of the type V of this signal.

Registers a subscriber in a specified execution context and returns the subscription. An optional event context can also be provided by the user for managing the subscription instead of doing it manually. When the value of the signal changes, the subscriber function will be called in the given execution context instead of the one of the publisher.

Registers a subscriber which will always be called in the same execution context in which the value of the signal was changed. An optional event context can be provided by the user for managing the subscription instead of doing it manually.

Assuming that the value of the signal can be interpreted as a boolean, this method returns a future of type Unit which will finish with success when the value of the original signal is false.

val signal = Signal[Int](2)
signal.map(_ % 2 == 0).onFalse.foreach { _ => println("This is the first time the value of the signal is odd") }

Creates a new signal of the same value type which changes its value to the changed value of the parent signal only if the given select function returns different results for the old and the new value. If the results of the select functions are equal, then even if the new value of the original signal is actually different from the old one, the value of the new signal stays the same.

Consider the following example:

val parent = Signal[Int](3)
val oddEvenSwitch = parent.onPartialUpdate { _ % 2 == 0 }
oddEvenSwitch.foreach { _ => println(s"The value switched between odd and even") }

Here, the value of oddEvenSwitch will update only if the new value is even if the old one was odd and vice versa. So, if we publish new odd values to parent (1, 5, 9, 7, ...) the value of oddEvenSwitch will stay at 3. Only when we publish an even number to parent (say, 2), the value oddEventSwitch will change. And from now on it will stay like that until we publish an odd number to the parent.

Assuming that the value of the signal can be interpreted as a boolean, this method returns a future of type Unit which will finish with success when the value of the original signal is true.

val signal = Signal[Int](3)
signal.map(_ % 2 == 0).onTrue.foreach { _ => println("This is the first time the value of the signal is even") }

Creates a version of this signal which, if the parent signal becomes empty, temporarily uses the value of the given fallback signal. The moment the parent signal is set to a new value again, the new signal switches back to it. Only when both signals are empty, the new signal will become empty too.

A shorthand for registering a subscriber function in this signal which only purpose is to publish changes to the value of this signal in another SourceSignal. The subscriber function will be called in the execution context of the original publisher.

Creates a new signal with the value type Z where the change in the value is the result of applying a function which combines the previous value of type Z with the changed value of the type V of the parent signal.

Creates a throttled version of this signal which updates no more often than once during the given time interval. If changes to the value of the parent signal happen more often, some of them will be ignored.

An alias for filter used in the for/yield notation.

This can be useful for more readable chains of asynchronous computations where at some point we want to wait until some condition is fulfilled:

val resultSignal = for {
a    <- signalA
b    <- signalB
true <- checkCondition(a, b)
c    <- signalC
} yield c

Here, resultSignal will be updated to the value of signalC only if the current values of signalA and signalB fulfill the condition. If the check fails, resultSignal will become empty until signalA or signalB changes its value and the new pair fulfills the condition.

Zips this signal with the given one.

An alias for pipeTo.

Typically, a newly created event streams and signals are lazy in the sense that till there are no subscriptions to them, they will not execute any intermediate computations (e.g. assembled to it through maps, flatMaps, etc). After all, those computations would be ignored at the end. Only when a subscription is created, the computations are performed for the first time. disableAutowiring enforces those computations even if there are no subscribers. It can be useful if e.g. the computations perform side-effects or if it's important from the performance point of view to have the intermediate results ready when the subscriber is created.

An alias for the on method with the default ExecutionContext.

Checks if there are any subscribers registered in this EventRelay.

The class which implements this EventRelay can use this method to notify all the subscribers that a new event arrived.

Adds a new subscriber instance. The implementing class should handle notifying this subscriber when a new event arrives. If this is the first subscriber, and disableAutowiring wasn't called previous, this will trigger a call to onWire.

Removes a previously registered subscriber instance. If this is the last subscriber, and disableAutowiring wasn't called previously, this will trigger a call to onUnwire.

Empties the set of subscribers and calls unWire if disableAutowiring wasn't called before.

An event stream where each event is a new value of the signal. Every time the value of the signal changes - actually changes to another value - the new value will be published in this stream. The events in the stream are guaranteed to differ. It's not possible to get two equal events one after another.

An event stream where each event is a tuple of the old and the new value of the signal. Every time the value of the signal changes - actually changes to another value - the new value will be published in this stream, together with the old value which you can use to check what exactly changed. The old value is wrapped in an Option: if the signal was previously empty, the old value will be None otherwise it will be Some[V]. The values are guaranteed to differ, i.e. if you get a tuple (Some(oldValue), newValue) then oldValue != newValue.