✨ Add code for Chapter 14 - Getting Started with async/await

Author: peterfriese

Chapter 14 - Getting Started with async-await/Getting Started with async await Playground.playground/Pages/Asynchronous Completion Handlers.xcplaygroundpage/Contents.swift

@@ -0,0 +1,75 @@
+/*:
+ [<Previous](@previous)  [Home](Introduction)  [Next>](@next)
+
+ # Asynchronous Completion Handlers
+ 
+ This sample shows how to use Grand Central Dispatch and completion handlers to prepare a sandwich.
+ 
+ The steps to prepare a sandwich are:
+ * toasting two slices of bread
+ * slicing the ingredients (e.g. cucumbers, tomatoes) for the sandwich
+ * spreading condiments on the bread
+ * layering the ingredients on top of one slice of bread
+ * putting a leaf of lettuce on top
+ * putting another slice of bread on top
+ 
+ Some of these steps might take a while, for example toasting the bread or slicing the ingredients.
+
+ Completion handlers are a common way to deal with asynchronous code. They are typically implemented using (trailing) closures.
+ This example uses `DispatchQueue` to execute long-running conde asynchronously on a background thread.
+ */
+
+import Foundation
+import PlaygroundSupport
+
+PlaygroundPage.current.needsIndefiniteExecution = true
+
+func makeSandwich(bread: String, ingredients: [String], condiments: [String], completion: @escaping (String) -> Void) {
+  sandwichMakerSays("Preparing your sandwich...")
+  
+  toastBread(bread) { toasted in
+    slice(ingredients) { sliced in
+      sandwichMakerSays("Spreading \(condiments.joined(separator: ", and ")) om \(toasted)")
+      sandwichMakerSays("Layering \(sliced.joined(separator: ", "))")
+      sandwichMakerSays("Putting lettuce on top")
+      sandwichMakerSays("Putting another slice of bread on top")
+      
+      completion("\(ingredients.joined(separator: ", ")), \(condiments.joined(separator: ", ")) on \(toasted)")
+    }
+  }
+  print("This code will be executed *before* the bread is toasted and the ingredients are sliced.")
+}
+
+func toastBread(_ bread: String, completion: @escaping (String) -> Void) {
+  DispatchQueue.global().async {
+    sandwichMakerSays("Toasting the bread... Standing by...", waitFor: 5)
+    completion("Crispy \(bread)")
+  }
+}
+
+func slice(_ ingredients: [String], completion: @escaping ([String]) -> Void) {
+  DispatchQueue.global().async {
+    let result = ingredients.map { ingredient in
+      sandwichMakerSays("Slicing \(ingredient)", waitFor: 1)
+      return "sliced \(ingredient)"
+    }
+    completion(result)
+  }
+}
+
+sandwichMakerSays("Hello to Cafe Complete, where we handle your order with care.")
+sandwichMakerSays("Please place your order.")
+
+let clock = ContinuousClock()
+let start = clock.now
+makeSandwich(bread: "Rye", ingredients: ["Cucumbers", "Tomatoes"], condiments: ["Mayo", "Mustard"]) { sandwich in
+  customerSays("Hmmm.... this looks like a delicious \(sandwich) sandwich!")
+  
+  let time = clock.now - start
+  print("Making this sandwich took \(time)")
+}
+
+print("The end.") // notice how this code will be executed **before** the sandwich has been delivered to the customer!
+
+//: [<Previous](@previous)  [Home](Introduction)  [Next>](@next)
+

Chapter 14 - Getting Started with async-await/Getting Started with async await Playground.playground/Pages/Completion Handlers.xcplaygroundpage/Contents.swift

@@ -0,0 +1,97 @@
+/*:
+ [<Previous](@previous)  [Home](Introduction)  [Next>](@next)
+ 
+ # Completion Handlers
+ 
+ This sample shows how to use completion handlers to prepare a sandwich.
+ 
+ The steps to prepare a sandwich are:
+ * toasting two slices of bread
+ * slicing the ingredients (e.g. cucumbers, tomatoes) for the sandwich
+ * spreading condiments on the bread
+ * layering the ingredients on top of one slice of bread
+ * putting a leaf of lettuce on top
+ * putting another slice of bread on top
+ 
+ Some of these steps might take a while, for example toasting the bread or slicing the ingredients.
+ 
+ Completion handlers are a common way to deal with asynchronous code. They are typically implemented using (trailing) closures. Note that, in this sample, we don't execute any part of the code asynchronously. The completion handlers in this sample are merely used to structure the way the individual parts of the app play together. Instead of calling a function and then receiving its return value, the code in this sample uses completion handlers to be _called back_ once the code in the called function has completed.
+ 
+ To actually make use of asynchronous capabilities, we need to make sure the code in the called functions runs asynchronously. To see an example for how this can be achieved, see [Asynchronous Completion Handlers](Asynchronous%20Completion%20Handlers).
+ */
+
+import Foundation
+import PlaygroundSupport
+
+PlaygroundPage.current.needsIndefiniteExecution = true
+
+/// This is the main algorithm for creating a sandwich. Call it with a bread, some ingredients, and condiments of your liking.
+/// - Parameters:
+///   - bread: The type of bread you want your sandwich to be based on.
+///   - ingredients: A list of ingredients you want to put on your sandwich.
+///   - condiments: The condiments you want to be spread on the slices of bread.
+///   - completion: The completion handler that will be called at the end of the sandwich making process.
+func makeSandwich(bread: String, ingredients: [String], condiments: [String], completion: (String) -> Void) {
+  sandwichMakerSays("Preparing your sandwich...")
+  
+  toastBread(bread, completion: { toasted in
+    print("\(bread) is now \(toasted)")
+  })
+  print("This code will be executed before the bread is toasted")
+  
+  toastBread(bread) { toasted in
+    print("\(bread) is now \(toasted)")
+  }
+  
+  toastBread(bread) { toasted in
+    slice(ingredients) { sliced in
+      sandwichMakerSays("Spreading \(condiments.joined(separator: ", and ")) om \(toasted)")
+      sandwichMakerSays("Layering \(sliced.joined(separator: ", "))")
+      sandwichMakerSays("Putting lettuce on top")
+      sandwichMakerSays("Putting another slice of bread on top")
+      
+      completion("\(ingredients.joined(separator: ", ")), \(condiments.joined(separator: ", ")) on \(toasted)")
+    }
+  }
+}
+
+/// This function toasts your bread. Not really, but you get the point.
+/// - Parameters:
+///   - bread: The type of bread to be used.
+///   - completion: The completion handler that will be called at the end of the toasting process.
+func toastBread(_ bread: String, completion: (String) -> Void) {
+  sandwichMakerSays("Toasting the bread... Standing by...", waitFor: 5)
+  completion("Crispy \(bread)")
+}
+
+/// This function slices the ingredients for your sandwich. Kind of.
+/// - Parameters:
+///   - ingredients: A list of ingredients.
+///   - completion: The completin handler that will be called when all ingredients have been sliced.
+func slice(_ ingredients: [String], completion: ([String]) -> Void) {
+  let result = ingredients.map { ingredient in
+    sandwichMakerSays("Slicing \(ingredient)", waitFor: 1)
+    return "sliced \(ingredient)"
+  }
+  completion(result)
+}
+
+//: The main program follows
+
+sandwichMakerSays("Hello to Cafe Complete, where we handle your order with care.")
+sandwichMakerSays("Please place your order.")
+
+// We're using a `ContinuousClock` to determine how long it took to make the sandwich.
+let clock = ContinuousClock()
+let time = clock.measure {
+  makeSandwich(bread: "Rye", ingredients: ["Cucumbers", "Tomatoes"], condiments: ["Mayo", "Mustard"]) { sandwich in
+    customerSays("Hmmm.... this looks like a delicious \(sandwich) sandwich!")
+  }
+}
+
+// This should be roughly 7 seconds (5 for toasting, and 1 for each ingredient we sliced)
+print("Making this sandwich took \(time)")
+
+print("The end.")
+
+//: [<Previous](@previous)  [Home](Introduction)  [Next>](@next)

Chapter 14 - Getting Started with async-await/Getting Started with async await Playground.playground/Pages/Introduction.xcplaygroundpage/Contents.swift

@@ -0,0 +1,19 @@
+/*:
+ # Getting Started with async/await
+ Created by [Peter Friese](https://twitter.com/peterfriese) – [peterfriese.dev](https://peterfriese.dev)
+ 
+ In this Swift Playground, you will learn several ways to write asynchronous code in Swift.
+ 
+ - note: You can open and run the playground in Xcode on your Mac, but you will have a better experience when opening and running it in the Swift Playground app ([download](https://apps.apple.com/app/id1496833156) it fromn the Mac App Store).
+ 
+ This playground accompanies _Asynchronous Programming with SwiftUI and Combine_ by Peter Friese. For the best learning experience, it is recommended to follow the samples in this playground while reading chapter 14 - _Getting Started with async/await_.
+ 
+ ## Table of contents
+ * [Writing synchronous code](Synchronous%20Code)
+ * [Using completion handlers](Completion%20Handlers)
+ * [Writing asynchronous code with completion handlers](Asynchronous%20Completion%20Handlers)
+ * [Using async/await to write asynchronous code](async%20await)
+ * [Executing code in parallel using `async let`](async%20let)
+ 
+ [Next >](@next)
+ */

Chapter 14 - Getting Started with async-await/Getting Started with async await Playground.playground/Pages/Synchronous Code.xcplaygroundpage/Contents.swift

@@ -0,0 +1,80 @@
+/*:
+ [<Previous](@previous)  [Home](Introduction)  [Next>](@next)
+ 
+ # Synchronous Code
+ 
+ This sample shows how to use synchronous code to prepare a sandwich.
+ 
+ The steps to prepare a sandwich are:
+ * toasting two slices of bread
+ * slicing the ingredients (e.g. cucumbers, tomatoes) for the sandwich
+ * spreading condiments on the bread
+ * layering the ingredients on top of one slice of bread
+ * putting a leaf of lettuce on top
+ * putting another slice of bread on top
+ 
+ Some of these steps might take a while, for example toasting the bread or slicing the ingredients. In this implementation, the sandwich maker will execute all steps serially, one after the other. This means they will stand by while waiting for the bread to be toasted (which, in this example, takes five seconds).
+ 
+ This is what we call **blocking**: no other part of the app running on the same thread will be able to execute until the respective call has completed.
+ 
+ In the other implementations, we will look at some features such as completion handlers and Swift's support for async/await to see how they can help to deal with asynchronous code.
+ */
+
+import Foundation
+
+/// This is the main algorithm for creating a sandwich. Call it with a bread, some ingredients, and condiments of your liking.
+/// - Parameters:
+///   - bread: The type of bread you want your sandwich to be based on.
+///   - ingredients: A list of ingredients you want to put on your sandwich.
+///   - condiments: The condiments you want to be spread on the slices of bread.
+/// - Returns: The finished sandwich.
+func makeSandwich(bread: String, ingredients: [String], condiments: [String]) -> String {
+  sandwichMakerSays("Preparing your sandwich...")
+  
+  let toasted = toastBread(bread)
+  let sliced = slice(ingredients)
+  
+  sandwichMakerSays("Spreading \(condiments.joined(separator: ", and ")) on \(toasted)")
+  sandwichMakerSays("Layering \(sliced.joined(separator: ", "))")
+  sandwichMakerSays("Putting lettuce on top")
+  sandwichMakerSays("Putting another slice of bread on top")
+  
+  return "\(ingredients.joined(separator: ", ")), \(condiments.joined(separator: ", ")) on \(toasted)"
+}
+
+/// This function toasts your bread. Not really, but you get the point.
+/// - Parameter bread: The type of bread to be used.
+/// - Returns: The toasted bread.
+func toastBread(_ bread: String) -> String {
+  sandwichMakerSays("Toasting the bread... Standing by...", waitFor: 5)
+  return "Crispy \(bread)"
+}
+
+/// This function slices the ingredients for your sandwich. Kind of.
+/// - Parameter ingredients: A list of ingredients.
+/// - Returns: A list of slices ingredients.
+func slice(_ ingredients: [String]) -> [String] {
+  let result = ingredients.map { ingredient in
+    sandwichMakerSays("Slicing \(ingredient)", waitFor: 1)
+    return "sliced \(ingredient)"
+  }
+  return result
+}
+
+//: The main program follows
+
+sandwichMakerSays("Hello to Cafe Synchronous, where we execute your order serially.")
+sandwichMakerSays("Please place your order.")
+
+// We're using a `ContinuousClock` to determine how long it took to make the sandwich.
+let clock = ContinuousClock()
+let time = clock.measure {
+  let sandwich = makeSandwich(bread: "Rye", ingredients: ["Cucumbers", "Tomatoes"], condiments: ["Mayo", "Mustard"])
+  customerSays("Hmmm.... this looks like a delicious \(sandwich) sandwich!")
+}
+
+// This should be roughly 7 seconds (5 for toasting, and 1 for each ingredient we sliced)
+print("Making this sandwich took \(time)")
+
+//: [<Previous](@previous)  [Home](Introduction)  [Next>](@next)
+

Chapter 14 - Getting Started with async-await/Getting Started with async await Playground.playground/Pages/async await.xcplaygroundpage/Contents.swift

@@ -0,0 +1,73 @@
+/*:
+ [<Previous](@previous)  [Home](Introduction)  [Next>](@next)
+ 
+ # Using async/await
+ 
+ This sample shows how to use Grand Central Dispatch and completion handlers to prepare a sandwich.
+ 
+ The steps to prepare a sandwich are:
+ * toasting two slices of bread
+ * slicing the ingredients (e.g. cucumbers, tomatoes) for the sandwich
+ * spreading condiments on the bread
+ * layering the ingredients on top of one slice of bread
+ * putting a leaf of lettuce on top
+ * putting another slice of bread on top
+ 
+ Some of these steps might take a while, for example toasting the bread or slicing the ingredients.
+ 
+ This implementation makes use of async/await (available in Swift 5.5) to execute longer running code asynchronously.
+ */
+
+import Foundation
+import PlaygroundSupport
+
+PlaygroundPage.current.needsIndefiniteExecution = true
+
+func makeSandwich(bread: String, ingredients: [String], condiments: [String]) async -> String {
+  sandwichMakerSays("Preparing your sandwich...")
+  
+  let toasted = await toastBread(bread)
+  let sliced = await slice(ingredients)
+  
+  sandwichMakerSays("Spreading \(condiments.joined(separator: ", and ")) om \(toasted)")
+  sandwichMakerSays("Layering \(sliced.joined(separator: ", "))")
+  sandwichMakerSays("Putting lettuce on top")
+  sandwichMakerSays("Putting another slice of bread on top")
+  
+  return "\(ingredients.joined(separator: ", ")), \(condiments.joined(separator: ", ")) on \(toasted)"
+}
+
+func toastBread(_ bread: String) async -> String {
+  sandwichMakerSays("Toasting the bread... Standing by...")
+  await Task.sleep(5_000_000_000)
+  return "Crispy \(bread)"
+}
+
+func slice(_ ingredients: [String]) async -> [String] {
+  var result = [String]()
+  for ingredient in ingredients {
+    sandwichMakerSays("Slicing \(ingredient)")
+    await Task.sleep(1_000_000_000)
+    result.append("sliced \(ingredient)")
+    
+  }
+  return result
+}
+
+let clock = ContinuousClock()
+
+sandwichMakerSays("Hello to Cafe Async, where we execute your order in asynchronously.")
+sandwichMakerSays("Please place your order.")
+
+Task {
+  let time = await clock.measure {
+    let sandwich = await makeSandwich(bread: "Rye", ingredients: ["Cucumbers", "Tomatoes"], condiments: ["Mayo", "Mustard"])
+    customerSays("Hmmm.... this looks like a delicious \(sandwich) sandwich!")
+    print("The end.")
+  }
+  print("Making this sandwich took \(time)")
+}
+
+
+//: [<Previous](@previous)  [Home](Introduction)  [Next>](@next)
+