Swift @propertyWrapper to allocate huge structs on the heap, by wrapping them inside arrays. -> Very effective "hackaround".

Struct+StoreOnHeap.swift

/// Stores value types on the heap
///
/// Arrays are stored on the heap and only the pointer (8 bytes) to the array remains on the stack.
/// This behaviour is used to wrap another type into an array, and therefore move it to the heap.
///
/// Example usage:
/// ```
/// @StoredOnHeap var hugeStruct: HugeStruct
/// ```
@propertyWrapper
struct StoredOnHeap<T> {
    private var value: [T]

    init(wrappedValue: T) {
        self.value = [wrappedValue]
    }

    var wrappedValue: T {
        get {
            return self.value[0]
        }

        set {
            self.value[0] = newValue
        }
    }
}

/// Stores optional value types on the heap
///
/// Arrays are stored on the heap and only the pointer (8 bytes) to the array remains on the stack.
/// This behaviour is used to wrap another type into an array, and therefore move it to the heap.
///
/// Example usage:
/// ```
/// @StoredOnHeap var hugeStruct: HugeStruct?
/// ```
@propertyWrapper
struct StoredOnHeapOptional<T> {
    private var value: [T] = []

    init() {}

    init(wrappedValue: T?) {
        if let wrappedValue = wrappedValue {
            self.value = [wrappedValue]
        }
    }

    var wrappedValue: T? {
        get {
            return self.value.first
        }

        set {
            self.value = []
            if let newValue = newValue {
                self.value.append(newValue)
            }
        }
    }
}