swift loop non sequence

Guri Bee

3 min read

·

21-10-2024

1

0

Share

Swift Looping Beyond Sequences: A Guide to Iteration Without the for in

You might think that in Swift, the only way to loop through data is using the for in loop with a sequence. But there's more to the story! This article explores the lesser-known but equally powerful ways to iterate in Swift, especially when you're working with data that doesn't conform to the Sequence protocol.

Why Go Beyond Sequences?

The for in loop is your go-to tool for iterating over sequences like arrays, strings, dictionaries, and ranges. But what happens when your data isn't neatly organized into a sequence? You might be dealing with:

• Custom Data Structures: Imagine a custom "Graph" data structure where you need to visit every connected node.
• Generators: These produce values on demand, one at a time, rather than storing them in a collection.
• API Responses: Sometimes you fetch data from an API in chunks, and you need to process each chunk individually.

For these cases, standard for in loops won't cut it. Let's delve into some alternative looping techniques that Swift provides.

1. while and repeat while

The classic while and repeat while loops shine when you need to iterate based on a condition, not a sequence.

Example: Finding the first even number in an array

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

var i = 0
while i < numbers.count {
    if numbers[i] % 2 == 0 {
        print("Found the first even number: \(numbers[i])")
        break // Exit the loop once the condition is met
    }
    i += 1
}

// Output: Found the first even number: 2

Key Points:

• You control the looping logic using a condition.
• The loop runs until the condition becomes false.
• The break statement is used to exit the loop early if needed.

Additional Note: The repeat while loop executes its code block at least once, regardless of the condition.

2. for loop with a custom Iterator

The power of for in loops lies in their ability to work with Sequence protocols. But you can extend this power by implementing your own IteratorProtocol!

Example: Iterating over the nodes of a custom "Graph" data structure

struct Node {
    let value: Int
    var neighbors: [Node]
}

struct GraphIterator: IteratorProtocol {
    var nodesToVisit: [Node]

    mutating func next() -> Node? {
        guard let node = nodesToVisit.first else { return nil }
        nodesToVisit.removeFirst()
        return node
    }
}

struct Graph {
    var nodes: [Node]
    
    func makeIterator() -> GraphIterator {
        return GraphIterator(nodesToVisit: nodes)
    }
}

let graph = Graph(nodes: [
    Node(value: 1, neighbors: [Node(value: 2, neighbors: []), Node(value: 3, neighbors: [])]),
    Node(value: 2, neighbors: []),
    Node(value: 3, neighbors: [])
])

for node in graph { // Using the 'for in' with the custom iterator
    print(node.value)
}

// Output: 1 2 3

Key Points:

• You define a GraphIterator conforming to IteratorProtocol.
• This iterator implements the next() function, which determines how to move through the data structure.
• The Graph structure provides a makeIterator() function, allowing you to use a for in loop to iterate over its elements.

This approach gives you full control over how you iterate through complex data structures.

3. forEach

If you just need to perform an action on each element without the need for explicit iteration control, forEach is your friend.

Example: Multiplying all elements in an array by 2

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

numbers.forEach { number in
    number *= 2
}

print(numbers) // Output: [2, 4, 6, 8, 10]

Key Points:

• It's concise and efficient for simple iteration tasks.
• It provides a closure to work with each element.

Conclusion

Don't limit your looping capabilities in Swift to just for in loops. Explore the powerful options presented by while, repeat while, custom iterators, and forEach. These techniques allow you to handle complex scenarios beyond standard sequences, giving you ultimate control over your data flow.

Note: The code examples in this article are heavily inspired by the discussion on "Swift Iterators" found here from the Swift Algorithm Club repository.