This section tells you a few things you need to know before you get started, such as what you’ll need for hardware and software, where to find the project files for this book, and more.
The section is a list of the expanded areas of Swift programming. It systematically navigates a variety of important topics, from the principles of Access Control, Code Organization, and Testing to custom Operators, Subscripts, and Keypaths. It presents in-depth coverage of Swift’s powerful idioms, like Result Builders and Pattern Matching, and ensures your proficiency in handling real-world errors.
The section further covers advanced concepts such as Encoding & Decoding Types, Memory Management, and takes you through the subtelties of value semantics. It presents a thorough discussion on Property Wrappers, the driving force behind popular frameworks like SwiftUI, and explores Protocol-Oriented Programming, underscoring Swift’s protocol-based design.
Finally, it covers Advanced Protocols, Generics, and Concurrency, giving you a solid understanding of Swift’s language-level concurrency mechanisms. Each topic provides a robust foundation for advanced Swift programming, ensuring your grasp of these concepts is both thorough and practical.
Swift gives you powerful tools for hiding complexity and organizing your code into easier-to-digest units. As your codebase grows,
ensuring correctness with automated tests becomes more critical in your projects.
You’ll learn how to define your own operators and use subscripts to make your types feel even more like built-in language constructs.
Keypaths provide references to properties, and together with subscripts and dynamic member lookup, you can do amazing things.
Swift is a concise, powerful language but can be verbose for certain tasks. Result builders allow you to create a domain-specific language and compactly express complex values. In this chapter, you will implement a result builder for making fancy attributed strings.
With pattern matching, you can accomplish more with less typing, and it helps give Swift its modern language feel. This chapter picks up where “Swift Apprentice: Fundamentals – Chapter 4: Advanced Flow Control” left off and shows you powerful Swift idioms that let you work with switch statements, tuples, optionals and more.
In the real world, you can’t avoid some errors. Gracefully handling errors is what sets mediocre code apart from great code. From handling missing values and simple initialization failure with optionals to providing greater diagnostic detail using full-featured error types, Swift provides language features to make your code robust and informative in the face of errors.
Swift has a powerful system for saving and loading your types to and from, for example, a file system, over the internet or some other communication channel. Swift has exceptional out-of-the-box support for the JSON format you will become familiar with in this chapter.
This chapter digs into the details of Swift’s automatic reference counting and memory management. It shows you how to avoid memory leaks when object relationships result in reference cycles.
Value semantics have a clear advantage over reference semantics regarding local reasoning but can lead to inefficiency for large objects. This chapter shows you how to get the best of both worlds.
Used widely in frameworks like Apple’s SwiftUI and Vapor, property wrappers are a general-purpose language feature for building reusable, custom logic that defines how a property behaves. This chapter highlights some pitfalls and develops an advanced example implementing the copy-on-write optimization.
From the standard library to user-authored generics, Swift is a protocol-based language.
In this chapter, you’ll see how to get all of the benefits associated
with object-oriented programming while being able to avoid most of the difficulties.
Learn how to use constraints to make generic code more useful
and how to hide implementation details with type erasure and
opaque return types.
Swift concurrency is a new way to handle asynchronous and concurrent code. It implements structured concurrency and provides language features that check many aspects of your code at compile time. You’ll learn about these mechanisms and how actors protect the shared mutable state of your objects without needing a lot of error-prone, boilerplate code.
