Copy-on-Write (COW) Storage #

Types such as Array, Dictionary, and Set are value types. Their small “wrapper” remains on the stack, while the data they contain is stored on the heap. This design makes copying quick and efficient.

Example:

var numbers = [1, 2, 3]
// "numbers" is a value type, but the list [1, 2, 3] is kept on the heap.

Indirect Enum Cases #

Using the indirect keyword with an enum tells Swift to store additional data on the heap. This is useful for structures that link to each other, such as mathematical expressions.

Example:

indirect enum Math {
    case number(Int)
    case add(Math, Math)
}

let sum = Math.add(.number(2), .number(3))
// The expression "2 + 3" is stored on the heap.

Explanation:
In this case, Math represents either a number or an addition operation. The indirect keyword ensures that the components of the addition (like 2 and 3) are placed on the heap.

Boxing with Existential Types #

When a value type, such as a struct, is assigned to a variable of type Any or a protocol, Swift wraps it in a “box” on the heap. This process, called boxing, ensures type safety.

Example:

protocol Vehicle {
    var speed: Int { get }
}

struct Bicycle: Vehicle {
    var speed: Int
}

let bike = Bicycle(speed: 15)
let vehicle: Vehicle = bike
// "bike" is boxed on the heap when assigned to the Vehicle protocol.

Explanation:
Here, the Bicycle struct conforms to the Vehicle protocol. When stored as a Vehicle, Swift boxes it on the heap to handle the existential type properly.

Capturing Value Types in Escaping Closures #

When a value type is used in a closure that outlives its surrounding function, Swift moves it to the heap. This prevents the value from being lost when the function ends.

Example:

struct Counter {
    var count: Int = 0
}

func makeCounter() -> () -> Int {
    var counter = Counter()
    return {
        counter.count += 1  // Modifies the captured value
        return counter.count
    }
}

let counterClosure = makeCounter()
print(counterClosure()) // Prints: 1
print(counterClosure()) // Prints: 2
// "counter" is stored on the heap due to the closure.

Escape Analysis and Compiler Tricks #

The Swift compiler sometimes detects that a value must leave its function, such as when it’s returned. To keep it alive, the compiler may move it to the heap.

Example:

struct DataHolder {
    var data: [Int]
}

func createHolder() -> DataHolder {
    return DataHolder(data: [1, 2, 3])
    // The compiler might place "data" on the heap.
}

let holder = createHolder()
// The array [1, 2, 3] resides on the heap.

Key Idea #

Value types usually live on the stack, which is fast memory. However, Swift cleverly uses the heap—larger memory—for tasks like copying, linking data, boxing, handling closures, or managing escaping values. This balance makes Swift both efficient and secure!