🔒 The new reducer protocol has improved many things, but we’re now in an awkward place when it comes to defining them: some are conformances and some are not. We’ll fix that with inspiration from SwiftUI and the help of a new protocol feature.

🔒 We are already seeing huge benefits from the reducer protocol, but one aspect is still not ideal, and that is how we compose reducers. We will look to result builders to solve the problem, and a new feature of them introduced in Swift 5.7.

🔒 Let's begin to solve a number of the problems with the Composable Architecture by introducing a reducer protocol. We will write some common conformances and operators in the new style, and even refactor a complex demo application.

🆓 The Composable Architecture was first released over two years ago, and the core ergonomics haven't changed much since then. It's time to change that: we are going to improve the ergonomics of nearly every facet of creating a feature with the library, and make all new patterns possible.

🆓 This week we are releasing the biggest update to the Composable Architecture since its first

release over 2 years ago, bringing more of Swift's modern concurrency tools to the library.

To celebrate we will demonstrate how these tools can massively simplify a few real-world

applications.

🔒 We explore ways to tie the lifetime of an effect to the lifetime of a view, making it possible to automatically cancel and tear down work when a view goes away. This unexpectedly helps us write even stronger tests for our features.

🔒 We introduce another helper to the `Effect` type that can use an asynchronous context to send multiple actions back into the system. By leveraging Swift's structured concurrency we can create complex effects in a natural way, all without sacrificing testability.

🔒 We can now run async work directly in a reducer's effects, but time-based asynchrony, like `Task.sleep`, will wreak havoc in our tests. Let's explore the problem in a new feature, and see how to recover the nice syntax of modern timing tools using a protocol from the past: Combine schedulers.

🔒 This week we start fixing the problems we outlined last week. We build the tools necessary to start using concurrency tasks directly in reducers, and along the way we open Pandora's box of existential types to solve some mind-bending type issues.

🆓 The Composable Architecture's fundamental unit of effect is modeled on Combine publishers because it was the simplest and most modern asynchrony tool available at the time. Now Swift has native concurrency tools, and so we want to make use of those tools in the library. But first, let's see what can go wrong if we try to naively use async/await in an existing application.