There is an updated edition of this book available! View Latest Edition

# 7 Sequence Operators Written by Shai Mishali

You can unlock the rest of this book, and our entire catalogue of books and videos, with a raywenderlich.com Professional subscription.

At this point, you know most of the operators that Combine has to offer! How great is that? There’s still one more category for you to dig into: Sequence Operators.

Sequence operators are easiest to understand when you realize that publishers are just sequences themselves. Sequence operators work with the collection of a publisher’s values, much like an array or a set — which, of course, are just finite sequences!

With that in mind, sequence operators mostly deal with the sequence as a whole and not with individual values, as other operator categories do.

Many of the operators in this category have nearly identical names and behaviors as their counterparts in the Swift standard library.

## Getting started

You can find the starter playground for this chapter in projects/Starter.playground. Throughout this chapter, you’ll add code to your playground and run it to see how these different sequence operators manipulate your publisher. You’ll use the `print` operator to log all publishing events.

## Finding values

The first section of this chapter consists of operators that locate specific values the publisher emits based on different criteria. These are similar to the collection methods in the Swift standard library.

### `min`

The `min` operator lets you find the minimum value emitted by a publisher. It’s greedy, which means it must wait for the publisher to send a `.finished` completion event. Once the publisher completes, only the minimum value is emitted by the operator:

``````example(of: "min") {
// 1
let publisher = [1, -50, 246, 0].publisher

// 2
publisher
.print("publisher")
.min()
.sink(receiveValue: { print("Lowest value is \(\$0)") })
.store(in: &subscriptions)
}
``````
``````——— Example of: min ———
publisher: receive subscription: ([1, -50, 246, 0])
publisher: request unlimited
Lowest value is -50
``````
``````example(of: "min non-Comparable") {
// 1
let publisher = ["12345",
"ab",
"hello world"]
.compactMap { \$0.data(using: .utf8) } // [Data]
.publisher // Publisher<Data, Never>

// 2
publisher
.print("publisher")
.min(by: { \$0.count < \$1.count })
// 3
let string = String(data: data, encoding: .utf8)!
print("Smallest data is \(string), \(data.count) bytes")
})
.store(in: &subscriptions)
}
``````
``````——— Example of: min non-Comparable ———
publisher: receive subscription: ([5 bytes, 2 bytes, 11 bytes])
publisher: request unlimited
Smallest data is ab, 2 bytes
``````

### `max`

As you’d guess, `max` works exactly like `min`, except that it finds the maximum value emitted by a publisher:

``````example(of: "max") {
// 1
let publisher = ["A", "F", "Z", "E"].publisher

// 2
publisher
.print("publisher")
.max()
.sink(receiveValue: { print("Highest value is \(\$0)") })
.store(in: &subscriptions)
}
``````
``````——— Example of: max ———
publisher: receive subscription: (["A", "F", "Z", "E"])
publisher: request unlimited
Highest value is Z
``````

### `first`

While the `min` and `max` operators deal with finding a published value at some unknown index, the rest of the operators in this section deal with finding emitted values at specific places, starting with the `first` operator.

``````example(of: "first") {
// 1
let publisher = ["A", "B", "C"].publisher

// 2
publisher
.print("publisher")
.first()
.sink(receiveValue: { print("First value is \(\$0)") })
.store(in: &subscriptions)
}
``````
``````——— Example of: first ———
publisher: receive subscription: (["A", "B", "C"])
publisher: request unlimited
First value is A
``````
``````example(of: "first(where:)") {
// 1
let publisher = ["J", "O", "H", "N"].publisher

// 2
publisher
.print("publisher")
.first(where: { "Hello World".contains(\$0) })
.sink(receiveValue: { print("First match is \(\$0)") })
.store(in: &subscriptions)
}
``````
``````——— Example of: first(where:) ———
publisher: receive subscription: (["J", "O", "H", "N"])
publisher: request unlimited
First match is H
``````

### `last`

Just as `min` has an opposite, `max`, `first` also has an opposite: `last`!

``````example(of: "last") {
// 1
let publisher = ["A", "B", "C"].publisher

// 2
publisher
.print("publisher")
.last()
.sink(receiveValue: { print("Last value is \(\$0)") })
.store(in: &subscriptions)
}
``````
``````——— Example of: last ———
publisher: receive subscription: (["A", "B", "C"])
publisher: request unlimited
Last value is C
``````

### `output(at:)`

The last two operators in this section don’t have counterparts in the Swift standard library. The `output` operators will only let values through if they’re emitted by the upstream publisher at the specified indices.

``````example(of: "output(at:)") {
// 1
let publisher = ["A", "B", "C"].publisher

// 2
publisher
.print("publisher")
.output(at: 1)
.sink(receiveValue: { print("Value at index 1 is \(\$0)") })
.store(in: &subscriptions)
}
``````
``````——— Example of: output(at:) ———
publisher: receive subscription: (["A", "B", "C"])
publisher: request unlimited
publisher: request max: (1) (synchronous)
Value at index 1 is B
``````

### `output(in:)`

You’ll wrap up this section with the second overload of the `output` operator: `output(in:)`.

``````example(of: "output(in:)") {
// 1
let publisher = ["A", "B", "C", "D", "E"].publisher

// 2
publisher
.output(in: 1...3)
receiveValue: { print("Value in range: \(\$0)") })
.store(in: &subscriptions)
}
``````
``````——— Example of: output(in:) ———
Value in range: B
Value in range: C
Value in range: D
finished
``````

## Querying the publisher

The following operators also deal with the entire set of values emitted by a publisher, but they don’t produce any specific value that it emits. Instead, these operators emit a different value representing some query on the publisher as a whole. A good example of this is the `count` operator.

### `count`

The `count` operator will emit a single number depicting how many values were emitted by the upstream publisher, once the publisher sends a `.finished` completion event:

``````example(of: "count") {
// 1
let publisher = ["A", "B", "C"].publisher

// 2
publisher
.print("publisher")
.count()
.sink(receiveValue: { print("I have \(\$0) items") })
.store(in: &subscriptions)
}
``````
``````——— Example of: count ———
publisher: receive subscription: (["A", "B", "C"])
publisher: request unlimited
I have 3 items
``````

### `contains`

Another useful operator is `contains`. You’ve probably used its counterpart in the Swift standard library more than once.

``````example(of: "contains") {
// 1
let publisher = ["A", "B", "C", "D", "E"].publisher
let letter = "C"

// 2
publisher
.print("publisher")
.contains(letter)
// 3
print(contains ? "Publisher emitted \(letter)!"
: "Publisher never emitted \(letter)!")
})
.store(in: &subscriptions)
}
``````
``````——— Example of: contains ———
publisher: receive subscription: (["A", "B", "C", "D", "E"])
publisher: request unlimited
Publisher emitted C!
``````
``````let letter = "C"
``````
``````let letter = "F"
``````
``````——— Example of: contains ———
publisher: receive subscription: (["A", "B", "C", "D", "E"])
publisher: request unlimited
Publisher never emitted F!
``````
``````example(of: "contains(where:)") {
// 1
struct Person {
let id: Int
let name: String
}

// 2
let people = [
(456, "Scott Gardner"),
(123, "Shai Mishali"),
(777, "Marin Todorov"),
(214, "Florent Pillet")
]
.map(Person.init)
.publisher

// 3
people
.contains(where: { \$0.id == 800 })
// 4
print(contains ? "Criteria matches!"
: "Couldn't find a match for the criteria")
})
.store(in: &subscriptions)
}
``````
``````——— Example of: contains(where:) ———
Couldn't find a match for the criteria
``````
``````.contains(where: { \$0.id == 800 })
``````
``````.contains(where: { \$0.id == 800 || \$0.name == "Marin Todorov" })
``````
``````——— Example of: contains(where:) ———
Criteria matches!
``````

### `allSatisfy`

A bunch of operators down, and only two to go! Both of them have counterpart collection methods in the Swift standard library.

``````example(of: "allSatisfy") {
// 1
let publisher = stride(from: 0, to: 5, by: 2).publisher

// 2
publisher
.print("publisher")
.allSatisfy { \$0 % 2 == 0 }
print(allEven ? "All numbers are even"
: "Something is odd...")
})
.store(in: &subscriptions)
}
``````
``````——— Example of: allSatisfy ———
publisher: request unlimited
All numbers are even
``````
``````let publisher = stride(from: 0, to: 5, by: 2).publisher
``````
``````let publisher = stride(from: 0, to: 5, by: 1).publisher
``````
``````——— Example of: allSatisfy ———
publisher: request unlimited
Something is odd...
``````

### `reduce`

Well, here we are! The final operator for this rather packed chapter: `reduce`.

``````Seed value is 0
Receives 1, 0 + 1 = 1
Receives 3, 1 + 3 = 4
Receives 7, 4 + 7 = 11
Emits 11
``````
``````example(of: "reduce") {
// 1
let publisher = ["Hel", "lo", " ", "Wor", "ld", "!"].publisher

publisher
.print("publisher")
.reduce("") { accumulator, value in
// 2
accumulator + value
}
.sink(receiveValue: { print("Reduced into: \(\$0)") })
.store(in: &subscriptions)
}
``````
``````——— Example of: reduce ———
publisher: receive subscription: (["Hel", "lo", " ", "Wor", "ld", "!"])
publisher: request unlimited
Reduced into: Hello World!
``````
``````.reduce("") { accumulator, value in
// 3
return accumulator + value
}
``````
``````.reduce("", +)
``````

## Key points

• Publishers are actually sequences, as they produce values much like collections and sequences do.
• You can use `min` and `max` to emit the minimum or maximum value emitted by a publisher, respectively.
• `first`, `last` and `output(at:)` are useful when you want to find a value emitted at a specific index. Use `output(in:)` to find values emitted within a range of indices.
• `first(where:)` and `last(where:)` each take a predicate to determine which values it should let through.
• Operators such as `count`, `contains` and `allSatisfy` don’t emit values emitted by the publisher. Rather, they emit a different value based on the emitted values.
• `contains(where:)` takes a predicate to determine if the publisher contains the given value.
• Use `reduce` to accumulate emitted values into a single value.

## Where to go from here?

Congrats on completing the last chapter on operators for this book! give yourself a quick pat on the back and high-five yourself while you’re at it. :]

Have a technical question? Want to report a bug? You can ask questions and report bugs to the book authors in our official book forum here.