SignallingRef

Obtains a snapshot of the current value, and a setter for updating it. The setter may noop (in which case false is returned) if another concurrent call to access uses its setter first.

Once it has noop'd or been used once, a setter never succeeds again.

Satisfies: r.access.map(_._1) == r.get r.access.flatMap { case (v, setter) => setter(f(v)) } == r.tryUpdate(f).map(_.isDefined)

Returns a stream of the current value of the signal. An element is always available -- on each pull, the current value is supplied.

Returns a stream of the updates to this signal.

Updates that are very close together may result in only the last update appearing in the stream. If you want to be notified about every single update, use a Queue or Channel instead.

Asynchronously gets the current value of this Signal.

Replaces the current value with a, returning the previous value.

Updates the current value using f and returns the previous value.

In case of retries caused by concurrent modifications, the returned value will be the last one before a successful update.

Modify the context F using transformation f.

Like tryModify but does not complete until the update has been successfully made.

Like tryModifyState but retries the modification until successful.

Sets the current value to a.

The returned action completes after the reference has been successfully set.

Satisfies: r.set(fa) *> r.get == fa

Like tryUpdate but allows the update function to return an output value of type B. The returned action completes with None if the value is not updated successfully and Some(b) otherwise.

Update the value of this ref with a state computation.

The current value of this ref is used as the initial state and the computed output state is stored in this ref after computation completes. If a concurrent modification occurs, None is returned.

Attempts to modify the current value once, returning false if another concurrent modification completes between the time the variable is read and the time it is set.

Modifies the current value using the supplied update function. If another modification occurs between the time the current value is read and subsequently updated, the modification is retried using the new value. Hence, f may be invoked multiple times.

Satisfies: r.update(_ => a) == r.set(a)

Updates the current value using f, and returns the updated value.