🆓 We explore a few more advanced scenarios when it comes to async code—including cancellation, async sequences, and clocks—and how difficult they are to test.

🆓 While Swift provides wonderful tools for writing async code, there are gaps in its tools for testing it. Let's explore the tools it *does* provide to show where they succeed, and where they fall short.

🔒 We complete the series by writing a comprehensive test suite for our stack navigation-based

app. We will uncover some shortcomings of the tools we've built and address each one,

resulting in a set of tools that are a joy to test with.

🔒 We round out the functionality of the Composable Architecture's stack navigation tools. This includes automatic cancellation of a child feature's effects when it's popped off the stack, and the ability for a child feature to pop itself. Along the way we will clean up the domain modeling and user experience of working with these tools.

🔒 We introduce a complementary `StackState` wrapper to our navigation tools to solve a few

issues that came from repurposing the identified array type. Once implemented and integrated,

we will put these tools' superpowers to work by implementing two new features.

🔒 We begin designing brand new navigation stack tools for the Composable Architecture to solve *all* of the problems we encountered when shoehorning stack navigation into the existing tools, and more.

🔒 Let's insert a new feature into the navigation stack. We'll take things step-by-step, employing an enum to hold multiple features in a single package, and making small changes to how we use our existing APIs before sketching out all-new tools dedicated to stack navigation.

🔒 We enhance our navigation stack with a bit more complexity by adding the ability to drill down multiple layers in multiple ways: using the new navigation link API, and programmatically. We also prepare a new feature to add to the stack.

🔒 It's finally time to tackle navigation stacks in the Composable Architecture! They are a

powerful, new tool in SwiftUI and stray a bit from all the other forms of tree-based

navigation we've explored. Let's compare the two styles and see what it takes to integrate

stacks into the library's navigation tools.

🔒 We take a detour to learn about the stack, the heap, copy-on-write, and how we can use this knowledge to further improve our navigation tools by introducing of a property wrapper.