tryMap – Augmented Code

Async-await in Swift is getting more popular as time goes by, but Combine publishers do not have built-in support for it currently. In this blog post, we’ll see how to expand some of the existing publishers.

Async-await supported sink

One case where I have encountered this is when I have wanted to call an async function in sink. Although I could wrap the call with Task within the sink subscriber, it gets unnecessary long if I need to do it in many places. Instead, we can just do it once and add an async-await supported sink subscriber.

	extension Publisher where Self.Failure == Never {
	func sink(receiveValue: @escaping ((Self.Output) async -> Void)) -> AnyCancellable {
	sink { value in
	Task {
	await receiveValue(value)
	}
	}
	}
	}

	// Allows writing sink without Task
	$imageURL
	.compactMap({ $0 })
	.sink { [weak self] url in
	await self?.processImageURL(url)
	}
	.store(in: &cancellables)

view raw ViewModel.swift hosted with ❤ by GitHub

Async-await supported map

The Combine framework has map and tryMap for supporting throwing functions, but is lacking something like tryAwaitMap for async throwing functions. Combine has a publisher named Future which supports performing asynchronous work and publishing a value. We can use this to wrap a Task with asynchronous work. Another publisher in Combine is flatMap what is used for turning one kind of publisher to a new kind of publisher. Therefore, we can combine these to turn a downstream publisher to a new publisher of type Future. The first tryAwaitMap below is for a case where the downstream publisher emits errors, and the second one is for the case where the downstream does not emit errors. We need to handle these separately since we need to tell Combine how error types are handled (non-throwing publisher has failure type set to Never).

	extension Publisher {
	public func tryAwaitMap<T>(_ transform: @escaping (Self.Output) async throws -> T) -> Publishers.FlatMap<Future<T, Error>, Self> {
	flatMap { value in
	Future { promise in
	Task {
	do {
	let result = try await transform(value)
	promise(.success(result))
	}
	catch {
	promise(.failure(error))
	}
	}
	}
	}
	}

	public func tryAwaitMap<T>(_ transform: @escaping (Self.Output) async throws -> T) -> Publishers.FlatMap<Future<T, Error>, Publishers.SetFailureType<Self, Error>> {
	// The same implementation but the returned publisher transforms failures with SetFailureType.
	}
	}

	// Case 1: throwing downstream publisher
	$imageURL
	.tryMap({ try Self.validateURL($0) })
	.tryAwaitMap({ try await ImageProcessor.process($0) })
	.map({ Image(uiImage: $0) })
	.sink(receiveCompletion: { print("completion: \($0)") },
	receiveValue: { print($0) })
	.store(in: &cancellables)

	// Case 2: non-throwing downstream publisher
	$imageURL
	.compactMap({ $0 })
	.tryAwaitMap({ try await ImageProcessor.process($0) })
	.map({ Image(uiImage: $0) })
	.sink(receiveCompletion: { print("completion: \($0)") },
	receiveValue: { print($0) })
	.store(in: &cancellables)

view raw ViewModel.swift hosted with ❤ by GitHub

If this was helpful, please let me know on Mastodon@toomasvahter or Twitter @toomasvahter. Feel free to subscribe to RSS feed. Thank you for reading.

Support me on Patreon

Donate with Paypal

Buy me a coffee