Point-Free Videos

🔒 We can now observe struct, optional, and enum state in the Composable Architecture, but what

about collections? Let's explore what it takes to get rid of the `ForEachStore` wrapper view

for a vanilla `ForEach` view instead, while still observing updates to collection state in the

most minimal way possible.

🔒 We've made structs and optionals observable in the Composable Architecture, eliminating the

need for `ViewStore`s and `IfLetStore`s, so what about enums? If we can make enums observable,

we could further eliminate the concept of the `SwitchStore`, greatly improving the ergonomics

of working with enums in the library.

🔒 The Composable Architecture can now observe _struct_ state, but it requires a lot of boilerplate. Let's fix this by leveraging the `@Observable` macro from the Swift open source repository. And let's explore what it means to observe _optional_ state and eliminate the library's `IfLetStore` view for a simple `if let` statement.

🔒 One of the core tenets of the Composable Architecture is that you should be able to model your

application's state using simple value types, like structs and enums. However, the

`@Observable` macro does not work with value types at all, and so in order to enhance the

Composable Architecture with Observation we will need to contend with this issue and explore

what it means for a struct to be observable.

🆓 We're about to completely revolutionize the Composable Architecture with Swift's new

Observation framework! But first, a sneak peek: we'll take the public beta (available today!)

for a spin to see how the concept of a "view store" completely vanishes when using the new

tools.

Oh, and did we mention that the new observation tools in the library have been backported

all the way back to iOS 13? This means you can use the tools _immediately_. 🤯

🔒 We have now totally reimagined the design of our case paths library to create actual key paths

for enum cases, but there is some boilerplate involved. Let’s create a macro that eliminates

all of it and explore a few of the possibilities it unlocks.

🔒 “Case paths” grant key path-like functionality to enum cases. They solve many problems in

navigation, parsing, and architecture, but fall short of native key paths…till now. Let’s

close this gap using macros that generate actual key paths to enum cases.

🔒 We take all we've learned about the Observation framework and apply it to a larger, more real

world application: our rewrite of Apple's Scrumdinger demo. We'll see what changes are easy to

make, what changes are a bit trickier, and encounter a bug that you'll want to know about.

🔒 We've explored the present state of observation in Swift, so what's the future have in store? Currently, observation is restricted to classes, while one of Swift's most celebrated features, value types, is left out in the cold. Let's explore a future in which observation is extended to value types.

🔒 While the `@Observable` macro improves upon nearly every aspect of the `@State` and `@ObservedObject` property wrappers, it is not without its pitfalls. We will explore several gotchas that you should be aware of when adopting observation in your applications.