SignalProducer

public struct SignalProducer<Value, Error: Swift.Error>

A SignalProducer creates Signals that can produce values of type Value and/or fail with errors of type Error. If no failure should be possible, NoError can be specified for Error.

SignalProducers can be used to represent operations or tasks, like network requests, where each invocation of start() will create a new underlying operation. This ensures that consumers will receive the results, versus a plain Signal, where the results might be sent before any observers are attached.

Because of the behavior of start(), different Signals created from the producer may see a different version of Events. The Events may arrive in a different order between Signals, or the stream might be completely different!

  • Initializes a SignalProducer that will emit the same events as the given signal.

    If the Disposable returned from start() is disposed or a terminating event is sent to the observer, the given signal will be disposed.

    Declaration

    Swift

    public init(_ signal: Signal<Value, Error>)

    Parameters

    signal

    A signal to observe after starting the producer.

  • Initializes a SignalProducer that will invoke the given closure once for each invocation of start().

    The events that the closure puts into the given observer will become the events sent by the started Signal to its observers.

    Note

    If the Disposable returned from start() is disposed or a terminating event is sent to the observer, the given CompositeDisposable will be disposed, at which point work should be interrupted and any temporary resources cleaned up.

    Declaration

    Swift

    public init(_ startHandler: @escaping (Signal<Value, Error>.Observer, CompositeDisposable) -> Void)

    Parameters

    startHandler

    A closure that accepts observer and a disposable.

  • Creates a producer for a Signal that will immediately send one value then complete.

    Declaration

    Swift

    public init(value: Value)

    Parameters

    value

    A value that should be sent by the Signal in a value event.

  • Creates a producer for a Signal that immediately sends one value, then completes.

    This initializer differs from init(value:) in that its sole value event is constructed lazily by invoking the supplied action when the SignalProducer is started.

    Declaration

    Swift

    public init(_ action: @escaping () -> Value)

    Parameters

    action

    A action that yields a value to be sent by the Signal as a value event.

  • Creates a producer for a Signal that will immediately fail with the given error.

    Declaration

    Swift

    public init(error: Error)

    Parameters

    error

    An error that should be sent by the Signal in a failed event.

  • Creates a producer for a Signal that will immediately send one value then complete, or immediately fail, depending on the given Result.

    Declaration

    Swift

    public init(result: Result<Value, Error>)

    Parameters

    result

    A Result instance that will send either value event if result is successful or failed event if result is a failure.

  • Creates a producer for a Signal that will immediately send the values from the given sequence, then complete.

    Declaration

    Swift

    public init<S: Sequence>(_ values: S) where S.Iterator.Element == Value

    Parameters

    values

    A sequence of values that a Signal will send as separate value events and then complete.

  • Creates a producer for a Signal that will immediately send the values from the given sequence, then complete.

    Declaration

    Swift

    public init(values first: Value, _ second: Value, _ tail: Value...)

    Parameters

    first

    First value for the Signal to send.
    second

    Second value for the Signal to send.
    tail

    Rest of the values to be sent by the Signal.

  • A producer for a Signal that will immediately complete without sending any values.

    Declaration

    Swift

    public static var empty: SignalProducer

  • A producer for a Signal that never sends any events to its observers.

    Declaration

    Swift

    public static var never: SignalProducer

  • Create a Signal from the producer, pass it into the given closure, then start sending events on the Signal when the closure has returned.

    The closure will also receive a disposable which can be used to interrupt the work associated with the signal and immediately send an interrupted event.

    Declaration

    Swift

    public func startWithSignal(_ setup: (_ signal: Signal<Value, Error>, _ interrupter: Disposable) -> Void)

    Parameters

    setUp

    A closure that accepts a signal and interrupter.

  • Extracts a signal producer from the receiver.

    Declaration

    Swift

    public var producer: SignalProducer

  • Create a Signal from the producer, then attach the given observer to the Signal as an observer.

    Declaration

    Swift

    public func start(_ observer: Signal<Value, Error>.Observer = .init()) -> Disposable

    Parameters

    observer

    An observer to attach to produced signal.

    Return Value

    A Disposable which can be used to interrupt the work associated with the signal and immediately send an interrupted event.

  • Convenience override for start(_:) to allow trailing-closure style invocations.

    Declaration

    Swift

    public func start(_ observerAction: @escaping Signal<Value, Error>.Observer.Action) -> Disposable

    Parameters

    observerAction

    A closure that accepts Event sent by the produced signal.

    Return Value

    A Disposable which can be used to interrupt the work associated with the signal and immediately send an interrupted event.

  • Create a Signal from the producer, then add an observer to the Signal, which will invoke the given callback when value or failed events are received.

    Declaration

    Swift

    public func startWithResult(_ result: @escaping (Result<Value, Error>) -> Void) -> Disposable

    Parameters

    result

    A closure that accepts a result that contains a .success case for value events or .failure case for failed event.

    Return Value

    A Disposable which can be used to interrupt the work associated with the Signal, and prevent any future callbacks from being invoked.

  • Create a Signal from the producer, then add exactly one observer to the Signal, which will invoke the given callback when a completed event is received.

    Declaration

    Swift

    public func startWithCompleted(_ completed: @escaping () -> Void) -> Disposable

    Parameters

    completed

    A closure that will be envoked when produced signal sends completed event.

    Return Value

    A Disposable which can be used to interrupt the work associated with the signal.

  • Creates a Signal from the producer, then adds exactly one observer to the Signal, which will invoke the given callback when a failed event is received.

    Declaration

    Swift

    public func startWithFailed(_ failed: @escaping (Error) -> Void) -> Disposable

    Parameters

    failed

    A closure that accepts an error object.

    Return Value

    A Disposable which can be used to interrupt the work associated with the signal.

  • Creates a Signal from the producer, then adds exactly one observer to the Signal, which will invoke the given callback when an interrupted event is received.

    Declaration

    Swift

    public func startWithInterrupted(_ interrupted: @escaping () -> Void) -> Disposable

    Parameters

    interrupted

    A closure that is invoked when interrupted event is received.

    Return Value

    A Disposable which can be used to interrupt the work associated with the signal.

  • Lift an unary Signal operator to operate upon SignalProducers instead.

    In other words, this will create a new SignalProducer which will apply the given Signal operator to every created Signal, just as if the operator had been applied to each Signal yielded from start().

    Declaration

    Swift

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

    Parameters

    transform

    An unary operator to lift.

    Return Value

    A signal producer that applies signal’s operator to every created signal.

  • Lift a binary Signal operator to operate upon SignalProducers instead.

    In other words, this will create a new SignalProducer which will apply the given Signal operator to every Signal created from the two producers, just as if the operator had been applied to each Signal yielded from start().

    Note

    starting the returned producer will start the receiver of the operator, which may not be adviseable for some operators.

    Declaration

    Swift

    public func lift<U, F, V, G>(_ transform: @escaping (Signal<Value, Error>) -> (Signal<U, F>) -> Signal<V, G>) -> (SignalProducer<U, F>) -> SignalProducer<V, G>

    Parameters

    transform

    A binary operator to lift.

    Return Value

    A binary operator that operates on two signal producers.

  • Lift a binary Signal operator to operate upon a Signal and a SignalProducer instead.

    In other words, this will create a new SignalProducer which will apply the given Signal operator to every Signal created from the two producers, just as if the operator had been applied to each Signal yielded from start().

    Declaration

    Swift

    public func lift<U, F, V, G>(_ transform: @escaping (Signal<Value, Error>) -> (Signal<U, F>) -> Signal<V, G>) -> (Signal<U, F>) -> SignalProducer<V, G>

    Parameters

    transform

    A binary operator to lift.

    Return Value

    A binary operator that works on Signal and returns SignalProducer.

  • Map each value in the producer to a new value.

    Declaration

    Swift

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

    Parameters

    transform

    A closure that accepts a value and returns a different value.

    Return Value

    A signal producer that, when started, will send a mapped value of self.

  • Map errors in the producer to a new error.

    Declaration

    Swift

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

    Parameters

    transform

    A closure that accepts an error object and returns a different error.

    Return Value

    A producer that emits errors of new type.

  • Maps each value in the producer 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 producer. 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<U>(on scheduler: Scheduler, transform: @escaping (Value) -> U) -> SignalProducer<U, Error>

    Parameters

    transform

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

    Return Value

    A producer that, when started, sends values obtained using transform as this producer sends values.

  • Preserve only the values of the producer that pass the given predicate.

    Declaration

    Swift

    public func filter(_ predicate: @escaping (Value) -> Bool) -> SignalProducer<Value, Error>

    Parameters

    predicate

    A closure that accepts value and returns Bool denoting whether value has passed the test.

    Return Value

    A producer that, when started, will send only the values passing the given predicate.

  • Applies transform to values from the producer and forwards values with non nil results unwrapped. - parameters: - transform: A closure that accepts a value from the value event and returns a new optional value.

    Declaration

    Swift

    public func filterMap<U>(_ transform: @escaping (Value) -> U?) -> SignalProducer<U, Error>

    Parameters

    transform

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

    Return Value

    A producer that will send new values, that are non nil after the transformation.

  • Yield the first count values from the input producer.

    Precondition

    count must be non-negative number.

    Declaration

    Swift

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

    Parameters

    count

    A number of values to take from the signal.

    Return Value

    A producer that, when started, will yield the first count values from self.

  • Yield an array of values when self completes.

    Note

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

    Declaration

    Swift

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

    Return Value

    A producer that, when started, will yield an array of values when self completes.

  • Yield an array of values until it reaches a certain count.

    Precondition

    count must be greater than zero.

    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.

    Declaration

    Swift

    public func collect(count: Int) -> SignalProducer<[Value], Error>

    Return Value

    A producer that, when started, collects at most count values from self, forwards them as a single array and completes.

  • Yield an array of values based on a predicate which matches the values collected.

    Note

    When self completes any remaining values will be sent, the last array may not match predicate. Alternatively, if were not collected any values will sent an empty array of values. 
    let (producer, observer) = SignalProducer<Int, NoError>.buffer(1)

producer
    .collect { values in values.reduce(0, combine: +) == 8 }
    .startWithValues { 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(_ predicate: @escaping (_ values: [Value]) -> Bool) -> SignalProducer<[Value], Error>

    Parameters

    predicate

    Predicate to match when values should be sent (returning true) or alternatively when they should be collected (where it should return false). The most recent value (value) is included in values and will be the end of the current array of values if the predicate returns true.

    Return Value

    A producer that, when started, collects values passing the predicate and, when self completes, forwards them as a single array and complets.

  • Yield an array of values based on a predicate which matches the values collected and the next value.

    Note

    When self completes any remaining values will be sent, the last array may not match predicate. Alternatively, if no values were collected an empty array will be sent. 
    let (producer, observer) = SignalProducer<Int, NoError>.buffer(1)

producer
    .collect { values, value in value == 7 }
    .startWithValues { 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(_ predicate: @escaping (_ values: [Value], _ value: Value) -> Bool) -> SignalProducer<[Value], Error>

    Parameters

    predicate

    Predicate to match when values should be sent (returning true) or alternatively when they should be collected (where it should return false). The most recent value (vaule) is not included in values and will be the start of the next array of values if the predicate returns true.

    Return Value

    A signal that will yield an array of values based on a predicate which matches the values collected and the next value.

  • Forward all events onto the given scheduler, instead of whichever scheduler they originally arrived upon.

    Declaration

    Swift

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

    Parameters

    scheduler

    A scheduler to deliver events on.

    Return Value

    A producer that, when started, will yield self values on provided scheduler.

  • Combine the latest value of the receiver with the latest value from the given producer.

    Note

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

    Note

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

    Note

    The returned producer will not complete until both inputs complete.

    Declaration

    Swift

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

    Parameters

    other

    A producer to combine self’s value with.

    Return Value

    A producer that, when started, will yield a tuple containing values of self and given producer.

  • Combine the latest value of the receiver with the latest value from the given signal.

    Note

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

    Note

    If either input is interrupted, the returned producer will also be interrupted.

    Note

    The returned producer will not complete until both inputs complete.

    Declaration

    Swift

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

    Parameters

    other

    A signal to combine self’s value with.

    Return Value

    A producer that, when started, will yield a tuple containing values of self and given signal.

  • Delay value and completed events by the given interval, forwarding them on the given scheduler.

    Note

    failed and interrupted events are always scheduled immediately.

    Declaration

    Swift

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

    Parameters

    interval

    Interval to delay value and completed events by.
    scheduler

    A scheduler to deliver delayed events on.

    Return Value

    A producer that, when started, will delay value and completed events and will yield them on given scheduler.

  • Skip the first count values, then forward everything afterward.

    Declaration

    Swift

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

    Parameters

    count

    A number of values to skip.

    Return Value

    A producer that, when started, will skip the first count values, then forward everything afterward.

  • Treats all Events from the input producer 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 producer will send the Event itself and then complete. When an interrupted event is received, the resulting producer will send the Event itself and then interrupt.

    Declaration

    Swift

    public func materialize() -> SignalProducer<Event<Value, Error>, NoError>

    Return Value

    A producer that sends events as its values.

  • Forward the latest value from self with the value from sampler as a tuple, only when sampler 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: SignalProducer<T, NoError>) -> SignalProducer<(Value, T), Error>

    Parameters

    sampler

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

    Return Value

    A producer that will send values from self and sampler, sampled (possibly multiple times) by sampler, then complete once both input producers have completed, or interrupt if either input producer is interrupted.

  • Forward the latest value from self with the value from sampler as a tuple, only when sampler 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, NoError>) -> SignalProducer<(Value, T), Error>

    Parameters

    sampler

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

    Return Value

    A producer that, when started, will send values from self and sampler, sampled (possibly multiple times) by sampler, then complete once both input producers have completed, or interrupt if either input producer is interrupted.

  • 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: SignalProducer<(), NoError>) -> SignalProducer<Value, Error>

    Parameters

    sampler

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

    Return Value

    A producer that, when started, will send values from self, sampled (possibly multiple times) by sampler, then complete once both input producers have completed, or interrupt if either input producer is interrupted.

  • 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<(), NoError>) -> SignalProducer<Value, Error>

    Parameters

    trigger

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

    Return Value

    A producer that will send values from self, sampled (possibly multiple times) by sampler, then complete once both inputs have completed, or interrupt if either input is interrupted.

  • 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<U>(from samplee: SignalProducer<U, NoError>) -> SignalProducer<(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. .

  • 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<U>(from samplee: Signal<U, NoError>) -> SignalProducer<(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. .

  • Forwards events from self until lifetime ends, at which point the returned producer will complete.

    Declaration

    Swift

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

    Parameters

    lifetime

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

    Return Value

    A producer that will deliver events until lifetime ends.

  • Forward events from self until trigger sends a value or completed event, at which point the returned producer will complete.

    Declaration

    Swift

    public func take(until trigger: SignalProducer<(), NoError>) -> SignalProducer<Value, Error>

    Parameters

    trigger

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

    Return Value

    A producer that will deliver events until trigger sends value or completed events.

  • Forward events from self until trigger sends a value or completed event, at which point the returned producer will complete.

    Declaration

    Swift

    public func take(until trigger: Signal<(), NoError>) -> SignalProducer<Value, Error>

    Parameters

    trigger

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

    Return Value

    A producer that will deliver events until trigger sends value or completed events.

  • Do not forward any values from self until trigger sends a value or completed, at which point the returned producer behaves exactly like producer.

    Declaration

    Swift

    public func skip(until trigger: SignalProducer<(), NoError>) -> SignalProducer<Value, Error>

    Parameters

    trigger

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

    Return Value

    A producer that will deliver events once the trigger sends value or completed events.

  • Do not forward any values from self until trigger sends a value or completed, at which point the returned signal behaves exactly like signal.

    Declaration

    Swift

    public func skip(until trigger: Signal<(), NoError>) -> SignalProducer<Value, Error>

    Parameters

    trigger

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

    Return Value

    A producer that will deliver events once the trigger sends value or completed events.

  • Forward events from self with history: values of the returned producer are a tuple 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) -> SignalProducer<(Value, Value), Error>

    Parameters

    initial

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

    Return Value

    A producer that sends tuples that contain previous and current sent values of self.

  • Send only the final value and then immediately completes.

    Declaration

    Swift

    public func reduce<U>(_ initial: U, _ combine: @escaping (U, Value) -> U) -> SignalProducer<U, Error>

    Parameters

    initial

    Initial value for the accumulator.
    combine

    A closure that accepts accumulator and sent value of self.

    Return Value

    A producer that sends accumulated value after self completes.

  • Aggregate self‘s values into a single combined value. When self emits its first value, combine is invoked with initial as the first argument and that emitted value as the second argument. The result is emitted from the producer returned from scan. That result is then passed to combine as the first argument when the next value is emitted, and so on.

    Declaration

    Swift

    public func scan<U>(_ initial: U, _ combine: @escaping (U, Value) -> U) -> SignalProducer<U, Error>

    Parameters

    initial

    Initial value for the accumulator.
    combine

    A closure that accepts accumulator and sent value of self.

    Return Value

    A producer that sends accumulated value each time self emits own value.

  • Forward only those values from self which do not pass isRepeat with respect to the previous value.

    Note

    The first value is always forwarded.

    Declaration

    Swift

    public func skipRepeats(_ isRepeat: @escaping (Value, Value) -> Bool) -> SignalProducer<Value, Error>

    Return Value

    A producer that does not send two equal values sequentially.

  • Do not forward any values from self until predicate returns false, at which point the returned producer behaves exactly like self.

    Declaration

    Swift

    public func skip(while predicate: @escaping (Value) -> Bool) -> SignalProducer<Value, Error>

    Parameters

    predicate

    A closure that accepts a value and returns whether self should still not forward that value to a producer.

    Return Value

    A producer that sends only forwarded values from self.

  • Forward events from self until replacement begins sending events.

    Declaration

    Swift

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

    Parameters

    replacement

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

    Return Value

    A producer which passes through value, failed, and interrupted events from self until replacement sends an event, at which point the returned producer will send that event and switch to passing through events from replacement instead, regardless of whether self has sent events already.

  • Forwards events from self until replacement begins sending events.

    Declaration

    Swift

    public func take(untilReplacement signal: Signal<Value, Error>) -> SignalProducer<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 producer which passes through value, failed, and interrupted events from self until replacement sends an event, at which point the returned producer will send that event and switch to passing through events from replacement instead, regardless of whether self has sent events already.

  • Wait until self completes and then forward the final count values on the returned producer.

    Declaration

    Swift

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

    Parameters

    count

    Number of last events to send after self completes.

    Return Value

    A producer that receives up to count values from self after self completes.

  • Forward any values from self until predicate returns false, at which point the returned producer will complete.

    Declaration

    Swift

    public func take(while predicate: @escaping (Value) -> Bool) -> SignalProducer<Value, Error>

    Parameters

    predicate

    A closure that accepts value and returns Bool value whether self should forward it to signal and continue sending other events.

    Return Value

    A producer that sends events until the values sent by self pass the given predicate.

  • Zip elements of two producers into pairs. The elements of any Nth pair are the Nth elements of the two input producers.

    Declaration

    Swift

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

    Parameters

    other

    A producer to zip values with.

    Return Value

    A producer that sends tuples of self and otherProducer.

  • Zip elements of this producer and a signal into pairs. The elements of any Nth pair are the Nth elements of the two.

    Declaration

    Swift

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

    Parameters

    other

    A signal to zip values with.

    Return Value

    A producer that sends tuples of self and otherSignal.

  • Apply operation to values from self with successful results forwarded on the returned producer and failures sent as failed events.

    Declaration

    Swift

    public func attempt(operation: @escaping (Value) -> Result<(), Error>) -> SignalProducer<Value, Error>

    Parameters

    operation

    A closure that accepts a value and returns a Result.

    Return Value

    A producer that receives successful Result as value event and failure as failed event.

  • Apply operation to values from self with successful results mapped on the returned producer and failures sent as failed events.

    Declaration

    Swift

    public func attemptMap<U>(_ operation: @escaping (Value) -> Result<U, Error>) -> SignalProducer<U, Error>

    Parameters

    operation

    A closure that accepts a value and returns a result of a mapped value as success.

    Return Value

    A producer that sends mapped values from self if returned Result is successful, failed events otherwise.

  • 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 producer 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.

    Declaration

    Swift

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

    Parameters

    interval

    Number of seconds to wait between sent values.
    scheduler

    A scheduler to deliver events on.

    Return Value

    A producer that sends values at least interval seconds appart on a given scheduler.

  • 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) -> SignalProducer<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 producer that sends values only while shouldThrottle is false.

  • 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, that value will be discarded and the returned producer will terminate immediately.

    Declaration

    Swift

    public func debounce(_ interval: TimeInterval, on scheduler: DateScheduler) -> SignalProducer<Value, Error>

    Parameters

    interval

    A number of seconds to wait before sending a value.
    scheduler

    A scheduler to send values on.

    Return Value

    A producer that sends values that are sent from self at least interval seconds apart.

  • Forward events from self until interval. Then if producer isn’t completed yet, fails with error on scheduler.

    Note

    If the interval is 0, the timeout will be scheduled immediately. The producer must complete synchronously (or on a faster scheduler) to avoid the timeout.

    Declaration

    Swift

    public func timeout(after interval: TimeInterval, raising error: Error, on scheduler: DateScheduler) -> SignalProducer<Value, Error>

    Parameters

    interval

    Number of seconds to wait for self to complete.
    error

    Error to send with failed event if self is not completed when interval passes.
    scheduler

    A scheduler to deliver error on.

    Return Value

    A producer that sends events for at most interval seconds, then, if not completed - sends error with failed event on scheduler.

  • Create a SignalProducer that will attempt the given operation once for each invocation of start().

    Upon success, the started signal will send the resulting value then complete. Upon failure, the started signal will fail with the error that occurred.

    Declaration

    Swift

    public static func attempt(_ operation: @escaping () -> Result<Value, Error>) -> SignalProducer<Value, Error>

    Parameters

    operation

    A closure that returns instance of Result.

    Return Value

    A SignalProducer that will forward successful result as value event and then complete or failed event if result is a failure.

  • 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) -> SignalProducer<Value, Error>

    Parameters

    transform

    A closure that accepts a value and returns identity value.

    Return Value

    A producer that sends unique values during its lifetime.

  • Injects side effects to be performed upon the specified producer events.

    Note

    In a composed producer, starting is invoked in the reverse direction of the flow of events.

    Declaration

    Swift

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

    Parameters

    starting

    A closure that is invoked before the producer is started.
    started

    A closure that is invoked after the producer is started.
    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 producer with attached side-effects for given event cases.

  • Start the returned producer on the given Scheduler.

    Note

    This implies that any side effects embedded in the producer will be performed on the given scheduler as well.

    Note

    Events may still be sent upon other schedulers — this merely affects where the start() method is run.

    Declaration

    Swift

    public func start(on scheduler: Scheduler) -> SignalProducer<Value, Error>

    Parameters

    scheduler

    A scheduler to deliver events on.

    Return Value

    A producer that will deliver events on given scheduler when started.

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

    Declaration

    Swift

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

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

    Declaration

    Swift

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

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

    Declaration

    Swift

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

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

    Declaration

    Swift

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

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

    Declaration

    Swift

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

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

    Declaration

    Swift

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

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

    Declaration

    Swift

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

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

    Declaration

    Swift

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

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

    Declaration

    Swift

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

  • Combines the values of all the given producers, in the manner described by combineLatest(with:). Will return an empty SignalProducer if the sequence is empty.

    Declaration

    Swift

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

  • Zips the values of all the given producers, in the manner described by zipWith.

    Declaration

    Swift

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

  • Zips the values of all the given producers, in the manner described by zipWith.

    Declaration

    Swift

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

  • Zips the values of all the given producers, in the manner described by zipWith.

    Declaration

    Swift

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

  • Zips the values of all the given producers, in the manner described by zipWith.

    Declaration

    Swift

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

  • Zips the values of all the given producers, in the manner described by zipWith.

    Declaration

    Swift

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

  • Zips the values of all the given producers, in the manner described by zipWith.

    Declaration

    Swift

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

  • Zips the values of all the given producers, in the manner described by zipWith.

    Declaration

    Swift

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

  • Zips the values of all the given producers, in the manner described by zipWith.

    Declaration

    Swift

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

  • Zips the values of all the given producers, in the manner described by zipWith.

    Declaration

    Swift

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

  • Zips the values of all the given producers, in the manner described by zipWith. Will return an empty SignalProducer if the sequence is empty.

    Declaration

    Swift

    public static func zip<S: Sequence>(_ producers: S) -> SignalProducer<[Value], Error>
		where S.Iterator.Element == SignalProducer<Value, Error>

  • Repeat self a total of count times. In other words, start producer count number of times, each one after previously started producer completes.

    Note

    Repeating 1 time results in an equivalent signal producer.

    Note

    Repeating 0 times results in a producer that instantly completes.

    Precondition

    count must be non-negative integer.

    Declaration

    Swift

    public func `repeat`(_ count: Int) -> SignalProducer<Value, Error>

    Parameters

    count

    Number of repetitions.

    Return Value

    A signal producer start sequentially starts self after previously started producer completes.

  • Ignore failures up to count times.

    Precondition

    count must be non-negative integer.

    Declaration

    Swift

    public func retry(upTo count: Int) -> SignalProducer<Value, Error>

    Parameters

    count

    Number of retries.

    Return Value

    A signal producer that restarts up to count times.

  • Wait for completion of self, then forward all events from replacement. Any failure or interruption sent from self is forwarded immediately, in which case replacement will not be started, and none of its events will be be forwarded.

    Note

    All values sent from self are ignored.

    Declaration

    Swift

    public func then<U>(_ replacement: SignalProducer<U, Error>) -> SignalProducer<U, Error>

    Parameters

    replacement

    A producer to start when self completes.

    Return Value

    A producer that sends events from self and then from replacement when self completes.

  • Wait for completion of self, then forward all events from replacement. Any failure or interruption sent from self is forwarded immediately, in which case replacement will not be started, and none of its events will be be forwarded.

    Note

    All values sent from self are ignored.

    Declaration

    Swift

    public func then<U>(_ replacement: SignalProducer<U, NoError>) -> SignalProducer<U, Error>

    Parameters

    replacement

    A producer to start when self completes.

    Return Value

    A producer that sends events from self and then from replacement when self completes.

  • Start the producer, then block, waiting for the first value.

    When a single value or error is sent, the returned Result will represent those cases. However, when no values are sent, nil will be returned.

    Declaration

    Swift

    public func first() -> Result<Value, Error>?

    Return Value

    Result when single value or failed event is received. nil when no events are received.

  • Start the producer, then block, waiting for events: value and completed.

    When a single value or error is sent, the returned Result will represent those cases. However, when no values are sent, or when more than one value is sent, nil will be returned.

    Declaration

    Swift

    public func single() -> Result<Value, Error>?

    Return Value

    Result when single value or failed event is received. nil when 0 or more than 1 events are received.

  • Start the producer, then block, waiting for the last value.

    When a single value or error is sent, the returned Result will represent those cases. However, when no values are sent, nil will be returned.

    Declaration

    Swift

    public func last() -> Result<Value, Error>?

    Return Value

    Result when single value or failed event is received. nil when no events are received.

  • Starts the producer, then blocks, waiting for completion.

    When a completion or error is sent, the returned Result will represent those cases.

    Declaration

    Swift

    public func wait() -> Result<(), Error>

    Return Value

    Result when single completion or failed event is received.

  • Creates a new SignalProducer that will multicast values emitted by the underlying producer, up to capacity. This means that all clients of this SignalProducer will see the same version of the emitted values/errors.

    The underlying SignalProducer will not be started until self is started for the first time. When subscribing to this producer, all previous values (up to capacity) will be emitted, followed by any new values.

    If you find yourself needing the current value (the last buffered value) you should consider using PropertyType instead, which, unlike this operator, will guarantee at compile time that there’s always a buffered value. This operator is not recommended in most cases, as it will introduce an implicit relationship between the original client and the rest, so consider alternatives like PropertyType, or representing your stream using a Signal instead.

    This operator is only recommended when you absolutely need to introduce a layer of caching in front of another SignalProducer.

    Precondition

    capacity must be non-negative integer.

    Declaration

    Swift

    public func replayLazily(upTo capacity: Int) -> SignalProducer<Value, Error>

    Parameters

    capacity

    Number of values to hold.

    Return Value

    A caching producer that will hold up to last capacity values.

  • concats next onto self.

    Declaration

    Swift

    public func concat(_ next: SignalProducer<Value, Error>) -> SignalProducer<Value, Error>

    Parameters

    next

    A follow-up producer to concat self with.

    Return Value

    A producer that will start self and then on completion of self - will start next.

  • concats value onto self.

    Declaration

    Swift

    public func concat(value: Value) -> SignalProducer<Value, Error>

    Parameters

    value

    A value to concat onto self.

    Return Value

    A producer that, when started, will emit own values and on completion will emit a value.

  • concats self onto initial previous.

    Declaration

    Swift

    public func prefix(_ previous: SignalProducer<Value, Error>) -> SignalProducer<Value, Error>

    Parameters

    previous

    A producer to start before self.

    Return Value

    A signal producer that, when started, first emits values from previous producer and then from self.

  • concats self onto initial value.

    Declaration

    Swift

    public func prefix(value: Value) -> SignalProducer<Value, Error>

    Parameters

    value

    A first value to emit.

    Return Value

    A producer that, when started, first emits value, then all values emited by self.

  • Merges the given producers into a single SignalProducer that will emit all values from each of them, and complete when all of them have completed.

    Declaration

    Swift

    public static func merge<Seq: Sequence>(_ producers: Seq) -> SignalProducer<Value, Error> where Seq.Iterator.Element == SignalProducer<Value, Error>

    Parameters

    producers

    A sequence of producers to merge.

  • Merges the given producers into a single SignalProducer that will emit all values from each of them, and complete when all of them have completed.

    Declaration

    Swift

    public static func merge(_ producers: SignalProducer<Value, Error>...) -> SignalProducer<Value, Error>

    Parameters

    producers

    A sequence of producers to merge.

  • Maps each event from self to a new producer, then flattens the resulting producers (into a producer of values), according to the semantics of the given strategy.

    Warning

    If self or any of the created producers fail, the returned producer will forward that failure immediately.

    Declaration

    Swift

    public func flatMap<U>(_ strategy: FlattenStrategy, transform: @escaping (Value) -> SignalProducer<U, Error>) -> SignalProducer<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.

  • Maps each event from self to a new producer, then flattens the resulting producers (into a producer of values), according to the semantics of the given strategy.

    Warning

    If self fails, the returned producer will forward that failure immediately.

    Declaration

    Swift

    public func flatMap<U>(_ strategy: FlattenStrategy, transform: @escaping (Value) -> SignalProducer<U, NoError>) -> SignalProducer<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.

  • Maps each event from self to a new producer, then flattens the resulting signals (into a producer of values), according to the semantics of the given strategy.

    Warning

    If self or any of the created signals emit an error, the returned producer will forward that error immediately.

    Declaration

    Swift

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

    Parameters

    strategy

    Strategy used when flattening signals.
    transform

    A closure that takes a value emitted by self and returns a signal with transformed value.

  • Maps each event from self to a new producer, then flattens the resulting signals (into a producer of values), according to the semantics of the given strategy.

    Warning

    If self emits an error, the returned producer will forward that error immediately.

    Declaration

    Swift

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

    Parameters

    strategy

    Strategy used when flattening signals.
    transform

    A closure that takes a value emitted by self and returns a signal with transformed value.

  • Maps each event from self to a new property, then flattens the resulting properties (into a producer of values), according to the semantics of the given strategy.

    Warning

    If self emits an error, the returned producer will forward that error immediately.

    Declaration

    Swift

    public func flatMap<P: PropertyProtocol>(_ strategy: FlattenStrategy, transform: @escaping (Value) -> P) -> SignalProducer<P.Value, Error>

    Parameters

    strategy

    Strategy used when flattening signals.
    transform

    A closure that takes a value emitted by self and returns a property with transformed value.

  • Catches any failure that may occur on the input producer, mapping to a new producer that starts in its place.

    Declaration

    Swift

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

    Parameters

    handler

    A closure that accepts emitted error and returns a signal producer with a different type of error.

  • 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.SignalProducer> = LoggingEvent.SignalProducer.allEvents,
	                      fileName: String = #file,
	                      functionName: String = #function,
	                      lineNumber: Int = #line,
	                      logger: @escaping EventLogger = defaultEventLog
	) -> SignalProducer<Value, Error>

    Parameters

    identifier

    a string to identify the SignalProducer 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 producer that, when started, logs the fired events.

  • Observe the binding source by sending any events to the given observer.

    Declaration

    Swift

    public func observe(_ observer: ProducedSignal.Observer, during lifetime: Lifetime) -> Disposable?

<U> Value == SignalProducer<U, Error>

  • Flattens the inner producers sent upon producer (into a single producer of values), according to the semantics of the given strategy.

    Note

    If producer or an active inner producer fails, the returned producer will forward that failure immediately.

    Warning

    interrupted events on inner producers will be treated like completed events on inner producers.

    Declaration

    Swift

    public func flatten(_ strategy: FlattenStrategy) -> SignalProducer<Value.Value, Error>

    Parameters

    strategy

    Strategy used when flattening signals.

<U, E> Value == SignalProducer<U, E>, Error == NoError

  • Flattens the inner producers sent upon producer (into a single producer of values), according to the semantics of the given strategy.

    Note

    If an active inner producer fails, the returned producer will forward that failure immediately.

    Warning

    interrupted events on inner producers will be treated like completed events on inner producers.

    Declaration

    Swift

    public func flatten(_ strategy: FlattenStrategy) -> SignalProducer<Value.Value, Value.Error>

    Parameters

    strategy

    Strategy used when flattening signals.

<U> Value == SignalProducer<U, NoError>, Error == NoError

  • Flattens the inner producers sent upon producer (into a single producer of values), according to the semantics of the given strategy.

    Warning

    interrupted events on inner producers will be treated like completed events on inner producers.

    Declaration

    Swift

    public func flatten(_ strategy: FlattenStrategy) -> SignalProducer<Value.Value, Value.Error>

    Parameters

    strategy

    Strategy used when flattening signals.

<U> Value == SignalProducer<U, NoError>

  • Flattens the inner producers sent upon signal (into a single signal of values), according to the semantics of the given strategy.

    Note

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

    Warning

    interrupted events on inner producers will be treated like completed events on inner producers.

    Declaration

    Swift

    public func flatten(_ strategy: FlattenStrategy) -> SignalProducer<Value.Value, Error>

    Parameters

    strategy

    Strategy used when flattening signals.

<U> Value == Signal<U, Error>

  • Flattens the inner signals sent upon producer (into a single producer of values), according to the semantics of the given strategy.

    Note

    If producer or an active inner signal emits an error, the returned producer will forward that error immediately.

    Warning

    interrupted events on inner signals will be treated like completed events on inner signals.

    Declaration

    Swift

    public func flatten(_ strategy: FlattenStrategy) -> SignalProducer<Value.Value, Error>

    Parameters

    strategy

    Strategy used when flattening signals.

<U, E> Value == Signal<U, E>, Error == NoError

  • Flattens the inner signals sent upon producer (into a single producer of values), according to the semantics of the given strategy.

    Note

    If an active inner signal emits an error, the returned producer will forward that error immediately.

    Warning

    interrupted events on inner signals will be treated like completed events on inner signals.

    Declaration

    Swift

    public func flatten(_ strategy: FlattenStrategy) -> SignalProducer<Value.Value, Value.Error>

    Parameters

    strategy

    Strategy used when flattening signals.

<U> Value == Signal<U, NoError>, Error == NoError

  • Flattens the inner signals sent upon producer (into a single producer of values), according to the semantics of the given strategy.

    Warning

    interrupted events on inner signals will be treated like completed events on inner signals.

    Declaration

    Swift

    public func flatten(_ strategy: FlattenStrategy) -> SignalProducer<Value.Value, Value.Error>

    Parameters

    strategy

    Strategy used when flattening signals.

<U> Value == Signal<U, NoError>

  • Flattens the inner signals sent upon producer (into a single producer of values), according to the semantics of the given strategy.

    Note

    If producer emits an error, the returned producer will forward that error immediately.

    Warning

    interrupted events on inner signals will be treated like completed events on inner signals.

    Declaration

    Swift

    public func flatten(_ strategy: FlattenStrategy) -> SignalProducer<Value.Value, Error>

    Parameters

    strategy

    Strategy used when flattening signals.

Value: Sequence

  • Flattens the sequence value sent by signal.

    Declaration

    Swift

    public func flatten() -> SignalProducer<Value.Iterator.Element, Error>

Value: PropertyProtocol

  • Flattens the inner properties sent upon signal (into a single signal of values), according to the semantics of the given strategy.

    Note

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

    Declaration

    Swift

    public func flatten(_ strategy: FlattenStrategy) -> SignalProducer<Value.Value, Error>

    Parameters

    strategy

    Strategy used when flattening signals.

Error == NoError

  • Maps each event from self to a new producer, then flattens the resulting producers (into a producer of values), according to the semantics of the given strategy.

    Warning

    If any of the created producers fail, the returned producer will forward that failure immediately.

    Declaration

    Swift

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

    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.

  • Maps each event from self to a new producer, then flattens the resulting producers (into a producer of values), according to the semantics of the given strategy.

    Declaration

    Swift

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

    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.

  • Maps each event from self to a new producer, then flattens the resulting signals (into a producer of values), according to the semantics of the given strategy.

    Warning

    If any of the created signals emit an error, the returned producer will forward that error immediately.

    Declaration

    Swift

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

    Parameters

    strategy

    Strategy used when flattening signals.
    transform

    A closure that takes a value emitted by self and returns a signal with transformed value.

  • Maps each event from self to a new producer, then flattens the resulting signals (into a producer of values), according to the semantics of the given strategy.

    Declaration

    Swift

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

    Parameters

    strategy

    Strategy used when flattening signals.
    transform

    A closure that takes a value emitted by self and returns a signal with transformed value.

  • Create a Signal from the producer, then add exactly one observer to the Signal, which will invoke the given callback when value events are received.

    Declaration

    Swift

    public func startWithValues(_ value: @escaping (Value) -> Void) -> Disposable

    Parameters

    value

    A closure that accepts a value carried by value event.

    Return Value

    A Disposable which can be used to interrupt the work associated with the Signal, and prevent any future callbacks from being invoked.

  • Promote a producer that does not generate failures into one that can.

    Note

    This does not actually cause failers to be generated for the given producer, but makes it easier to combine with other producers that may fail; for example, with operators like combineLatestWith, zipWith, flatten, etc.

    Declaration

    Swift

    public func promoteErrors<F: Swift.Error>(_: F.Type) -> SignalProducer<Value, F>

    Parameters

    _

    An ErrorType.

    Return Value

    A producer that has an instantiatable ErrorType.

  • Forward events from self until interval. Then if producer isn’t completed yet, fails with error on scheduler.

    Note

    If the interval is 0, the timeout will be scheduled immediately. The producer must complete synchronously (or on a faster scheduler) to avoid the timeout.

    Declaration

    Swift

    public func timeout<NewError: Swift.Error>(
		after interval: TimeInterval,
		raising error: NewError,
		on scheduler: DateScheduler
	) -> SignalProducer<Value, NewError>

    Parameters

    interval

    Number of seconds to wait for self to complete.
    error

    Error to send with failed event if self is not completed when interval passes.
    scheudler

    A scheduler to deliver error on.

    Return Value

    A producer that sends events for at most interval seconds, then, if not completed - sends error with failed event on scheduler.

  • Apply a failable operation to values from self with successful results forwarded on the returned producer and thrown errors sent as failed events.

    Declaration

    Swift

    public func attempt(_ operation: @escaping (Value) throws -> Void) -> SignalProducer<Value, AnyError>

    Parameters

    operation

    A failable closure that accepts a value.

    Return Value

    A producer that forwards successes as value events and thrown errors as failed events.

  • Apply a failable operation to values from self with successful results mapped on the returned producer and thrown errors sent as failed events.

    Declaration

    Swift

    public func attemptMap<U>(_ operation: @escaping (Value) throws -> U) -> SignalProducer<U, AnyError>

    Parameters

    operation

    A failable closure that accepts a value and attempts to transform it.

    Return Value

    A producer that sends successfully mapped values from self, or thrown errors as failed events.

  • Wait for completion of self, then forward all events from replacement.

    Note

    All values sent from self are ignored.

    Declaration

    Swift

    public func then<U, NewError: Swift.Error>(_ replacement: SignalProducer<U, NewError>) -> SignalProducer<U, NewError>

    Parameters

    replacement

    A producer to start when self completes.

    Return Value

    A producer that sends events from self and then from replacement when self completes.

<U> Value == U?

  • Unwraps non-nil values and forwards them on the returned signal, nil values are dropped.

    Declaration

    Swift

    public func skipNil() -> SignalProducer<Value.Wrapped, Error>

    Return Value

    A producer that sends only non-nil values.

<U, E> Value == Event<U, E>, Error == NoError

  • The inverse of materialize(), this will translate a producer of Event values into a producer of those events themselves.

    Declaration

    Swift

    public func dematerialize() -> SignalProducer<Value.Value, Value.Error>

    Return Value

    A producer that sends values carried by self events.

Error == AnyError

  • Create a SignalProducer that will attempt the given failable operation once for each invocation of start().

    Upon success, the started producer will send the resulting value then complete. Upon failure, the started signal will fail with the error that occurred.

    Declaration

    Swift

    public static func attempt(_ operation: @escaping () throws -> Value) -> SignalProducer<Value, AnyError>

    Parameters

    operation

    A failable closure.

    Return Value

    A SignalProducer that will forward a success as a value event and then complete or failed event if the closure throws.

  • Apply a failable operation to values from self with successful results forwarded on the returned producer and thrown errors sent as failed events.

    Declaration

    Swift

    public func attempt(_ operation: @escaping (Value) throws -> Void) -> SignalProducer<Value, AnyError>

    Parameters

    operation

    A failable closure that accepts a value.

    Return Value

    A producer that forwards successes as value events and thrown errors as failed events.

  • Apply a failable operation to values from self with successful results mapped on the returned producer and thrown errors sent as failed events.

    Declaration

    Swift

    public func attemptMap<U>(_ operation: @escaping (Value) throws -> U) -> SignalProducer<U, AnyError>

    Parameters

    operation

    A failable closure that accepts a value and attempts to transform it.

    Return Value

    A producer that sends successfully mapped values from self, or thrown errors as failed events.

Value: Equatable

  • Forward only those values from self which are not duplicates of the immedately preceding value.

    Note

    The first value is always forwarded.

    Declaration

    Swift

    public func skipRepeats() -> SignalProducer<Value, Error>

    Return Value

    A producer that does not send two equal values sequentially.

Value: Hashable

  • Forward only those values from self that are unique across the set of all values that have been seen.

    Note

    This causes the values to be retained to check for uniqueness. Providing a function that returns a unique value for each sent value can help you reduce the memory footprint.

    Declaration

    Swift

    public func uniqueValues() -> SignalProducer<Value, Error>

    Return Value

    A producer that sends unique values during its lifetime.

Value == Bool

  • Create a producer that computes a logical NOT in the latest values of self.

    Declaration

    Swift

    public func negate() -> SignalProducer<Value, Error>

    Return Value

    A producer that emits the logical NOT results.

  • Create a producer that computes a logical AND between the latest values of self and producer.

    Declaration

    Swift

    public func and(_ producer: SignalProducer<Value, Error>) -> SignalProducer<Value, Error>

    Parameters

    producer

    Producer to be combined with self.

    Return Value

    A producer that emits the logical AND results.

  • Create a producer that computes a logical AND between the latest values of self and signal.

    Declaration

    Swift

    public func and(_ signal: Signal<Value, Error>) -> SignalProducer<Value, Error>

    Parameters

    signal

    Signal to be combined with self.

    Return Value

    A producer that emits the logical AND results.

  • Create a producer that computes a logical OR between the latest values of self and producer.

    Declaration

    Swift

    public func or(_ producer: SignalProducer<Value, Error>) -> SignalProducer<Value, Error>

    Parameters

    producer

    Producer to be combined with self.

    Return Value

    A producer that emits the logical OR results.

  • Create a producer that computes a logical OR between the latest values of self and signal.

    Declaration

    Swift

    public func or(_ signal: Signal<Value, Error>) -> SignalProducer<Value, Error>

    Parameters

    signal

    Signal to be combined with self.

    Return Value

    A producer that emits the logical OR results.