Iterator design pattern in Swift

This time I’ll give attention to the iterator design pattern. The sample is closely used within the Swift standard library, there are protocols that will provide you with assist if you have to create an iterator, however actually: I’ve by no means applied this sample immediately. 😅

The reality is that most likely in 99% of the use circumstances you may by no means need to take care of this sample, as a result of there’s superb assist for iterators built-in immediately into Swift. At all times use sequences, arrays, dictionaries as an alternative of immediately implementing this sample, nevertheless it’s good to know the way issues are working below the hood, is not it? 🙃

What’s the iterator desin sample?

Because the identify suggests, the sample lets you iterate over a set of parts. Right here is the definition from the gang of 4 guide:

Present a approach to entry the weather of an combination object sequentially with out exposing its underlying illustration.

Lengthy story brief the iterator offers you an interface that can allow you to iterate over collections no matter how they’re applied within the background. Here’s a fast instance of the idea above utilizing a string iterator.

import Basis

protocol StringIterator 
    func subsequent() -> String?


class ArrayStringIterator: StringIterator 

    personal let values: [String]
    personal var index: Int?

    init(_ values: [String]) 
        self.values = values
    

    personal func nextIndex(for index: Int?) -> Int? 
        if let index = index, index < self.values.rely - 1 
            return index + 1
        
        if index == nil, !self.values.isEmpty 
            return 0
        
        return nil
    

    func subsequent() -> String? 
        if let index = self.nextIndex(for: self.index) 
            self.index = index
            return self.values[index]
        
        return nil
    



protocol Iterable 
    func makeIterator() -> StringIterator


class DataArray: Iterable 

    personal var dataSource: [String]

    init() 
        self.dataSource = ["🐶", "🐔", "🐵", "🦁", "🐯", "🐭", "🐱", "🐮", "🐷"]
    

    func makeIterator() -> StringIterator 
        return ArrayStringIterator(self.dataSource)
    


let information = DataArray()
let iterator = information.makeIterator()

whereas let subsequent = iterator.subsequent() 
    print(subsequent)

As you’ll be able to see there are two predominant protocols and a very easy implementation for each of them. Our DataArray class now acts like an actual array, the underlying parts may be iterated via utilizing a loop. Let’s ditch the idea and re-implement the instance from above through the use of actual Swift commonplace library parts. 😉

Customized sequences in Swift

Swift has a built-in sequence protocol that can assist you creating iterators. Implementing your personal sequence in Swift is all about hiding your underlying information construction by making a customized iterator object. You simply need to retailer the present index and return your subsequent component in line with that every time the subsequent operate will get known as. 😛

import Basis

struct Emojis: Sequence 
    let animals: [String]

    func makeIterator() -> EmojiIterator 
        return EmojiIterator(self.animals)
    


struct EmojiIterator: IteratorProtocol 

    personal let values: [String]
    personal var index: Int?

    init(_ values: [String]) 
        self.values = values
    

    personal func nextIndex(for index: Int?) -> Int? 
        if let index = index, index < self.values.rely - 1 
            return index + 1
        
        if index == nil, !self.values.isEmpty 
            return 0
        
        return nil
    

    mutating func subsequent() -> String? 
        if let index = self.nextIndex(for: self.index) 
            self.index = index
            return self.values[index]
        
        return nil
    


let emojis = Emojis(animals: ["🐶", "🐔", "🐵", "🦁", "🐯", "🐭", "🐱", "🐮", "🐷"])
for emoji in emojis 
    print(emoji)

So the Sequence protocol is a generic counterpart of our customized iterable protocol used within the first instance. The IteratorProtocol is considerably just like the string iterator protocol used earlier than, however extra Swiftish and naturally extra generic.

So, that is nice. Lastly you understand how to create a customized sequence. Which is sweet if you would like to cover your information construction and supply a generic iterable interface. Think about what would occur in the event you have been about to start out utilizing a dictionary as an alternative of an array for storing named emojis with out an iterator that wraps them. 🤔

Now the factor is that there’s another tremendous helpful factor within the Swift commonplace library that I might like to speak about. That is proper, one abstraction degree up and right here we’re:

Customized collections in Swift

Collections are one step past sequences. Parts within them may be accessed by way of subscript in addition they outline each a startIndex and an endIndex, plus particular person parts of a set may be accessed a number of instances. Sounds good? 👍

Typically it may be helpful to create a custom collection sort. For instance if you would like to remove non-compulsory values. Think about a categorized favourite mechanism, for each class you’d have an array of favorites, so that you’d need to take care of empty and non-existing circumstances. With a custom collection you may cover that further code inside your customized information construction and supply a clear interface for the remainder of your app. 😍

class Favorites 

    typealias FavoriteType = [String: [String]]

    personal(set) var listing: FavoriteType

    public static let shared = Favorites()

    personal init() 
        self.listing = FavoriteType()
    



extension Favorites: Assortment 

    typealias Index = FavoriteType.Index
    typealias Ingredient = FavoriteType.Ingredient

    var startIndex: Index 
        return self.listing.startIndex
    
    var endIndex: Index 
        return self.listing.endIndex
    

    subscript(index: Index) -> Iterator.Ingredient 
        return self.listing[index]
    

    func index(after i: Index) -> Index 
        return self.listing.index(after: i)
    


extension Favorites 

    subscript(index: String) -> [String] 
        return self.listing[index] ?? []
    

    func add(_ worth: String, class: String) 
        if var values = self.listing[category] 
            guard !values.incorporates(worth) else 
                return
            
            values.append(worth)
            self.listing[category] = values
        
        else 
            self.listing[category] = [value]
        
    

    func take away(_ worth: String, class: String) 
        guard var values = self.listing[category] else 
            return
        
        values = values.filter  $0 == worth 

        if values.isEmpty 
            self.listing.removeValue(forKey: class)
        
        else 
            self.listing[category] = values
        
    



Favorites.shared.add("apple", class: "fruits")
Favorites.shared.add("pear", class: "fruits")
Favorites.shared.add("apple", class: "fruits")

Favorites.shared["fruits"]

Favorites.shared.take away("apple", class: "fruits")
Favorites.shared.take away("pear", class: "fruits")
Favorites.shared.listing

I do know, it is a actually dumb instance, nevertheless it demonstrates why collections are extra superior in comparison with pure sequences. Additionally within the hyperlinks beneath there are nice demos of nicely written collections. Be at liberty to study extra about these tremendous protocols and customized information sorts hidden (not so deep) contained in the Swift commonplace library. 🤐