05, Jul 2024

Swift: Sequence Types

Sequence types provide a unified interface for working with collections of elements. They offer a powerful way to iterate over, filter, map, and reduce collections of data. Let's explore the sequence types available in Swift, their key features, and best practices for using them to dramatically simplify what used to take quite a bit of boiler-plate code.




Understanding Sequence Types

A sequence type is any type that conforms to the `Sequence` protocol. This protocol defines a single requirement: the `makeIterator()` function implementation, which returns an `IteratorProtocol` that can be used to iterate over the sequence's elements.

protocol Sequence {
    associatedtype Element where Self.Element == Self.Iterator.Element

    func makeIterator() -> Self.Iterator
}

Here's a very minimal implementation for Sequence in a custom struct:

struct CustomSequence: Sequence {
    let items: [Element]
    func makeIterator() -> IndexingIterator<[Element]> {
        items.makeIterator()
    }
}


let customSequence = CustomSequence(items: [1,2,3,4,5])
print(customSequence.map({ $0 + 3 }))

Common Sequence types

Swift provides several built-in sequence types, including:

• Array: An ordered collection of elements of the same type.

print([1,2,3,4].map({ $0 + 3 }))

• Dictionary: An unordered collection of key-value pairs.

print(["one": 1, "two": 2].map({ $1 + 3 }))

• Set: An unordered collection of unique values.

print(Set([1,1,2,2,3,3,3]).map({ $0 + 3 }))

• Range: A sequence of consecutive values.

print((0..<5).map({ $0 + 3 }))

• String: A sequence of characters.

print("ABC".map({ $0.lowercased() }))

Sequence operations

Sequence types provide a rich set of operations for working with collections of data. Some of the most common operations include:

• Iteration: Use a `for-in` loop to iterate over the elements of a sequence.
• Filtering: Use the `filter` method to create a new sequence containing only the elements that satisfy a given condition.
• Mapping: Use the `map` method to create a new sequence by transforming each element of the original sequence.
• Reducing: Use the `reduce` method to combine the elements of a sequence into a single value.
• Chaining: Combine multiple sequence operations using chaining.

Example:

let numbers = [1, 2, 3, 4, 5]

// Filter even numbers
let evenNumbers = numbers.filter { $0 % 2 == 0 }

// Map numbers to their squares
let squares = evenNumbers.map { $0 • $0 }

// Reduce numbers to their sum
let sum = squares.reduce(0, +)

Or to make it shorter:

let numbers = [1, 2, 3, 4, 5]

let sum = numbers.filter { $0 % 2 == 0 }.map { $0 • $0 }.reduce(0, +)

Custom Sequences

As mentioned previously, you can create custom sequence types by conforming to the `Sequence` protocol and implementing the `makeIterator()` method.

struct FibonacciSequence: Sequence {
    typealias Element = Int

    func makeIterator() -> FibonacciIterator {
        return FibonacciIterator()
    }
}

struct FibonacciIterator: IteratorProtocol {

    var currentInt = 0
    var nextInt = 1

    mutating func next() -> Int? {
        guard currentInt < 100 else { return nil }
        let result = currentInt
        currentInt = nextInt
        nextInt += result
        return result
    }
}

print(Array(FibonacciSequence()))

It's very important to note the line `guard currentInt < 100 else { return nil }`; this puts a cap on what otherwise would become and infinite Sequence. What do you thing will happen if you remove that line and attempt to iterate over the Sequence?

Best Practices

• Choose the appropriate sequence type: It's very unlikely that your need for a Sequence is not already covered by one of the builtin collection types. So select the sequence type that best suits your needs.
• Use sequence operations effectively: Leverage the power of sequence operations to write concise and efficient transformative code.
• Consider performance implications: Some sequence operations can be computationally expensive depending on the operation and the size of the Sequence. The previous "Infinite Sequence" example is an extreme case for Sequence size consideration.
• Create custom sequences when necessary: Define custom sequences for specialized use cases while maintaining the importance of Sequence bounds consideration and operational cost.

---

Sequence types provide a powerful way to work with collections of data. By understanding the various sequence types and their operations, you can write much more concise code. Remember to choose the right sequence type for your specific use case and follow best practices to ensure your code is maintainable and performant.