When can a value type be stored on the heap?

The value type (struct, enum, tuple) can be allocated on the heap in the following cases:

1. Nested type: If the value type is part of a reference type (class), then its instance is stored directly inside the class instance on the heap.
2. Captured in a closure: If the value type is captured by a closure, and this closure is then passed outside the current scope, the compiler may decide to allocate the value type on the heap to ensure its availability after the scope where it was created ends.
3. Collections: Elements of collections (Array, Dictionary, Set), even if these elements are value types, are stored on the heap because the collections themselves (in Swift implementation) are reference types or use internal heap storage.
4. Existentials (Any, AnyObject, Protocol): When placing a value type in a container of type Any, AnyObject, or passing it as a protocol type (any SomeProtocol), the Swift type system uses an "existential container". For large value types, this container may store the value type itself on the heap rather than inline.
5. On-Demand Allocation Optimizations (retrospectively): In some cases, the compiler may optimize the storage of large value types by placing them on the heap, even if they do not meet the explicit scenarios above, for memory management purposes. This is not guaranteed behavior and depends on compiler optimizations.

import Foundation

// 1. Nested type
class Container {
    // MyValueType is stored inside the Container instance
    struct MyValueType {
        var data: Int
    }
    var value: MyValueType
    
    init(data: Int) {
        self.value = MyValueType(data: data)
    }
}

// let container = Container(data: 10) // value.data is stored on the heap as part of Container

// 2. Capture in a closure
func createClosure() -> () -> Int {
    var counter = 0 // counter is a Value Type
    // Captured by closure and may be stored on the heap
    let closure = {
        counter += 1
        return counter
    }
    return closure
}

// let myClosure = createClosure() // counter may be on the heap

// 3. Collections
struct AnotherValueType {
    var name: String
}

// Elements of an array (Value Type) are stored on the heap
var array: [AnotherValueType] = [AnotherValueType(name: "Apple"), AnotherValueType(name: "Banana")]

// 4. Existentials
struct LargeValueType {
    var largeData: [Int] = Array(repeating: 0, count: 1000)
}

func processAny(_ data: Any) {
    // When passing LargeValueType as Any, it may be allocated on the heap
}

// let largeValue = LargeValueType()
// processAny(largeValue)

// 5. On-Demand Allocation (depends on the compiler) - implicit case