Signal

public final class Signal<Value, Error> where Error : Error

extension Signal: SignalProtocol

extension Signal: SignalProducerConvertible

extension Signal: BindingSource  where Error == Never

A push-driven stream that sends Events over time, parameterized by the type of values being sent (Value) and the type of failure that can occur (Error). If no failures should be possible, Never can be specified for Error.

An observer of a Signal will see the exact same sequence of events as all other observers. In other words, events will be sent to all observers at the same time.

Signals are generally used to represent event streams that are already "in progress," like notifications, user input, etc. To represent streams that must first be started, see the SignalProducer type.

A Signal is kept alive until either of the following happens:

its input observer receives a terminating event; or
it has no active observers, and is not being retained.

init(_:)
Initialize a Signal that will immediately invoke the given generator, then forward events sent to the given observer.

Note

The disposable returned from the closure will be automatically disposed if a terminating event is sent to the observer. The Signal itself will remain alive until the observer is released.
Declaration
Swift

public init(_ generator: (Observer , Lifetime ) -> Void)
Parameters

generator

A closure that accepts an implicitly created observer that will act as an event emitter for the signal.
observe(_:)
Observe the Signal by sending any future events to the given observer.

Note

If the Signal has already terminated, the observer will immediately receive an interrupted event.
Declaration
Swift

@discardableResult public func observe(_ observer: Observer ) -> Disposable ?
Parameters

observer

An observer to forward the events to.

Return Value

A Disposable which can be used to disconnect the observer, or nil if the signal has already terminated.


 
 
 Event

Represents a signal event.

Signals must conform to the grammar: value* (failed | completed | interrupted)?

Declaration

Swift

public enum Event

extension Signal .Event: CustomStringConvertible

extension Signal .Event: EventProtocol

extension Signal .Event: Equatable where Value: Equatable, Error: Equatable

logEvents(identifier:events:fileName:functionName:lineNumber:logger:)
Logs all events that the receiver sends. By default, it will print to the standard output.
Declaration
Swift

public func logEvents(identifier: String = "", events: Set<LoggingEvent .Signal> = LoggingEvent .Signal.allEvents, fileName: String = #file, functionName: String = #function, lineNumber: Int = #line, logger: @escaping EventLogger = defaultEventLog) -> Signal<Value, Error>
Parameters

identifier

a string to identify the Signal firing events.

events

Types of events to log.

fileName

Name of the file containing the code which fired the event.

functionName

Function where event was fired.

lineNumber

Line number where event was fired.

logger

Logger that logs the events.

Return Value

Signal that, when observed, logs the fired events.
merge(_:)
Merges the given signals into a single Signal that will emit all values from each of them, and complete when all of them have completed.
Declaration
Swift

public static func merge<Seq>(_ signals: Seq) -> Signal<Value, Error> where Seq : Sequence, Seq.Element == Signal<Value, Error>
Parameters

signals

A sequence of signals to merge.
merge(_:)
Merges the given signals into a single Signal that will emit all values from each of them, and complete when all of them have completed.
Declaration
Swift

public static func merge(_ signals: Signal<Value, Error>...) -> Signal<Value, Error>
Parameters

signals

A list of signals to merge.
flatMap(_:_:)
Maps each event from signal to a new signal, then flattens the resulting producers (into a signal of values), according to the semantics of the given strategy.

Warning

If signal or any of the created producers fail, the returned signal will forward that failure immediately.
Declaration
Swift

public func flatMap(_ strategy: FlattenStrategy , _ transform: @escaping (Value) -> SignalProducer <U, Error>) -> Signal<U, Error>
Parameters

strategy

Strategy used when flattening signals.

transform

A closure that takes a value emitted by self and returns a signal producer with transformed value.
flatMap(_:_:)
Maps each event from signal to a new signal, then flattens the resulting producers (into a signal of values), according to the semantics of the given strategy.

Warning

If signal or any of the created producers fail, the returned signal will forward that failure immediately.
Declaration
Swift

public func flatMap<Inner: SignalProducerConvertible >(_ strategy: FlattenStrategy , _ transform: @escaping (Value) -> Inner) -> Signal<Inner.Value, Error> where Inner.Error == Error
Parameters

strategy

Strategy used when flattening signals.

transform

A closure that takes a value emitted by self and returns a signal producer with transformed value.
flatMap(_:_:)
Maps each event from signal to a new signal, then flattens the resulting producers (into a signal of values), according to the semantics of the given strategy.

Warning

If signal fails, the returned signal will forward that failure immediately.
Declaration
Swift

public func flatMap(_ strategy: FlattenStrategy , _ transform: @escaping (Value) -> SignalProducer <U, Never>) -> Signal<U, Error>
Parameters

strategy

Strategy used when flattening signals.

transform

A closure that takes a value emitted by self and returns a signal producer with transformed value.
flatMap(_:_:)
Maps each event from signal to a new signal, then flattens the resulting producers (into a signal of values), according to the semantics of the given strategy.

Warning

If signal fails, the returned signal will forward that failure immediately.
Declaration
Swift

public func flatMap<Inner: SignalProducerConvertible >(_ strategy: FlattenStrategy , _ transform: @escaping (Value) -> Inner) -> Signal<Inner.Value, Error> where Inner.Error == Never
Parameters

strategy

Strategy used when flattening signals.

transform

A closure that takes a value emitted by self and returns a signal producer with transformed value.
flatMapError(_:)
Catches any failure that may occur on the input signal, mapping to a new producer that starts in its place.
Declaration
Swift

public func flatMapError<F>(_ transform: @escaping (Error) -> SignalProducer <Value, F>) -> Signal<Value, F>
Parameters

transform

A closure that accepts emitted error and returns a signal producer with a different type of error.
flatMapError(_:)
Catches any failure that may occur on the input signal, mapping to a new producer that starts in its place.
Declaration
Swift

public func flatMapError<Inner: SignalProducerConvertible >(_ transform: @escaping (Error) -> Inner) -> Signal<Value, Inner.Error> where Inner.Value == Value
Parameters

transform

A closure that accepts emitted error and returns a signal producer with a different type of error.
Observer
An Observer is a simple wrapper around a function which can receive Events (typically from a Signal).
See more
Declaration
Swift

public final class Observer
never
A Signal that never sends any events to its observers.
Declaration
Swift

public static var never: Signal { get }
empty
A Signal that completes immediately without emitting any value.
Declaration
Swift

public static var empty: Signal { get }
pipe(disposable:)
Create a Signal that will be controlled by sending events to an input observer.

Note

The Signal will remain alive until a terminating event is sent to the input observer, or until it has no observers and there are no strong references to it.
Declaration
Swift

public static func pipe(disposable: Disposable ? = nil) -> (output: Signal, input: Observer )
Parameters

disposable

An optional disposable to associate with the signal, and to be disposed of when the signal terminates.

Return Value

A 2-tuple of the output end of the pipe as Signal, and the input end of the pipe as Signal.Observer .


 
 
 signal

Declaration

Swift

public var signal: Signal<Value, Error> { get }


 
 
 producer

Declaration

Swift

public var producer: SignalProducer <Value, Error> { get }

observe(_:)
Observe self for all events being emitted.

Note

If self has terminated, the closure would be invoked with an interrupted event immediately.
Declaration
Swift

@discardableResult public func observe(_ action: @escaping Signal<Value, Error>.Observer .Action ) -> Disposable ?
Parameters

action

A closure to be invoked with every event from self.

Return Value

A disposable to detach action from self. nil if self has terminated.
observeResult(_:)
Observe self for all values being emitted, and if any, the failure.
Declaration
Swift

@discardableResult public func observeResult(_ action: @escaping (Result<Value, Error>) -> Void) -> Disposable ?
Parameters

action

A closure to be invoked with values from self, or the propagated error should any failed event is emitted.

Return Value

A disposable to detach action from self. nil if self has terminated.
observeCompleted(_:)
Observe self for its completion.
Declaration
Swift

@discardableResult public func observeCompleted(_ action: @escaping () -> Void) -> Disposable ?
Parameters

action

A closure to be invoked when a completed event is emitted.

Return Value

A disposable to detach action from self. nil if self has terminated.
observeFailed(_:)
Observe self for its failure.
Declaration
Swift

@discardableResult public func observeFailed(_ action: @escaping (Error) -> Void) -> Disposable ?
Parameters

action

A closure to be invoked with the propagated error, should any failed event is emitted.

Return Value

A disposable to detach action from self. nil if self has terminated.
observeInterrupted(_:)
Observe self for its interruption.

Note

If self has terminated, the closure would be invoked immediately.
Declaration
Swift

@discardableResult public func observeInterrupted(_ action: @escaping () -> Void) -> Disposable ?
Parameters

action

A closure to be invoked when an interrupted event is emitted.

Return Value

A disposable to detach action from self. nil if self has terminated.
map(_:)
Map each value in the signal to a new value.
Declaration
Swift

public func map(_ transform: @escaping (Value) -> U) -> Signal<U, Error>
Parameters

transform

A closure that accepts a value from the value event and returns a new value.

Return Value

A signal that will send new values.
map(value:)
Map each value in the signal to a new constant value.
Declaration
Swift

public func map(value: U) -> Signal<U, Error>
Parameters

value

A new value.

Return Value

A signal that will send new values.
map(_:)
Map each value in the signal to a new value by applying a key path.
Declaration
Swift

public func map(_ keyPath: KeyPath<Value, U>) -> Signal<U, Error>
Parameters

keyPath

A key path relative to the signal’s Value type.

Return Value

A signal that will send new values.
mapError(_:)
Map errors in the signal to a new error.
Declaration
Swift

public func mapError<F>(_ transform: @escaping (Error) -> F) -> Signal<Value, F>
Parameters

transform

A closure that accepts current error object and returns a new type of error object.

Return Value

A signal that will send new type of errors.
lazyMap(on:transform:)
Maps each value in the signal to a new value, lazily evaluating the supplied transformation on the specified scheduler.

Important

Unlike map, there is not a 1-1 mapping between incoming values, and values sent on the returned signal. If scheduler has not yet scheduled transform for execution, then each new value will replace the last one as the parameter to transform once it is finally executed.
Declaration
Swift

public func lazyMap(on scheduler: Scheduler , transform: @escaping (Value) -> U) -> Signal<U, Error>
Parameters

transform

The closure used to obtain the returned value from this signal’s underlying value.

Return Value

A signal that sends values obtained using transform as this signal sends values.
filter(_:)
Preserve only values which pass the given closure.
Declaration
Swift

public func filter(_ isIncluded: @escaping (Value) -> Bool) -> Signal<Value, Error>
Parameters

isIncluded

A closure to determine whether a value from self should be included in the returned Signal.

Return Value

A signal that forwards the values passing the given closure.
compactMap(_:)
Applies transform to values from signal and forwards values with non nil results unwrapped.
Declaration
Swift

public func compactMap(_ transform: @escaping (Value) -> U?) -> Signal<U, Error>
Parameters

transform

A closure that accepts a value from the value event and returns a new optional value.

Return Value

A signal that will send new values, that are non nil after the transformation.
filterMap(_:)
Applies transform to values from signal and forwards values with non nil results unwrapped.
Declaration
Swift

@available(*, deprecated, renamed: "compactMap") public func filterMap(_ transform: @escaping (Value) -> U?) -> Signal<U, Error>
Parameters

transform

A closure that accepts a value from the value event and returns a new optional value.

Return Value

A signal that will send new values, that are non nil after the transformation.
take(first:)
Take up to n values from the signal and then complete.

Precondition

count must be non-negative number.
Declaration
Swift

public func take(first count: Int) -> Signal<Value, Error>
Parameters

count

A number of values to take from the signal.

Return Value

A signal that will yield the first count values from self
collect()
Collect all values sent by the signal then forward them as a single array and complete.

Note

When self completes without collecting any value, it will send an empty array of values.
Declaration
Swift

public func collect() -> Signal<[Value], Error>
Return Value

A signal that will yield an array of values when self completes.
collect(count:)
Collect at most count values from self, forward them as a single array and complete.

Note

When the count is reached the array is sent and the signal starts over yielding a new array of values.

Note

When self completes any remaining values will be sent, the last array may not have count values. Alternatively, if were not collected any values will sent an empty array of values.

Precondition

count should be greater than zero.
Declaration
Swift

public func collect(count: Int) -> Signal<[Value], Error>
collect(_:)
Collect values from self, and emit them if the predicate passes.

When self completes any remaining values will be sent, regardless of the collected values matching shouldEmit or not.

If self completes without having emitted any value, an empty array would be emitted, followed by the completion of the returned Signal.
```
let (signal, observer) = Signal<Int, Never>.pipe()
signal
 .collect { values in values.reduce(0, combine: +) == 8 }
 .observeValues { print(0ドル) }
observer.send(value: 1)
observer.send(value: 3)
observer.send(value: 4)
observer.send(value: 7)
observer.send(value: 1)
observer.send(value: 5)
observer.send(value: 6)
observer.sendCompleted()
// Output:
// [1, 3, 4]
// [7, 1]
// [5, 6]
```
Declaration
Swift

public func collect(_ shouldEmit: @escaping (_ collectedValues: [Value]) -> Bool) -> Signal<[Value], Error>
Parameters

shouldEmit

A closure to determine, when every time a new value is received, whether the collected values should be emitted. The new value is included in the collected values.

Return Value

A signal of arrays of values, as instructed by the shouldEmit closure.
collect(_:)
Collect values from self, and emit them if the predicate passes.

When self completes any remaining values will be sent, regardless of the collected values matching shouldEmit or not.

If self completes without having emitted any value, an empty array would be emitted, followed by the completion of the returned Signal.
```
let (signal, observer) = Signal<Int, Never>.pipe()
signal
 .collect { values, value in value == 7 }
 .observeValues { print(0ドル) }
observer.send(value: 1)
observer.send(value: 1)
observer.send(value: 7)
observer.send(value: 7)
observer.send(value: 5)
observer.send(value: 6)
observer.sendCompleted()
// Output:
// [1, 1]
// [7]
// [7, 5, 6]
```
Declaration
Swift

public func collect(_ shouldEmit: @escaping (_ collected: [Value], _ latest: Value) -> Bool) -> Signal<[Value], Error>
Parameters

shouldEmit

A closure to determine, when every time a new value is received, whether the collected values should be emitted. The new value is not included in the collected values, and is included when the next value is received.

Return Value

A signal of arrays of values, as instructed by the shouldEmit closure.
collect(every:on:skipEmpty:discardWhenCompleted:)
Forward the latest values on scheduler every interval.

Note

If self terminates while values are being accumulated, the behaviour will be determined by discardWhenCompleted. If true, the values will be discarded and the returned signal will terminate immediately. If false, that values will be delivered at the next interval.
Declaration
Swift

public func collect(every interval: DispatchTimeInterval, on scheduler: DateScheduler , skipEmpty: Bool = false, discardWhenCompleted: Bool = true) -> Signal<[Value], Error>
Parameters

interval

A repetition interval.

scheduler

A scheduler to send values on.

skipEmpty

Whether empty arrays should be sent if no values were accumulated during the interval.

discardWhenCompleted

A boolean to indicate if the latest unsent values should be discarded on completion.

Return Value

A signal that sends all values that are sent from self at interval seconds apart.
observe(on:)
Forward all events onto the given scheduler, instead of whichever scheduler they originally arrived upon.
Declaration
Swift

public func observe(on scheduler: Scheduler ) -> Signal<Value, Error>
Parameters

scheduler

A scheduler to deliver events on.

Return Value

A signal that will yield self values on provided scheduler.
combineLatest(with:)
Combine the latest value of the receiver with the latest value from the given signal.

Note

The returned signal will not send a value until both inputs have sent at least one value each.

Note

If either signal is interrupted, the returned signal will also be interrupted.

Note

The returned signal will not complete until both inputs complete.
Declaration
Swift

public func combineLatest(with other: Signal<U, Error>) -> Signal<(Value, U), Error>
Parameters

otherSignal

A signal to combine self‘s value with.

Return Value

A signal that will yield a tuple containing values of self and given signal.
merge(with:)
Merge the given signal into a single Signal that will emit all values from both of them, and complete when all of them have completed.
Declaration
Swift

public func merge(with other: Signal<Value, Error>) -> Signal<Value, Error>
Parameters

other

A signal to merge self‘s value with.

Return Value

A signal that sends all values of self and given signal.
delay(_:on:)
Delay value and completed events by the given interval, forwarding them on the given scheduler.

Note

failed and interrupted events are always scheduled immediately.

Precondition

interval must be non-negative number.
Declaration
Swift

public func delay(_ interval: TimeInterval, on scheduler: DateScheduler ) -> Signal<Value, Error>
Parameters

interval

Interval to delay value and completed events by.

scheduler

A scheduler to deliver delayed events on.

Return Value

A signal that will delay value and completed events and will yield them on given scheduler.
skip(first:)
Skip first count number of values then act as usual.

Precondition

count must be non-negative number.
Declaration
Swift

public func skip(first count: Int) -> Signal<Value, Error>
Parameters

count

A number of values to skip.

Return Value

A signal that will skip the first count values, then forward everything afterward.
materialize()
Treat all Events from self as plain values, allowing them to be manipulated just like any other value.

In other words, this brings Events "into the monad".

Note

When a Completed or Failed event is received, the resulting signal will send the Event itself and then complete. When an Interrupted event is received, the resulting signal will send the Event itself and then interrupt.
Declaration
Swift

public func materialize() -> Signal<Event , Never>
Return Value

A signal that sends events as its values.
materializeResults()
Treats all Results from the input producer as plain values, allowing them to be manipulated just like any other value.

In other words, this brings Results "into the monad."

Note

When a Failed event is received, the resulting producer will send the Result.failure itself and then complete.
Declaration
Swift

public func materializeResults() -> Signal<Result<Value, Error>, Never>
Return Value

A producer that sends results as its values.
on(event:failed:completed:interrupted:terminated:disposed:value:)
Inject side effects to be performed upon the specified signal events.
Declaration
Swift

public func on( event: ((Event ) -> Void)? = nil, failed: ((Error) -> Void)? = nil, completed: (() -> Void)? = nil, interrupted: (() -> Void)? = nil, terminated: (() -> Void)? = nil, disposed: (() -> Void)? = nil, value: ((Value) -> Void)? = nil ) -> Signal<Value, Error>
Parameters

event

A closure that accepts an event and is invoked on every received event.

failed

A closure that accepts error object and is invoked for failed event.

completed

A closure that is invoked for completed event.

interrupted

A closure that is invoked for interrupted event.

terminated

A closure that is invoked for any terminating event.

disposed

A closure added as disposable when signal completes.

value

A closure that accepts a value from value event.

Return Value

A signal with attached side-effects for given event cases.
sample(with:)
Forward the latest value from self with the value from sampler as a tuple, only whensampler sends a value event.

Note

If sampler fires before a value has been observed on self, nothing happens.
Declaration
Swift

public func sample<T>(with sampler: Signal<T, Never>) -> Signal<(Value, T), Error>
Parameters

sampler

A signal that will trigger the delivery of value event from self.

Return Value

A signal that will send values from self and sampler, sampled (possibly multiple times) by sampler, then complete once both input signals have completed, or interrupt if either input signal is interrupted.
sample(on:)
Forward the latest value from self whenever sampler sends a value event.

Note

If sampler fires before a value has been observed on self, nothing happens.
Declaration
Swift

public func sample(on sampler: Signal<(), Never>) -> Signal<Value, Error>
Parameters

sampler

A signal that will trigger the delivery of value event from self.

Return Value

A signal that will send values from self, sampled (possibly multiple times) by sampler, then complete once both input signals have completed, or interrupt if either input signal is interrupted.
withLatest(from:)
Forward the latest value from samplee with the value from self as a tuple, only when self sends a value event. This is like a flipped version of sample(with:) , but samplee‘s terminal events are completely ignored.

Note

If self fires before a value has been observed on samplee, nothing happens.
Declaration
Swift

public func withLatest(from samplee: Signal<U, Never>) -> Signal<(Value, U), Error>
Parameters

samplee

A signal whose latest value is sampled by self.

Return Value

A signal that will send values from self and samplee, sampled (possibly multiple times) by self, then terminate once self has terminated. samplee‘s terminated events are ignored.
withLatest(from:)
Forward the latest value from samplee with the value from self as a tuple, only when self sends a value event. This is like a flipped version of sample(with:) , but samplee‘s terminal events are completely ignored.

Note

If self fires before a value has been observed on samplee, nothing happens.
Declaration
Swift

public func withLatest(from samplee: SignalProducer <U, Never>) -> Signal<(Value, U), Error>
Parameters

samplee

A producer whose latest value is sampled by self.

Return Value

A signal that will send values from self and samplee, sampled (possibly multiple times) by self, then terminate once self has terminated. samplee‘s terminated events are ignored.
withLatest(from:)
Forward the latest value from samplee with the value from self as a tuple, only when self sends a value event. This is like a flipped version of sample(with:) , but samplee‘s terminal events are completely ignored.

Note

If self fires before a value has been observed on samplee, nothing happens.
Declaration
Swift

public func withLatest<Samplee>(from samplee: Samplee) -> Signal<(Value, Samplee.Value), Error> where Samplee : SignalProducerConvertible , Samplee.Error == Never
Parameters

samplee

A producer whose latest value is sampled by self.

Return Value

A signal that will send values from self and samplee, sampled (possibly multiple times) by self, then terminate once self has terminated. samplee‘s terminated events are ignored.
take(during:)
Forwards events from self until lifetime ends, at which point the returned signal will complete.
Declaration
Swift

public func take(during lifetime: Lifetime ) -> Signal<Value, Error>
Parameters

lifetime

A lifetime whose ended signal will cause the returned signal to complete.

Return Value

A signal that will deliver events until lifetime ends.
take(until:)
Forward events from self until trigger sends a value or completed event, at which point the returned signal will complete.
Declaration
Swift

public func take(until trigger: Signal<(), Never>) -> Signal<Value, Error>
Parameters

trigger

A signal whose value or completed events will stop the delivery of value events from self.

Return Value

A signal that will deliver events until trigger sends value or completed events.
skip(until:)
Do not forward any values from self until trigger sends a value or completed event, at which point the returned signal behaves exactly like signal .
Declaration
Swift

public func skip(until trigger: Signal<(), Never>) -> Signal<Value, Error>
Parameters

trigger

A signal whose value or completed events will start the deliver of events on self.

Return Value

A signal that will deliver events once the trigger sends value or completed events.
combinePrevious(_:)
Forward events from self with history: values of the returned signal are a tuples whose first member is the previous value and whose second member is the current value. initial is supplied as the first member when self sends its first value.
Declaration
Swift

public func combinePrevious(_ initial: Value) -> Signal<(Value, Value), Error>
Parameters

initial

A value that will be combined with the first value sent by self.

Return Value

A signal that sends tuples that contain previous and current sent values of self.
combinePrevious()
Forward events from self with history: values of the returned signal are a tuples whose first member is the previous value and whose second member is the current value.

The returned Signal would not emit any tuple until it has received at least two values.
Declaration
Swift

public func combinePrevious() -> Signal<(Value, Value), Error>
Return Value

A signal that sends tuples that contain previous and current sent values of self.
reduce(_:_:)
Combine all values from self, and forward only the final accumulated result.

See scan(_:_:) if the resulting producer needs to forward also the partial results.
Declaration
Swift

public func reduce(_ initialResult: U, _ nextPartialResult: @escaping (U, Value) -> U) -> Signal<U, Error>
Parameters

initialResult

The value to use as the initial accumulating value.

nextPartialResult

A closure that combines the accumulating value and the latest value from self. The result would be used in the next call of nextPartialResult, or emit to the returned Signal when self completes.

Return Value

A signal that sends the final result as self completes.
reduce(into:_:)
Combine all values from self, and forward only the final accumulated result.

See scan(into:_:) if the resulting producer needs to forward also the partial results.
Declaration
Swift

public func reduce(into initialResult: U, _ nextPartialResult: @escaping (inout U, Value) -> Void) -> Signal<U, Error>
Parameters

initialResult

The value to use as the initial accumulating value.

nextPartialResult

A closure that combines the accumulating value and the latest value from self. The result would be used in the next call of nextPartialResult, or emit to the returned Signal when self completes.

Return Value

A signal that sends the final result as self completes.
scan(_:_:)
Combine all values from self, and forward the partial results and the final result.

See reduce(_:_:) if the resulting producer needs to forward only the final result.
Declaration
Swift

public func scan(_ initialResult: U, _ nextPartialResult: @escaping (U, Value) -> U) -> Signal<U, Error>
Parameters

initialResult

The value to use as the initial accumulating value.

nextPartialResult

A closure that combines the accumulating value and the latest value from self. The result would be forwarded, and would be used in the next call of nextPartialResult.

Return Value

A signal that sends the partial results of the accumuation, and the final result as self completes.
scan(into:_:)
Combine all values from self, and forward the partial results and the final result.

See reduce(into:_:) if the resulting producer needs to forward only the final result.
Declaration
Swift

public func scan(into initialResult: U, _ nextPartialResult: @escaping (inout U, Value) -> Void) -> Signal<U, Error>
Parameters

initialResult

The value to use as the initial accumulating value.

nextPartialResult

A closure that combines the accumulating value and the latest value from self. The result would be forwarded, and would be used in the next call of nextPartialResult.

Return Value

A signal that sends the partial results of the accumuation, and the final result as self completes.
skipRepeats(_:)
Forward only values from self that are not considered equivalent to its immediately preceding value.

Note

The first value is always forwarded.
Declaration
Swift

public func skipRepeats(_ isEquivalent: @escaping (Value, Value) -> Bool) -> Signal<Value, Error>
Parameters

isEquivalent

A closure to determine whether two values are equivalent.

Return Value

A signal which conditionally forwards values from self.
skip(while:)
Do not forward any value from self until shouldContinue returns false, at which point the returned signal starts to forward values from self, including the one leading to the toggling.
Declaration
Swift

public func skip(while shouldContinue: @escaping (Value) -> Bool) -> Signal<Value, Error>
Parameters

shouldContinue

A closure to determine whether the skipping should continue.

Return Value

A signal which conditionally forwards values from self.
take(untilReplacement:)
Forward events from self until replacement begins sending events.
Declaration
Swift

public func take(untilReplacement signal: Signal<Value, Error>) -> Signal<Value, Error>
Parameters

replacement

A signal to wait to wait for values from and start sending them as a replacement to self‘s values.

Return Value

A signal which passes through value, failed, and interrupted events from self until replacement sends an event, at which point the returned signal will send that event and switch to passing through events from replacement instead, regardless of whether self has sent events already.
take(last:)
Wait until self completes and then forward the final count values on the returned signal.
Declaration
Swift

public func take(last count: Int) -> Signal<Value, Error>
Parameters

count

Number of last events to send after self completes.

Return Value

A signal that receives up to count values from self after self completes.
take(while:)
Forward any values from self until shouldContinue returns false, at which point the returned signal would complete.
Declaration
Swift

public func take(while shouldContinue: @escaping (Value) -> Bool) -> Signal<Value, Error>
Parameters

shouldContinue

A closure to determine whether the forwarding of values should continue.

Return Value

A signal which conditionally forwards values from self.
zip(with:)
Zip elements of two signals into pairs. The elements of any Nth pair are the Nth elements of the two input signals.
Declaration
Swift

public func zip(with other: Signal<U, Error>) -> Signal<(Value, U), Error>
Parameters

otherSignal

A signal to zip values with.

Return Value

A signal that sends tuples of self and otherSignal.
throttle(_:on:)
Forward the latest value on scheduler after at least interval seconds have passed since the returned signal last sent a value.

If self always sends values more frequently than interval seconds, then the returned signal will send a value every interval seconds.

To measure from when self last sent a value, see debounce.

Seealso

debounce

Note

If multiple values are received before the interval has elapsed, the latest value is the one that will be passed on.

Note

If self terminates while a value is being throttled, that value will be discarded and the returned signal will terminate immediately.

Note

If the device time changed backwards before previous date while a value is being throttled, and if there is a new value sent, the new value will be passed anyway.

Precondition

interval must be non-negative number.
Declaration
Swift

public func throttle(_ interval: TimeInterval, on scheduler: DateScheduler ) -> Signal<Value, Error>
Parameters

interval

Number of seconds to wait between sent values.

scheduler

A scheduler to deliver events on.

Return Value

A signal that sends values at least interval seconds appart on a given scheduler.
throttle(while:on:)
Conditionally throttles values sent on the receiver whenever shouldThrottle is true, forwarding values on the given scheduler.

Note

While shouldThrottle remains false, values are forwarded on the given scheduler. If multiple values are received while shouldThrottle is true, the latest value is the one that will be passed on.

Note

If the input signal terminates while a value is being throttled, that value will be discarded and the returned signal will terminate immediately.

Note

If shouldThrottle completes before the receiver, and its last value is true, the returned signal will remain in the throttled state, emitting no further values until it terminates.
Declaration
Swift

public func throttle<P: PropertyProtocol >(while shouldThrottle: P, on scheduler: Scheduler ) -> Signal<Value, Error> where P.Value == Bool
Parameters

shouldThrottle

A boolean property that controls whether values should be throttled.

scheduler

A scheduler to deliver events on.

Return Value

A signal that sends values only while shouldThrottle is false.
debounce(_:on:discardWhenCompleted:)
Forward the latest value on scheduler after at least interval seconds have passed since self last sent a value.

If self always sends values more frequently than interval seconds, then the returned signal will never send any values.

To measure from when the returned signal last sent a value, see throttle.

Seealso

throttle

Note

If multiple values are received before the interval has elapsed, the latest value is the one that will be passed on.

Note

If self terminates while a value is being debounced, the behaviour will be determined by discardWhenCompleted. If true, that value will be discarded and the returned producer will terminate immediately. If false, that value will be delivered at the next debounce interval.

Precondition

interval must be non-negative number.
Declaration
Swift

public func debounce(_ interval: TimeInterval, on scheduler: DateScheduler , discardWhenCompleted: Bool = true) -> Signal<Value, Error>
Parameters

interval

A number of seconds to wait before sending a value.

scheduler

A scheduler to send values on.

discardWhenCompleted

A boolean to indicate if the latest value should be discarded on completion.

Return Value

A signal that sends values that are sent from self at least interval seconds apart.
uniqueValues(_:)
Forward only those values from self that have unique identities across the set of all values that have been seen.

Note

This causes the identities to be retained to check for uniqueness.
Declaration
Swift

public func uniqueValues<Identity: Hashable>(_ transform: @escaping (Value) -> Identity) -> Signal<Value, Error>
Parameters

transform

A closure that accepts a value and returns identity value.

Return Value

A signal that sends unique values during its lifetime.


 
 
 combineLatest(_:_:)

Combines the values of all the given signals, in the manner described by combineLatest(with:) .

Declaration

Swift

public static func combineLatest<B>(_ a: Signal<Value, Error>, _ b: Signal<B, Error>) -> Signal<(Value, B), Error>


 
 
 combineLatest(_:_:_:)

Combines the values of all the given signals, in the manner described by combineLatest(with:) .

Declaration

Swift

public static func combineLatest<B, C>(_ a: Signal<Value, Error>, _ b: Signal<B, Error>, _ c: Signal<C, Error>) -> Signal<(Value, B, C), Error>


 
 
 combineLatest(_:_:_:_:)

Combines the values of all the given signals, in the manner described by combineLatest(with:) .

Declaration

Swift

public static func combineLatest<B, C, D>(_ a: Signal<Value, Error>, _ b: Signal<B, Error>, _ c: Signal<C, Error>, _ d: Signal<D, Error>) -> Signal<(Value, B, C, D), Error>


 
 
 combineLatest(_:_:_:_:_:)

Combines the values of all the given signals, in the manner described by combineLatest(with:) .

Declaration

Swift

public static func combineLatest<B, C, D, E>(_ a: Signal<Value, Error>, _ b: Signal<B, Error>, _ c: Signal<C, Error>, _ d: Signal<D, Error>, _ e: Signal<E, Error>) -> Signal<(Value, B, C, D, E), Error>


 
 
 combineLatest(_:_:_:_:_:_:)

Combines the values of all the given signals, in the manner described by combineLatest(with:) .

Declaration

Swift

public static func combineLatest<B, C, D, E, F>(_ a: Signal<Value, Error>, _ b: Signal<B, Error>, _ c: Signal<C, Error>, _ d: Signal<D, Error>, _ e: Signal<E, Error>, _ f: Signal<F, Error>) -> Signal<(Value, B, C, D, E, F), Error>


 
 
 combineLatest(_:_:_:_:_:_:_:)

Combines the values of all the given signals, in the manner described by combineLatest(with:) .

Declaration

Swift

public static func combineLatest<B, C, D, E, F, G>(_ a: Signal<Value, Error>, _ b: Signal<B, Error>, _ c: Signal<C, Error>, _ d: Signal<D, Error>, _ e: Signal<E, Error>, _ f: Signal<F, Error>, _ g: Signal<G, Error>) -> Signal<(Value, B, C, D, E, F, G), Error>


 
 
 combineLatest(_:_:_:_:_:_:_:_:)

Combines the values of all the given signals, in the manner described by combineLatest(with:) .

Declaration

Swift

public static func combineLatest<B, C, D, E, F, G, H>(_ a: Signal<Value, Error>, _ b: Signal<B, Error>, _ c: Signal<C, Error>, _ d: Signal<D, Error>, _ e: Signal<E, Error>, _ f: Signal<F, Error>, _ g: Signal<G, Error>, _ h: Signal<H, Error>) -> Signal<(Value, B, C, D, E, F, G, H), Error>


 
 
 combineLatest(_:_:_:_:_:_:_:_:_:)

Combines the values of all the given signals, in the manner described by combineLatest(with:) .

Declaration

Swift

public static func combineLatest<B, C, D, E, F, G, H, I>(_ a: Signal<Value, Error>, _ b: Signal<B, Error>, _ c: Signal<C, Error>, _ d: Signal<D, Error>, _ e: Signal<E, Error>, _ f: Signal<F, Error>, _ g: Signal<G, Error>, _ h: Signal<H, Error>, _ i: Signal<I, Error>) -> Signal<(Value, B, C, D, E, F, G, H, I), Error>


 
 
 combineLatest(_:_:_:_:_:_:_:_:_:_:)

Combines the values of all the given signals, in the manner described by combineLatest(with:) .

Declaration

Swift

public static func combineLatest<B, C, D, E, F, G, H, I, J>(_ a: Signal<Value, Error>, _ b: Signal<B, Error>, _ c: Signal<C, Error>, _ d: Signal<D, Error>, _ e: Signal<E, Error>, _ f: Signal<F, Error>, _ g: Signal<G, Error>, _ h: Signal<H, Error>, _ i: Signal<I, Error>, _ j: Signal<J, Error>) -> Signal<(Value, B, C, D, E, F, G, H, I, J), Error>

combineLatest(_:)
Combines the values of all the given signals, in the manner described by combineLatest(with:) . No events will be sent if the sequence is empty.
Declaration
Swift

public static func combineLatest<S>(_ signals: S) -> Signal<[Value], Error> where S : Sequence, S.Element == Signal<Value, Error>


 
 
 zip(_:_:)