Contents

zip(_:_:_:)

Combines elements from three other publishers and delivers groups of elements as tuples.

Declaration

func zip<P, Q, R>(_ publisher1: P, _ publisher2: Q, _ publisher3: R) -> Publishers.Zip4<Self, P, Q, R> where P : Publisher, Q : Publisher, R : Publisher, Self.Failure == P.Failure, P.Failure == Q.Failure, Q.Failure == R.Failure

Parameters

  • publisher1:

    A second publisher.

  • publisher2:

    A third publisher.

  • publisher3:

    A fourth publisher.

Return Value

A publisher that emits groups of elements from the upstream publishers as tuples.

Discussion

Use zip(_:_:_:) to return a new publisher that combines the elements from three other publishers to publish a tuple to the downstream subscriber. The returned publisher waits until all four publishers have emitted an event, then delivers the oldest unconsumed event from each publisher as a tuple to the subscriber.

In this example, several PassthroughSubject instances emit values; zip(_:_:_:) receives the oldest unconsumed value from each publisher and combines them into a tuple that it republishes to the downstream:

let numbersPub = PassthroughSubject<Int, Never>()
let lettersPub = PassthroughSubject<String, Never>()
let emojiPub = PassthroughSubject<String, Never>()
let fractionsPub  = PassthroughSubject<Double, Never>()

cancellable = numbersPub
    .zip(lettersPub, emojiPub, fractionsPub)
    .sink { print("\($0)") }
numbersPub.send(1)         // numbersPub: 1       lettersPub:        emojiPub:       fractionsPub:         zip output: <none>
numbersPub.send(2)         // numbersPub: 1,2     lettersPub:        emojiPub:       fractionsPub:         zip output: <none>
numbersPub.send(3)         // numbersPub: 1,2,3   lettersPub:        emojiPub:       fractionsPub:         zip output: <none>
fractionsPub.send(0.1)     // numbersPub: 1,2,3   lettersPub: "A"    emojiPub:       fractionsPub: 0.1     zip output: <none>
lettersPub.send("A")       // numbersPub: 1,2,3   lettersPub: "A"    emojiPub:       fractionsPub: 0.1     zip output: <none>
emojiPub.send("πŸ˜€")        // numbersPub: 2,3     lettersPub: "A"    emojiPub: "πŸ˜€"  fractionsPub: 0.1     zip output: (1, "A", "πŸ˜€", 0.1)
lettersPub.send("B")       // numbersPub: 2,3     lettersPub: "B"    emojiPub:       fractionsPub:         zip output: <none>
fractionsPub.send(0.8)     // numbersPub: 2,3     lettersPub: "B"    emojiPub:       fractionsPub: 0.8     zip output: <none>
emojiPub.send("πŸ₯°")        // numbersPub: 3       lettersPub: "B"    emojiPub:       fractionsPub: 0.8     zip output: (2, "B", "πŸ₯°", 0.8)
// Prints:
//  (1, "A", "πŸ˜€", 0.1)
//  (2, "B", "πŸ₯°", 0.8)

If any upstream publisher finishes successfully or fails with an error, so too does the zipped publisher.

See Also

Collecting and republishing the oldest unconsumed elements from multiple publishers