Optimizing Collections in Swift

Build Collection Types That Hold Up Under Pressure 💻

Károly Lőrentey’s Optimizing Collections in Swift is a deep, practical study of what it takes to make collection types fast in Swift. It began as notes for a dotSwift 2017 talk, and the book retains that exploratory energy: a simple problem is introduced, a solution is built, and then the solution is pushed further—often through several increasingly sophisticated data structures.

The result is not a guide to shipping a specific app. It is a focused tour of Swift’s expressive power, using collection performance as the vehicle. Along the way, readers work through sorted arrays, red-black trees, B-trees, and copy-on-write storage, always with an eye on how the code behaves in practice.

Data Structures, Step by Step

The book opens with copy-on-write value semantics and the SortedSet protocol, then moves into sorted arrays and binary search. From there, it examines the Swiftification of NSOrderedSet, implements red-black trees, and explores the copy-on-write optimization in depth. Later chapters introduce B-trees and additional optimizations such as inlining array methods and eliminating redundant copying.

Each structure is not just described—it is built. The text walks through lookup methods, insertion, balancing, collection conformance, index validation, and iteration performance. That progression helps readers see how earlier ideas return in later chapters, and why certain trade-offs keep appearing.

Swift Language Techniques 🧠

Under the surface, this is a book about expressing ideas in Swift. Algebraic data types, pattern matching, recursion, and value semantics are explored through real implementations. The copy-on-write optimization, in particular, shows how Swift’s reference counting and value types can work together to create safe, efficient shared storage.

Readers who want to write more idiomatic Swift will find that these techniques carry over to everyday programming, even when they are not implementing a collection type from scratch.

Performance Is Part of the Design ⚙️

Performance is treated as a design concern, not an afterthought. Benchmarks and examples accompany the implementations, and the book discusses how iteration and insertion costs change across different structures. It also looks at practical optimizations, including inlining and avoiding redundant copying.

The code was tested with the Swift 4 compiler that shipped in Xcode 9, and most examples work on any platform that can run Swift. Where platform-specific code was needed, the book includes support for Apple platforms and GNU/Linux.

Who Will Get the Most From It

This is not a beginner’s introduction to Swift. It assumes you are comfortable with the basic syntax and have written roughly a thousand lines of Swift. If that sounds like you, the book offers a rigorous but approachable way to deepen your understanding of data structures, performance, and the language features that make Swift unusual.

It is especially relevant for developers who want to implement their own collection types, but its lessons about idiomatic Swift and performance-aware design are useful far beyond that specific goal.

Formats and Practical Details

The digital edition is available in EPUB, PDF, and Xcode playground formats. In the playground version, most of the source code is editable, so you can change implementations and see the effects immediately. That makes the book unusually well suited to active experimentation: try a modification, run it, and compare the results.

If you find a mistake, the author invites bug reports through the book’s repository, and the text includes a look at how the book itself was made.

Why It’s Worth Your Time

Optimizing Collections in Swift is for programmers who enjoy understanding how things work under the hood. It combines data structure theory, practical Swift implementation, and performance measurement into a single focused study. If you want to become better at expressing ideas in Swift—and at making them fast—this is a book that rewards careful reading and hands-on experimentation.