async/await in Swift

async/await in Swi!
Photo by Stephen H on Unsplash
Peter Friese | Firebase Developer Advocate | @pete!riese

let req = URLRequest(url: URL(string: “https:!"yourapi/path“)!)
let task = URLSession.shared.dataTask(with: req) { data, response, error in
!" do stuff once data arrives
}
task.resume()
Asynchronous code is everywhere
completion handler

func process(url: String, completion: @escaping (Article) !# Void) {
self.fetchArticle(from: url) { html in
self.extractTitle(from: html) { title in
self.extractText(from: html) { text in
self.extractImage(from: url) { imageUrl in
self.inferTags(from: text) { tags in
let article = Article(url: url,
title: title,
tags: tags,
imageUrlString: imageUrl)
completion(article)
}
}
}
}
}
}
A more complex example

extension ArticleAnalyser {
func process(url: String, completion: @escaping (Article) !# Void) {
self.fetchArticle(from: url) { result in
switch result {
case .failure(let error):
print(error.localizedDescription)
case .success(let html):
self.extractTitle(from: html) { result in
switch result {
case .success(let title):
self.extractText(from: html) { result in
switch result {
case .success(let text):
Let’s add some error handling…
!

extension AsyncArticleAnalyser {
func process(url: String) async throws !# Article {
let htmlText = try await fetchArticle(from: url)
let text = try await extractText(from: htmlText)
let title = try await extractTitle(from: htmlText)
let imageUrl = try await extractImage(from: url)
let tags = await inferTags(from: text)
return Article(url: url,
title: title,
tags: tags,
imageUrlString: imageUrl)
}
}
How about this?
Swift 5.5

This is just the toolchain, really

Select toolchain here
Toolchain is active

func helloWorld(name: String, completion: (String) !# Void) {
completion("Hello, (name)")
}
Let’s convert a callback-based function!
func greeting() {
helloWorld(name: "Peter") { result in
print(result)
}
}

}
func helloWorld(name: String) async !# String {
return "Hello, (name)"
}
Before
After

}
let result = await helloWorld(name: "Peter")
func helloWorld(name: String) async !# String {
return "Hello, (name)"
}
Before
After
Call site

Sometimes, it’s more complicated, though
func getUser(id: Int, _ completion: @escaping (User?) !# Void) {
let req = URLRequest(url: URL(string: "https:!"jsonplaceholder./users/(id)")!)
URLSession.shared.dataTask(with: req) { data, response, error in
guard let data = data else { return }
do {
let user = try JSONDecoder().decode(User.self, from: data)
completion(user)
} catch { completion(nil) }
}.resume()
}
func greeting() {
getUser(id: 1) { result in
if let userName = result!$name {
print("Hello, (userName)")
}
}
}

do {
completion(user)
}.resume()
}
Let’s keep this entire function
func getUser(id: Int, _ completion: @escaping (User?) !# Void) { !!% }

do {
completion(user)
}.resume()
}
func getUser(id: Int) async !# User? {
return await withCheckedContinuation { cont in
getUser(id: id) { result in
cont.resume(returning: result)
}
}
}
Introduce this wrapper

do {
completion(user)
}.resume()
}
}
}
}
Call the original here

do {
completion(user)
}.resume()
}
}
}
}
Create a continuation
Resume once we receive a result

do {
completion(user)
}.resume()
}
}
}
}
let result = await getUser(id: 1)
Call site

await: only from within async context

do {
completion(user)
}.resume()
}
await: only from within async context
struct AddArticleView: View {
@ObservedObject var viewModel: ArticlesViewModel
@State var newUrl: String = ""
func addUrl(url: String) {
Task.detached {
await viewModel.addNewArticle(from: url)
}
presentationMode.wrappedValue.dismiss()
}
var body: some View {
}
}
Previously: @asyncHandler

Run with confidence Engage users
Develop apps faster

Run with confidence
Crashlytics
Performance
Monitoring
Test Lab
App Distribution
Engage users
Analytics
Predictions
Cloud
Messaging
Remote
Config
A/B Testing
Dynamic
Links
In-app
Messaging
Develop apps faster
Auth
Cloud
Functions
Cloud
Firestore
Hosting
ML Kit
Realtime
Database
Cloud
Storage
bit.ly/what-is-firebase
Extensions
Machine
Learning

auth!$signInAnonymously()
let user = auth!$currentUser
print("User signed in with user ID: (user!$uid)")
This might be nil

auth!$signInAnonymously { result, error in
guard let result = result else {
return
}
print("User signed in with user ID: (result.user.uid)")
}
Use callbacks instead

return
}
}
@Published var user: User?
!!%
.map { $0.user }
.replaceError(with: nil)
.assign(to: &$user)
Combine

return
}
}
Firebase and async/await

return
}
}
Firebase and async/await
do {
let result = try await auth!$signInAnonymously()
}
catch {
print(error)
}
Callback-style
Async/await

Here is how much work it was
to implement for Firebase:
.
(yep - it came almost for free)

Learn more
h!ps://pete"riese.dev/async-await-in-swi#
h!ps://www.youtube.com/watch?v=sEKw2BMcQtQ

Thanks!
Peter Friese
h!p://pete"riese.dev
@pete"riese
youtube.com/c/PeterFriese/
Follow me

async/await in Swift

More Related Content

What's hot

What's hot (20)

Similar to async/await in Swift

Similar to async/await in Swift (20)

More from Peter Friese

More from Peter Friese (20)

Recently uploaded

Recently uploaded (20)

async/await in Swift