Issue 48  4th December 2023

Gosh Darn Format Style!

Swift’s FormatStyle and ParseableFormatStyle are the easiest way to convert Foundation data types to and from localized strings. Unfortunately Apple hasn’t done a great job in documenting just what it can do, or how to use them. This site aims to solve this problem, and it does a pretty good job at it.

I was reminded of Gosh Darn - if case let, and Gosh Darn - Swift closures, and wanted to include an entire list of all the Gosh Darn sites - but it turns out someone else has already done the work: goshdarnsyntaxsite.com

goshdarnformatstyle.com  

Create an AsyncStream from withObservationTracking() function

In this article, Matthaus Woolard takes Natalia's example from last week, and shows how to wrap a stream of Observation events into an AsyncStream. I love how this makes the code a lot more readable at the call site.

What I find striking is that code that makes use of AsyncStream is very similar to code that makes use of callbacks. For example, here is a code snippet that shows how to listen to changes in a Firestore collection:

let listener = Firestore.firestore().collection("fruits").addSnapshotListener { querySnapshot, error in
  guard let documents = querySnapshot?.documents else { return }

  self.fruits = documents.compactMap { queryDocumentSnapshot in
    do {
      return try queryDocumentSnapshot.data(as: Fruit.self)
    }
    catch {
      return nil
    }
  }
}

And here is how this looks like when using an AsyncSequence:

let fruitsSequence = Firestore.firestore().collection("fruits").snapshotSequence(Fruit.self)
for try await fruits in fruitsSequence {
  self.fruits = fruits
}

This code is based on a prototypical implementation of AsyncSequence in Firebase. Let me know what you think (e.g. by leaving a comment on the PR, or by replying to this email) - would you like to use this?

nilcoalescing.com  

How to import Swift macros without using Swift Package Manager

Swift Macros are one of the hottest new features in Swift - check out Swift-Macros (curated by Krzysztof Zabłocki), which has an extensive list of macros that are publicly available.

Macros are usually defined in Swift Packages, and are shipped as source code. But what if you don't want to use Swift Package Manager, or if you don't want to ship your macros as source code?

Pol Piella has you covered - in this article, he shows how to compile a macros in to a binary, and then import it into a build target. Pretty cool!

polpiella.dev