Forem: Ahmed Komsan

Swift - Powerful Yet Overlooked Functions for problem solving -- Part 1

Ahmed Komsan — Sun, 30 Mar 2025 12:52:37 +0000

Swift is known for its simplicity and expressive syntax, but some incredibly powerful functions often go unnoticed. These lesser-known built-in functions can help solve common programming challenges more efficiently, making your code more readable, concise, and performant.

let's explore a set of Swift functions that will help you write cleaner, more elegant solutions to everyday problems.

What we'll cover

Smarter iteration and loops with stride
combining sequence and parallel Iteration with zip
Quick validation with allSatisfy(_:)
Lazy Sequence Generation with sequence
Categorizing data with Dictionary(grouping:by:)

Smarter iteration and loops with `stride`

Stride function provides a flexible way to create sequences of values based on a specific range and step, making it useful for various looping and iteration scenarios in Swift.

Swift provides two variations of stride:

stride(from:to:by:) Excludes the end value (to).
stride(from:through:by:) Includes the end value (through).

1. Creating a Range of Values with a Custom Step

// Excluding the last value
for value in stride(from: 0, to: 10, by: 2) {
    print(value)  // 0, 2, 4, 6, 8
}

// OR
let eventNumber: [Int] = stride(from: 0, to: 10, by: 2).map(\.self)
print(eventNumber) // [0, 2, 4, 6, 8]

// Including the last value
let eventNumberIncusive: [Int] = stride(from: 0, through: 10, by: 2).map(\.self) // inluding last element ( through )
print(eventNumberIncusive) // [0, 2, 4, 6, 8, 10]

2. Generating Reverse Sequences, iterate backward

let countdown = stride(from: 10, to: 0, by: -3).map { $0 }
print(countdown) // [10, 7, 4, 1]

3. Works with floating-point numbers

for value in stride(from: 0.0, through: 1.0, by: 0.2) {
    print(value) // 0.0, 0.2, 0.4, 0.6, 0.8, 1.0
}

4. Can be combined with higher-order functions like map, filter, and reduce for more data transformations

let squaredNumbers = stride(from: 1, through: 10, by: 2).map { $0 * $0 }
print(squaredNumbers) // [1, 9, 25, 49, 81]

`zip(_:_:)` – for combining sequence and parallel Iteration:

The zip function can be used to combine two or more sequences into a single sequence of tuples or iterating over two related arrays simultaneously

1. Combining Two Sequences into a Single Sequence of Tuples

let names = ["Alice", "Bob", "Charlie"]
let scores = [85, 92, 78]

let zipped = zip(names, scores)
zipped.forEach { print($0) } // ("Alice", 85), ("Bob", 92), ("Charlie", 78)

2. Iterate two collections in sync without manual indexing.

let letters = ["a", "b", "c"]
let numbers = [1, 2, 3]

for (letter, number) in zip(letters, numbers) {
    print("\(letter) - \(number)") // a - 1, b - 2, c - 3
}

Quick validation with `allSatisfy(_:)`

allSatisfy(_:) check whether all elements in a collection meet a specific condition, making validations more concise.

let numbers = [2, 4, 6, 8]
let allEven = numbers.allSatisfy { $0 % 2 == 0 }  // true

Lazy Sequence Generation with `sequence`

sequence is usefull for generating sequences lazily through the sequence function family. These functions are invaluable for creating memory-efficient, on-demand sequences.

Swift provides two variations of sequence:

sequence(first:next:) creates a sequence starting from an initial value and repeatedly applies a function to generate the next value until it returns nil.
sequence(state:next:) function maintains a state variable that you can mutate, making it useful for generating sequences with complex state tracking.

1. Finite squence with sequence(first:next:), stops when nil is returned

let countdown = sequence(first: 5, next: { $0 > 0 ? $0 - 1 : nil })
// 5, 4, 3, 2, 1, 0

2. Infinite squence with sequence(first:next:)

llet powersOfTwo = sequence(first: 1, next: { $0 * 2 })
print(Array( powersOfTwo.prefix(5))) // [1, 2, 4, 8, 16]

3. Finite squence with sequence(state:next:), stops when nil is returned

let countingUpToFive = sequence(state: 1) { state -> Int? in
    if state > 5 { return nil } // exit condition
    let result = state
    state = state + 1 // updated ( next ) state
    return result // previous state
}

print(Array(countingUpToFive)) // [1, 2, 3, 4, 5]

4. Infinite fibonacci squence with sequence(state:next:)

let fibonacci = sequence(state: (0, 1)) { state -> Int? in
    let result = state.0 // previous stat, we want the sequence to start with first element of initial/first state ( 0, 1)
    state = (state.1, state.0 + state.1) // updated ( next ) state
    return result // previous state
}

print(Array(fibonacci.prefix(10))) // [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

Categorizing data with `Dictionary(grouping:by:)`

Dictionary(grouping:by:)lets you group elements from a collection ( array or sequence ) into a dictionary based on a common key, making it great for categorizing data without manually iterating and sorting elements.

let words = ["apple", "banana", "avocado", "blueberry"]
let grouped = Dictionary(grouping: words, by: { $0.first! })
print(grouped) // ["a": ["apple", "avocado"], "b": ["banana", "blueberry"]]

let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
let groupedNumbers = Dictionary(grouping: numbers, by: { $0 % 2 == 0 ? "Even" : "Odd" })
print(groupedNumbers) // ["Even": [2, 4, 6, 8, 10], "Odd": [1, 3, 5, 7, 9]]

Conclusion

Competitive programming and real-world app development demand efficiency and clarity.
Swift isn’t just about syntax simplicity—it’s packed with hidden features that can significantly improve your code’s efficiency and readability. By integrating these powerful built-in functions into your workflow, you can eliminate unnecessary loops, reduce complexity, and enhance performance. Next time you tackle a complex problem, think about using stride for iteration, zip for parallel sequences, sequence for lazy evaluation, and Dictionary(grouping:by:) for effortless categorization.

If you think i missed anything, let me know and feel free to share with me any thoughts or feedback you have.

Thanks for reading!🚀

KeyPaths in swift

Ahmed Komsan — Thu, 24 Jun 2021 23:50:02 +0000

1 - What are Keypaths in swift
2 - Types of KeyPaths
- 2.1 ReferenceWritableKeyPath
- 2.2 WritableKeyPath
- 2.3 KeyPath
- 2.4 PartialKeyPath
- 2.5 AnyKeyPath
3 - Swift 5.2: Key path as functions
4 - Using keyPaths
See Also
Conclusion

1 - What are Keypaths in swift

KeyPath is an object that stores a reference to a property of a type, that keyPath object allow us later on to get/set their underlying value ( defer/stash getter and setter evaluation when needed ) using subscript operator. you can then pass these keypaths objects around to create an API with shorter and cleaner syntax.

let's see with an example, suppose we have a class Person:

class User {
    var fullName: String
    var email: String?
    var age: Int

    init(fullName: String, email: String? = nil, age: Int) {
        self.fullName = fullName
        self.email = email
        self.age = age
    }
}

given the User we can then create a keyPath object for any instance property ( fullName, email, age ) of the User type and use that keyPath later on to get/set the property value on a specific user instance:

let user = User(fullName: "Mike", age: 16)
let fullNameKeyPath = \User.fullName
// get fullName value using fullNameKeyPath
print( user[keyPath: fullNameKeyPath] ) // Mike
// set fullName value using fullNameKeyPath
user[keyPath: fullNameKeyPath] = "John"
print( user[keyPath: fullNameKeyPath] ) // John

and as you can see, the keyPath expression have the form \Root.path and the KeyPath declaration is

class KeyPath<Root, Value> : PartialKeyPath<Root>

keyPath takes two generic types: Root Type ( User is the example ) and Value Type which is the Type of the property the keyPath refers to ( String in case fullName, Int for age, String? for email ).

Note: at compile time, a key-path expression ( \Root.path ) is replaced by an instance of the keyPath class of the appropriate keyPath type ( we have 5 types of keypaths )

you can also make the keyPath expression nested or compound like,

class User {
   // ...
}
let user = User(fullName: "Mike", age: 16)
let fullNameEmptyKeyPath = \User.fullName.isEmpty
print(user[keyPath: fullNameEmptyKeyPath]) // false

let user = User(fullName: "Mike", age: 16)
let fullNamePath = \User.fullName
let isEmptyPath = \String.isEmpty

let fullNameIsEmptyKeyPath = fullNamePath.appending(path: isEmptyPath) // merge the two paths
print( user[keyPath: fullNameIsEmptyKeyPath] ) // read keyPath value -> false

and here the keyPath Root type is User and the Value is Bool ( isEmpty is Bool ) so the fullNameIsEmptyKeyPath is of type KeyPath<User, Bool>

2 - Types of KeyPaths

we have 5 types of keypaths represented by a hierarchy of 5 generic classes: ReferenceWritableKeyPath inherits from WritableKeyPath and WritableKeyPath inherits from KeyPath and so on.

Note: that hierarchy means ( for example ) if you have a function that takes KeyPath<Root,Type> as a parameter then you can pass also a keyPath of type WritableKeyPath and ReferenceWritableKeyPath as a parameter to hat function because both of theme inherits from KeyPath<Root,Type> but you cannot pass in a parameter of type PartialKeyPath or AnyKeyPath

let's explore the different keypaths types one by one and see when they can be used.

2.1 ReferenceWritableKeyPath

ReferenceWritableKeyPath works with Root of reference types ( class ) and mutable properties ( var ), this allows to read and write ( change ) the property value.

This is the one we have seen already in the previous example, as the User is class/reference type and the fullName property is var

class User {
   var fullName: String
    var email: String?
    var age: Int
  // ...
}
let fullNameKeyPath = \User.fullName
print(type(of: fullNameKeyPath)) // ReferenceWritableKeyPath<User, String>

Note: it doesn't matter wether the instance itself is var or let, what matters is the keyPath property should be mutable ( var ) to be able to change/write its value.

2.2 WritableKeyPath

WritableKeyPath works will Root of value types ( struct and enum ) and again allow us to read/write the keyPath property value of an instance taking into account the property should be var and the instance should be var also.

struct User {
    var fullName: String
    var email: String?
    var age: Int
}
var user = User(fullName: "Mike", age: 16) // instance should be var
let ageKeyPath = \User.age
// get fullName
print(user[keyPath: ageKeyPath]) // 16 
// set fullName
user[keyPath: ageKeyPath] = 20
print(user[keyPath: ageKeyPath]) // 20

print(type(of: ageKeyPath)) // WritableKeyPath<User, Int>

2.3 KeyPath

KeyPath is the simplest type, it can be used with both reference types ( classes ) and value types ( struct and enum ) as a Root type. it is used only for read property value ( read-only ) so it is only used for accessing immutable ( let ) properties.

struct User {  // or it can be -> class User 
    var fullName: String
    var email: String?
    let age: Int // Note: age is immutable
}
var user = User(fullName: "Mike", age: 16)
let ageKeyPath = \User.age
// get age
print(user[keyPath: ageKeyPath]) // 16
print(type(of: ageKeyPath)) // KeyPath<User, Int>

and if we tried changing the property value using the ageKeyPath.

user[keyPath: ageKeyPath] = 20  // error: cannot assign through subscript: 'ageKeyPath' is a read-only key path

2.4 PartialKeyPath

in the previous three keyPath types we know the two required types : the Root type ( User in our example ) and the Value Type ( String for fullName or Int for age ). But if we don't know the Value type of our keyPath or we need to be more flexible about the value type then we can use the PartialKeyPath<Root> which takes a reference to a property of any ValueType from specific Root type. this is beneficial when we need to write a functions that accepts a KeyPaths of different Value types but the same Root Type or we need to store multiple keyPaths of different Value types in an array.

struct User {
    var fullName: String
    var email: String?
    let age: Int
}

var user = User(fullName: "Mike", email: "aaa@test.com", age: 16)

let agePartialKeyPath: PartialKeyPath<User> = \User.age
let emailPartialKeyPath: PartialKeyPath<User> = \User.email
let fullNamePartialKeyPath: PartialKeyPath<User> = \User.fullName

let keyPathsList: [PartialKeyPath<User>] = [agePartialKeyPath,emailPartialKeyPath,fullNamePartialKeyPath]
keyPathsList.forEach { keypath in
    print(user[keyPath: keypath]) // 16, Optional("aaa@test.com"), Mike
}

2.5 AnyKeyPath

AnyKeyPath is the least restrictive one. it is fully type erased keyPath that can be used when the Root Type is unknown and the Value Type ( Path) is also unknown. this is very beneficial when we want to create an API that takes a keyPath of different Root types or we want to store multiple KeyPaths of different Root Types in an array.

struct Cat {
    var name: String
}

class User {
   // ...
}

var user = User(fullName: "Mike", email: "aaa@test.com", age: 16)

let userAgeKeyPath = \User.age // ReferenceWritableKeyPath<User, Int>
let userEmailKeyPath = \User.email // ReferenceWritableKeyPath<User, Optional<String>>
let userFullNameKeyPath = \User.fullName // ReferenceWritableKeyPath<User, String>

var cat = Cat(name: "Nala")
let catNameKeyPath = \Cat.name // WritableKeyPath<Cat, String>

let keyPathsList: [AnyKeyPath] = [userAgeKeyPath,userEmailKeyPath,userFullNameKeyPath,catNameKeyPath]

keyPathsList.forEach { keypath in
    if let keypath = keypath as? PartialKeyPath<User> {
        print(user[keyPath: keypath]) // // 16, Optional("aaa@test.com"), Mike
    }else if let keypath = keypath as? PartialKeyPath<Cat> {
        print(cat[keyPath: keypath]) // Nala
    }

}

here we create keypaths of different Value types and different Root types then we store them in an array of type AnyKeyPath.

since we are using AnyKeyPath we don't know any information about both the keypath Root type or the value Type and this is why we are trying to cast the keypath to PartialKeyPath<User> ( getter return Any ). we can for sure try to cast it to a more specific keypath like KeyPath<Cat, String> or KeyPath<User, String> and if the casting succeeds we know exactly both the Root Type and the Value Type.

let's recap,

KeyPath Type	Read	Write	Note
AnyKeyPath	Yes	No	unknown Root Type/ unknown Value Type
PartialKeyPath	Yes	No	known Root Type / unknown Value Type
KeyPath	Yes	No	known Root Type / known Value Type
WritableKeyPath	Yes	Yes	known Root Type / known Value Type for value types ( struct and enum ) ( var instance )
ReferenceWritableKeyPath	Yes	Yes	known Root Type / known Value Type, for class Type ( let or var instance)

3 - Swift 5.2: Key path as functions

Because closures of the form: (Root Type ) -> Value are common in Swift, Key path as functions is one of the features added to swift 5.2. it allows keypath to automatically be promoted and used wherever a functions of the form (Root ) -> Value are expected.

let's assume we have a list of users and we need to extract their full names,

struct User {
    var fullName: String
    var email: String?
    var age: Int
}

var firstUser = User(fullName: "Mike", email: "mike@test.com", age: 20)
var secondUser = User(fullName: "Adam", email: "adam@test.com", age: 25)
var ThirdUser = User(fullName: "John", email: "jogn@test.com", age: 30)
var users = [firstUser,secondUser,ThirdUser]

let usersNames = users.map { $0.fullName } // original
print(usersNames) // ["Mike", "Adam", "John"]

here we are passing to the map a function of the form ( User ) -> String return the users full names, in swift 5.2 we can instead pass a keypath for the user fullName property and pass it to the map.

let usersNames = users.map (\.fullName) // using keypath
print(usersNames)  // ["Mike", "Adam", "John"]

let fullNameKeyPath: (User) -> String = \User.fullName
let usersNames = users.map ( fullNameKeyPath )
print(usersNames)

but this way we need to be explicit about the keypath type let fullNameKeyPath: (User) -> String, because let fullNameKeyPath = \User.fullName is inferred as a keypath object not as a function ( default behavior ). by making the type explicit we are using the fullNameKeyPath as a function not as a keypath object.

let fullNameKeyPath = \User.fullName // inferred as WritableKeyPath<User, String>
let usersNames = users.map ( fullNameKeyPath ) // Error
print(usersNames)

4 - Using keyPaths

keypaths can be used on collection types to create generic algorithms and APIs with shorter and cleaner syntax. for instance let's say we want to sort an array containing elements of any Type and sort it by a specific property. with keypaths,

extension Sequence {
    func sorted<T: Comparable>(by keyPath: KeyPath<Element, T>) -> [Element] {
        return sorted { a, b in
            return a[keyPath: keyPath] < b[keyPath: keyPath]  // read
        }
    }
}

var firstUser = User(fullName: "Mike", email: "mike@test.com", age: 20)
var secondUser = User(fullName: "Adam", email: "adam@test.com", age: 25)
var ThirdUser = User(fullName: "John", email: "john@test.com", age: 30)
var users = [firstUser,secondUser,ThirdUser]

print( users.sorted(by: \.fullName))
// [User(fullName: "Adam", email: Optional("adam@test.com"), age: 25),
// User(fullName: "John", email: Optional("john@test.com"), age: 30),
// User(fullName: "Mike", email: Optional("mike@test.com"), age: 20)]
print( ["C","D","AB","A"].sorted(by: \.self) ) // ["A", "AB", "C", "D"]
print( ["C","D","AB","A"].sorted(by: \.count) ) // ["C", "D", "A", "AB"]

here we created an extension to the Sequence type, adding a new sorted(by keyPath:) that takes a keypath to sort the array based on that keypath value, so we can sort array of users by fullName, email, age or sort any array based on any Comparable property.

another example could be if we want to update a UILabel properties in a shorter syntax, we can do something like:

protocol Builder {}

extension Builder {
     func set<T>(_ keyPath:ReferenceWritableKeyPath<Self, T>,to newValue: T) -> Self {
        self[keyPath: keyPath] = newValue  // change property value
        return self
    }
}

extension UILabel: Builder { }

let label = UILabel()
    .set(\.text, to: "Hello world")
    .set(\.textColor, to: .red)
    .set(\.font, to: .systemFont(ofSize: 24, weight: .medium))

Note: if you want to apply this to any UIKit component, just make it conform to the Builder protocol just like we did with the UILabel like extension extension UIButton: Builder { }. but if we want to use this on any NSObject or any UIKit element then we can instead make the NSObject conforms to the Builder protocol extension NSObject: Builder { }.

as you can see, keypaths enable us to create many APIs with shorter syntax like creating DSL for working with layout constraints, algorithms on collections types and many other use cases.

Conclusion

keypaths introduced in Swift 4 to overcome the old #keyPath() syntax limitations available in Swift 3. As you might know #keyPath() is represented using a String which has a number of limitations.

#keyPath() works only with NSObjects
loss of type information, we don't know which type ( String,Int, ...etc ) the keypath refers to

KeyPaths are great and type safe as compared to the old #keyPath(), allow us to create a generic algorithms and APIs that are shorter and cleaner. keypaths are also used in SwiftUI and Combine framework in several places to keep the API concise.

If you think i missed anything, let me know and feel free to share with me any thoughts or feedback you have.

Thanks for reading!🚀

Getting Started with Diffable Data Source

Ahmed Komsan — Fri, 17 Jul 2020 12:12:34 +0000

Diffable Data Source is a new declarative API for UITableView and its counterpart UICollectionView introduced at WWDC19, IOS 13 as a replacement for UITableViewDataSource and UICollectionViewDataSource.

In this article we will take a brief look at UITableViewDataSource then we will go directly to the new API and see how it works with an example.

UITableViewDataSource

Previously, when working with UITableView or UICollectionView you would implement UITableViewDataSource protocol providing the table view with the details of how to display cells and supplementary views ( headers and footers ) and what data you want to render.

// Providing number of Rows and Sections
func tableView(UITableView, numberOfRowsInSection: Int) -> Int
func numberOfSections(in: UITableView) -> Int
// Providing Cells, Headers, and Footers
func tableView(UITableView, cellForRowAt: IndexPath) -> UITableViewCell
func tableView(UITableView, titleForHeaderInSection: Int) -> String?
func tableView(UITableView, titleForFooterInSection: Int) -> String?
// other datasource methods

whenever the models managed by the controller changes, you would normally reload the whole table view with reloadData() or performBatchUpdates(_:completion:) to update (insert, delete, move) only specific items or sections, doing something like :

self.tableView.performBatchUpdates({
    self.tableView.deleteRows(at: deletedIndexPaths, with: .fade)
    self.tableView.insertRows(at: insertedIndexPaths, with: .right)
}, completion: nil)

But you need to be careful when getting the changes occurred and make sure the changes applied in the right order.
Otherwise when updates go wrong, you will get something like:

Although UITableViewDataSource approach is simple and flexible but it is also error prone and a common source of bugs and crashes when there is misalignment between the current UI state and the models managed by the controller.

Diffable data source

Now with the UITableViewDiffableDataSource you can create datasource and apply the changes between states in more safe way in terms of snapshots that represent the current state ( rendered models ) of the table view.
To display or update the the data you just create an object of NSDiffableDataSourceSnapshot with the updated data and provide it to the data source through calling its apply(_:animatingDifferences:) method that will compare the current displayed snapshot ( rendered models ) with the new applied snapshot to get the differences then apply and animate those changes.

Getting Started

Now let's see an example of a contacts list screen with a search bar allowing the user to search his contacts by name.

As we mentioned, with the new approach we just need two types

UITableViewDiffableDataSource that has two generic types: Section type and item type, telling the table view how to display cells and supplementary views.
NSDiffableDataSourceSnapshot<SectionIdentifierType, ItemIdentifierType> : that represent a new or updated UI state to be displayed.

Create the model

Let's start by building our model which is a Contact that will be displayed in a table view cell.

struct Contact : Hashable {

  var id = UUID()
  var firstName: String
  var lastName: String
  var emailAddress: String

  func hash(into hasher: inout Hasher) {
    hasher.combine(id)
  }

  static func == (lhs: Contact, rhs: Contact) -> Bool {
    lhs.id == rhs.id
  }
}

Note : Diffable data source requires the two generic types SectionIdentifierType and ItemIdentifierType ( model ) to be Hashable, allowing the data source to perform diffing between different snapshots ( compare different UI States to know exactly what has been inserted, deleted or moved )

Setting up the data source

First let's create our Section type that will be used as SectionIdentifierType, containing two sections:

enum Section : Int , CaseIterable {
    case friendsContacts
    case allContacts
}

Then we create and configure our diffable data source that will provide that table view with details of how to display cells and supplementary view ( section headers and footers ).

typealias DataSource = UITableViewDiffableDataSource<Section, Contact>
private lazy var dataSource = makeDataSource()
// ...
func makeDataSource() -> DataSource {
    let dataSource = DataSource(tableView: tableView, cellProvider: {( tableView, indexPath, contact) -> UITableViewCell? in

        let cell = tableView.dequeueReusableCell(withIdentifier: ContactTableCell.reuseIdentifier, for: indexPath) as? ContactTableCell
        cell?.configure(with: contact)
        return cell
    })
    return dataSource
}

Note : That you would normally do by implementing cellForRowAt, titleForHeaderInSection and so on with the UITableViewDataSource

Creating a Snapshot

Now the table view knows exactly how to display data (models) and at this point we need to provide the table view with the data to be displayed.
This is where the NSDiffableDataSourceSnapshot comes in.

private var friendsContacts : [Contact] = Contact.friendsContacts
private var allContacts : [Contact] = Contact.allContacts
typealias Snapshot = NSDiffableDataSourceSnapshot<Section, Contact>

override func viewDidLoad(){
    super.viewDidLoad()
    // some other UI Configurations
    applySnapshot(animatingDifferences: false)
}

func applySnapshot(animatingDifferences: Bool = true) {
    var snapshot = Snapshot()
    snapshot.appendSections( Section.allCases )
    snapshot.appendItems(friendsContacts, toSection: .friendsContacts)
    snapshot.appendItems(allContacts, toSection: .allContacts)
    dataSource.apply(snapshot, animatingDifferences: animatingDifferences)
}

Creating a new snapshot with sections and items to be displayed. Whenever we apply a new snapshot, the table view will compare the currently displayed snapshot with the new applied one, to know exactly what's updated then apply and animate those updates accordingly.

Note : You can safely call apply() from the main queue or a background queue.

Add UISearchController

private var friendsContacts : [Contact] = Contact.friendsContacts
private var allContacts : [Contact] = Contact.allContacts
private var searchController = UISearchController(searchResultsController: nil)

override func viewDidLoad(){
    super.viewDidLoad()
    // some other UI Configurations
    configureSearchController()
}

extension ContactsTableViewController: UISearchResultsUpdating {

    func configureSearchController() {
        searchController.searchResultsUpdater = self
        searchController.obscuresBackgroundDuringPresentation = false
        searchController.searchBar.placeholder = "Search Contacts"
        navigationItem.searchController = searchController
        definesPresentationContext = true
    }

    func updateSearchResults(for searchController: UISearchController) {

        let myContacts = Contact.allContacts
        let myFriends = Contact.friendsContacts
        if let text = searchController.searchBar.text, !text.isEmpty {
            allContacts = myContacts.filter { contact in
                return contact.firstName.contains(text) || contact.lastName.contains(text)
            }
            friendsContacts = myFriends.filter { contact in
                return contact.firstName.contains(text) || contact.lastName.contains(text)
            }
        } else {
            allContacts = myContacts
            friendsContacts = myFriends
        }
        applySnapshot()
    }
}

Whenever the user changes the search text, we updates our allContacts and friendsContacts lists accordingly then apply a new snapshot with the updated lists to be displayed, that's it.

Note : what we are doing here is creating new snapshot from scratch then we apply it to the datasource.
Other-way we can get the currently displayed snapshot by calling dataSource.snapshot() then we can update that snapshot ( insert, remove, move ) and apply it back.

Supplementary Views

Let's finally add a header to both sections.
Assuming we need a custom header view.

class SectionHeaderReusableView: UITableViewHeaderFooterView {
   // whatever how it looks
}

Then we implement UITableViewDelegate needed methods, such as:

// MARK: - UITableViewDelegate

extension ContactsTableViewController {

    override func tableView(_ tableView: UITableView, heightForHeaderInSection section: Int) -> CGFloat {
        return 30
    }

    override func tableView(_ tableView: UITableView, heightForFooterInSection section: Int) -> CGFloat {
        return CGFloat.leastNormalMagnitude
    }

    override func tableView(_ tableView: UITableView, viewForHeaderInSection section: Int) -> UIView? {
        guard let header = tableView.dequeueReusableHeaderFooterView(
            withIdentifier: SectionHeaderReusableView.reuseIdentifier) as? SectionHeaderReusableView
        else {
            return nil
        }

        if section == Section.allContacts.rawValue {
            header.titleLabel.text = "Your Contacts"
        } else {
            header.titleLabel.text = "Friends Contacts"
        }

        return header
    }

    override func tableView(_ tableView: UITableView, viewForFooterInSection section: Int) -> UIView? {
        return nil
    }

}

Note : If you want to use titleForHeaderInSection and titleForFooterInSection both part of UITableViewDataSource, you can simply create UITableViewDiffableDataSource subclass and override the methods of you want to implement.

class MyDataSource: UITableViewDiffableDataSource<Section, Contact> {
  override func tableView(_ tableView: UITableView, titleForHeaderInSection section: Int) -> String? {
    return "This is section: \(section)"
  }
}

Final Result

Source Code

You can find the demo source code here

Conclusion

As you can see, Diffable Data Source makes it much easier to work with UITableView and UICollectionView by hiding most of the complexity related to synchronization between the UI State and the datasource.

If you think i missed anything, let me know and feel free to share with me any thoughts or feedback you have.

Thanks for reading!🚀🌌

Forem: Ahmed Komsan

Swift - Powerful Yet Overlooked Functions for problem solving -- Part 1

What we'll cover

Smarter iteration and loops with stride

zip(_:_:) – for combining sequence and parallel Iteration:

Quick validation with allSatisfy(_:)

Lazy Sequence Generation with sequence

Categorizing data with Dictionary(grouping:by:)

Conclusion

KeyPaths in swift

1 - What are Keypaths in swift

2 - Types of KeyPaths

2.1 ReferenceWritableKeyPath

2.2 WritableKeyPath

2.3 KeyPath

2.4 PartialKeyPath

2.5 AnyKeyPath

3 - Swift 5.2: Key path as functions

4 - Using keyPaths

See Also

Conclusion

Getting Started with Diffable Data Source

UITableViewDataSource

Diffable data source

Getting Started

Create the model

Setting up the data source

Creating a Snapshot

Add UISearchController

Supplementary Views

Final Result

Source Code

See Also

Conclusion

Smarter iteration and loops with `stride`

`zip(_:_:)` – for combining sequence and parallel Iteration:

Quick validation with `allSatisfy(_:)`

Lazy Sequence Generation with `sequence`

Categorizing data with `Dictionary(grouping:by:)`