Combine

[Kharchevskyi]

Consider usage of Combine framework for handling async operations
https://developer.apple.com/documentation/combine

Pros:

• Native framework
• Declarative Swift API
• Easier to onboard new developers. Native and fast growing solution.
• Less number of dependencies in app
• Bunch of native operators(retry, map, filter and so on)
• Easier to switch between threads. So for example we can fetch folders on background thread and in easy way switch to main to save them to DB. More control over thread switching
• Easy retry for operation with just .retry(2)

private func getAndSaveFolders() -> Promise<[FolderViewModel]> {
        Promise<[FolderViewModel]> { [weak self] resolve, _ in
            guard let self = self else { throw AppErr.nilSelf }
            // fetch all folders
            let remoteFolders = try await(self.remoteFoldersProvider.fetchFolders())

            DispatchQueue.main.async {
                // save to Realm
                let folders = remoteFolders.compactMap(FolderObject.init)
                self.localFoldersProvider.save(folders: folders)

                // save trash folder path
                self.saveTrashFolderPath(with: folders)

                // return folders
                resolve(folders.map(FolderViewModel.init))
            }
      }
 }

vs (example)

fetchFolders
   .retry(2) 
   .map(FolderObject.init)
   .receive(on: .main)
   .save()
   .map(FolderViewModel.init)

• More control over threads

func fetch() -> Promise<[FolderViewModel]> {
        Promise(on: .main) { (_, _) in
            
        }
}

In case fetch() will be executed in another Promise with await(fetch()) this will cause to UI freeze

• Easier switch to SwiftUI(in some point in future)

Cons:

• Available from iOS 13

[tomholub]

I think it may be ok to not support iOS 12, but I'll have to check with our customer.

[Kharchevskyi]

#294

[tomholub]

Could you give me an example of what the following pseudo code could look like with Combine?

// method definition
async function someAsynchronousFunction(id: String): Promise<String> {
  const data = await getData(id)
  const key = await getKey(this.keyName)
  if(key == null) {
    throw new Error("Missing a key")
  }
  return await encrypt(data, key)
}

// method execution and error handling
someAsynchronousFunction(id).onSuccess({ encrypted =>
  this.renderEncryptedStuff(encrypted)
}).onError({ error =>
  this.renderError(error.message)
})

[tomholub]

I'm guessing, with current tooling it would look something like this?

// method definition
private func someAsynchronousFunction(id: String) -> Promise<String> {
    Promise<String> { [weak self] resolve, reject in
        guard let self = self else { throw AppErr.nilSelf }
        let data = try await(getData(id)) // hopefully it auto-rejects when this throws?
        let key = try await(getKey(self.keyName))
        if(key == null) {
            reject(Error("Missing a key"))
            return
        }
        resolve(try await(encrypt(data, key)))
    }
}

// method execution and error handling
someAsynchronousFunction(id)
    .then(on: .main) { [weak self] in
        self?.renderEncryptedStuff(encrypted)
    }
    .catch(on: .main) { [weak self] error in
        self?.renderError(error.message)
    }

[Kharchevskyi]

This is just an example with some useful operators, like retry,filter, breakpointOnError and tryMap and cancelling

import UIKit
import Combine
import SwiftUI
import PlaygroundSupport

var cancellable = Set<AnyCancellable>()

enum APIError: Error {
    case missedData
    case missedKey
}

func getData(for id: String) -> PassthroughSubject<String, APIError> {
    let subject = PassthroughSubject<String, APIError>()

    DispatchQueue.global().async {
        print("a")
        subject.send("data for id \(id)")
    }

    return subject
}

func getKey(for id: String) -> PassthroughSubject<String, APIError> {
    let subject = PassthroughSubject<String, APIError>()

    DispatchQueue.global().asyncAfter(deadline: .now() + 1) {
//        subject.send(completion: .failure(.missedKey))
        print("1")
        subject.send("key for id \(id)")
    }

    return subject
}

struct KeyData {
    let data: String
    let key: String
}

enum EncryptionError: Error {
    case failedToEncrypt
}

func encrypt(keyData: KeyData) throws -> StateOnUI {
    // for example some error occurs during encrypting
//    throw EncryptionError.failedToEncrypt
    print("return")
    return .keyData(KeyData(data: keyData.data, key: "encrypted"))
}

enum UIError: Error {
    case missedData
}

enum StateOnUI {
    case keyData(KeyData)
    case missedKey
}

// getting some data
let encryptedKeyData = Publishers
    .CombineLatest(getData(for: "123"), getKey(for: "123"))
    // retry fetching up to 3 times
    .retry(3)
    // will stops the process in the debugger with a breakpoint
    .breakpointOnError()
    // map data and key to some object
    .map(KeyData.init)
    // continue only if key contains some data
    .filter { $0.key.contains("encrypted") }
    // try to encrypt Key
    .tryMap(encrypt(keyData:))
    // retry encryption 2 times
    .retry(2)
    // if some error occurs it will replace this error with some UI state
    .replaceError(with: .missedKey)
    .eraseToAnyPublisher()


// For example we have image view which will show some image as a result
let imageView = UIImageView()
encryptedKeyData
    .map { (data) -> UIImage in
        switch data {
        case .keyData:
            let image = UIImage()
            return image
        case .missedKey:
            let anotherImage = UIImage()
            return anotherImage
        }
    }
    .assign(to: \.image, on: imageView)

// Or just do smth with this UI state
encryptedKeyData
    .receive(on: DispatchQueue.main)
    .sink(receiveValue: { value in
        print("do smth with \(value)")
    })
    .store(in: &cancellable)


// this operation can be canceled for example
cancellable.forEach {
    $0.cancel()
}

[tomholub]

Thank you - it's quite readable if there is a comment on every line like you did. Without it, I'd be lost. For understanding, could you please change this:

// getting some data
let encryptedKeyData = Publishers
    .CombineLatest(getData(for: "123"), getKey(for: "123"))
    // map data and key to some object
    .map(KeyData.init)
    // continue only if key contains some data
    .filter { $0.key.contains("encrypted") }
    // try to encrypt Key
    .tryMap(encrypt(keyData:))
    // if some error occurs it will replace this error with some UI state
    .replaceError(with: .missedKey)
    .eraseToAnyPublisher()

To:

1. render error, instead of stopping execution silently (when key is nil)
2. use encrypt method that accepts two arguments - data, key instead of a single object

---

As a separate prototype / pattern - it seems that Combine also has a concept of Futures and Promises, which seem to be observables that can only finish or error once: https://www.vadimbulavin.com/asynchronous-programming-with-future-and-promise-in-swift-with-combine-framework/

Could you please try to translate the following into promises or futures with Combine, to compare:

// method definition
private func someAsynchronousFunction(id: String) -> Promise<String> {
    Promise<String> { [weak self] resolve, reject in
        guard let self = self else { throw AppErr.nilSelf }
        let data = try await(getData(id)) // hopefully it auto-rejects when this throws?
        let key = try await(getKey(self.keyName))
        if(key == null) {
            reject(Error("Missing a key"))
            return
        }
        resolve(try await(encrypt(data, key)))
    }
}

// method execution and error handling
someAsynchronousFunction(id)
    .then(on: .main) { [weak self] in
        self?.renderEncryptedStuff(encrypted)
    }
    .catch(on: .main) { [weak self] error in
        self?.renderError(error.message)
    }

[Kharchevskyi]

This operators and chain is pretty common for iOS development
besides that this is more testable because actually all this .operator is function which have some input and output value

instead of binding UI to encryptedKeyData stream we can operate on plain data as before

Publishers
    .CombineLatest(getData(for: "123"), getKey(for: "123"))
    .map(KeyData.init)
    .filter { $0.key.contains("encrypted") }
    .sink { _ in
        print("Completion")
    } receiveValue: { keyData in
        // work with keyData 
    }

with 2 arguments

Publishers
    .CombineLatest(getData(for: "123"), getKey(for: "123"))
    .map { (data, key) in
        encrypt(data: data, key: key)
    }
    // or just (Swift is smart)
//    .map(encrypt)

Yes, basically Swift has Promises as part of combine

getFoldersCount()
    .sink(
        receiveCompletion: { result in
            guard case .failure(let error) = result else {
                return
            }
            
            print("error = \(error)")
        },
        receiveValue: { folderCount in
            print("count = \(folderCount)")
        })

beside that you can for example cancel execution or retry, map, combine or any other operation on Promise

[tomholub]

How to show an error if key is nil instead of filtering around it? Basically this:

        if(key == null) {
            reject(Error("Missing a key"))
            return
        }

[Kharchevskyi]

It can be shown by binding to some UI elements(not in scope of this issue), or quite similar to what we have now

func fetchKeyWithPossibleError(for id: String) -> Future<String, AppError>  {
    Future { promise in
        // some error occurred
        promise(.failure(.wrongParsing))
    }
}

fetchKeyWithPossibleError(for: "some id")
    .sink(
        receiveCompletion: { result in
            guard case .failure(let error) = result else {
                return
            }
            
            print("Here we can show some error message")
        },
        receiveValue: { key in
            print("Do smith with key")
        })