Publishers

Converts a materialized publisher of Signals into the represented sequence. Fails on a malformed source sequence.

Use this operator to convert a stream of Signal values from an upstream publisher into its materially represented publisher type. Malformed sequences will fail with a DematerializationError.

For each element:

• .subscription elements are ignored
• .input(_) elements are unwrapped and forwarded to the subscriber
• .completion(_) elements are forwarded within the DematerializationError wrapper

If the integrity of the upstream sequence can be guaranteed, applying the assertNoDematerializationFailure() operator to this publisher will force unwrap any errors and produce a publisher with a Failure type that matches the materially represented original sequence.

Wraps all the elements as well as the subscription and completion events of an upstream publisher into a stream of Signal elements

Automates the process of connecting to a multicast publisher. Connects when the first subscriber connects then cancels and discards when the subscriber count falls to zero.

Configuration values for the Publishers.Signpost operator.

Pass Publishers.SignpostConfiguration.Marker values to the initializer to define how signposts for each event should be labelled:

• A nil marker value will disable signposts for that event
• A .default marker value will use the event name as the event label
• A .named(_:) marker value will use the passed string as the event label

A publisher that combines the latest value from another publisher with each value from an upstream publisher

Creates a simple publisher inline from a provided closure

This publisher can be used to turn any arbitrary source of values (such as a timer or a user authorization request) into a new publisher sequence.

From within the scope of the closure passed into the initializer, it is possible to call the methods of the Dispatcher object – which is passed in as a parameter – to send values down stream.

Example

import Entwine

let photoKitAuthorizationStatus = Publishers.Factory<PHAuthorizationStatus, Never> { dispatcher in
    let status = PHPhotoLibrary.authorizationStatus()
    dispatcher.forward(status)
    switch status {
    case .notDetermined:
        PHPhotoLibrary.requestAuthorization { newStatus in
            dispatcher.forward(newStatus)
            dispatcher.forward(completion: .finished)
        }
    default:
        dispatcher.forward(completion: .finished)
    }
    return AnyCancellable {}
}

When creating a publisher from a source with an unbounded rate of production that cannot be influenced, developers should consider following this operator with a Publishers.Buffer operator to prevent a strain on resources