Thursday, June 13, 2024
HomeIOS DevelopmentIterator design sample in Swift

Iterator design sample in Swift


This time I will deal with the iterator design sample. The sample is closely used within the Swift normal library, there are protocols that will provide you with assist if it’s essential to create an iterator, however actually: I’ve by no means applied this sample instantly. 😅

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

What’s the iterator design sample?

Because the identify suggests, the sample allows you to iterate over a group of components. Right here is the definition from the gang of 4 ebook:

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

Lengthy story brief the iterator provides 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 speculation above utilizing a string iterator.

import Basis

protocol StringIterator {
    func subsequent() -> String?
}

class ArrayStringIterator: StringIterator {

    non-public let values: [String]
    non-public var index: Int?

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

    non-public func nextIndex(for index: Int?) -> Int? {
        if let index = index, index < self.values.depend - 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 {

    non-public var dataSource: [String]

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

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

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

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

As you possibly can see there are two essential protocols and a very easy implementation for each of them. Our DataArray class now acts like an actual array, the underlying components will be iterated by utilizing a loop. Let’s ditch the speculation and re-implement the instance from above by utilizing actual Swift normal library parts. 😉

Customized sequences in Swift

Swift has a built-in sequence protocol that will help you creating iterators. Implementing your individual sequence in Swift is all about hiding your underlying knowledge construction by making a customized iterator object. You simply need to retailer the present index and return your subsequent ingredient in accordance with that every time the following perform will get known as. 😛

import Basis

struct Emojis: Sequence {
    let animals: [String]

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

struct EmojiIterator: IteratorProtocol {

    non-public let values: [String]
    non-public var index: Int?

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

    non-public func nextIndex(for index: Int?) -> Int? {
        if let index = index, index < self.values.depend - 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 Swift-ish and naturally extra generic.

So, that is nice. Lastly you understand how to create a customized sequence. Which is nice if you would like to cover your knowledge construction and supply a generic iterable interface. Think about what would occur for those who have been about to begin 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 yet one more tremendous helpful factor within the Swift normal library that I might like to speak about. That is proper, one abstraction stage up and right here we’re:

Customized collections in Swift

Collections are one step past sequences. Components within them will be accessed through subscript in addition they outline each a startIndex and an endIndex, plus particular person components of a group will be accessed a number of instances. Sounds good? 👍

Generally it may be helpful to create a customized assortment sort. For instance if you would like to remove non-obligatory 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 customized assortment you may disguise that additional code inside your customized knowledge construction and supply a clear interface for the remainder of your app. 😍

class Favorites {

    typealias FavoriteType = [String: [String]]

    non-public(set) var record: FavoriteType

    public static let shared = Favorites()

    non-public init() {
        self.record = FavoriteType()
    }
}


extension Favorites: Assortment {

    typealias Index = FavoriteType.Index
    typealias Aspect = FavoriteType.Aspect

    var startIndex: Index {
        return self.record.startIndex
    }
    var endIndex: Index {
        return self.record.endIndex
    }

    subscript(index: Index) -> Iterator.Aspect {
        return self.record[index]
    }

    func index(after i: Index) -> Index {
        return self.record.index(after: i)
    }
}

extension Favorites {

    subscript(index: String) -> [String] {
        return self.record[index] ?? []
    }

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

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

        if values.isEmpty {
            self.record.removeValue(forKey: class)
        }
        else {
            self.record[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.record

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 effectively written collections. Be at liberty to study extra about these tremendous protocols and customized knowledge sorts hidden (not so deep) contained in the Swift normal library. 🤐

RELATED ARTICLES

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Most Popular

Recent Comments