mem2.swift

import Foundation

func dump(_ p: UnsafeRawPointer, _ size: Int) {
    let addr = unsafeBitCast(p, to: UInt64.self)
    let p = p.bindMemory(to: UInt8.self, capacity: size)
    for i in 0..<size {
        if i % 8 == 0 {
            if i != 0 {
                print()
            }
            print(String(format: "[0x%016lx]", addr + UInt64(i)), terminator: "")
        }
        print(String(format: " %02x", p[i]), terminator: "")
    }
    print()
}

struct SA {
    var v1: UInt32 = 0xA1B1C1D1
    var v2: UInt32 = 0xA2B2C2D2
    var v3: UInt32 = 0xA3B3C3D3
    var v4: UInt32 = 0xA4B4C4D4
}

class CA {
    var v1: UInt32 = 0xA1B1C1D1
    var v2: UInt32 = 0xA2B2C2D2
    var v3: UInt32 = 0xA3B3C3D3
    var v4: UInt32 = 0xA4B4C4D4
}

enum EA<T> {
    case c0(T)
    case c1
}

func test1() {
    print("--: test1")
    
    print("----: .c0(SA())")
    var x1: EA<SA> = .c0(SA())
    let px1 = UnsafeRawPointer(UnsafeMutablePointer(&x1))
    dump(px1, MemoryLayout<EA<SA>>.size)
    
    print("----: .c0(.c0(.c0(.c0(SA()))))")
    var x2: EA<EA<EA<EA<SA>>>> = .c0(.c0(.c0(.c0(SA()))))
    let px2 = UnsafeRawPointer(UnsafeMutablePointer(&x2))
    dump(px2, MemoryLayout<EA<EA<EA<EA<SA>>>>>.size)
    
    print("----: .c0(.c0(.c1))")
    var x3: EA<EA<EA<EA<SA>>>> = .c0(.c0(.c1))
    let px3 = UnsafeRawPointer(UnsafeMutablePointer(&x3))
    dump(px3, MemoryLayout<EA<EA<EA<EA<SA>>>>>.size)
    
    print("----: .c1")
    var x4: EA<EA<EA<EA<SA>>>> = .c1
    let px4 = UnsafeRawPointer(UnsafeMutablePointer(&x4))
    dump(px4, MemoryLayout<EA<EA<EA<EA<SA>>>>>.size)

    print("----: .c0(CA())")
    var x5: EA<CA> = .c0(CA())
    let px5 = UnsafeRawPointer(UnsafeMutablePointer(&x5))
    dump(px5, MemoryLayout<EA<CA>>.size)
    print("--")
    let ppx5 = px5.bindMemory(to: UnsafeRawPointer.self, capacity: 1).pointee
    dump(ppx5, 32)
    
    print("----: .c0(.c0(.c0(.c0(CA()))))")
    var x6: EA<EA<EA<EA<CA>>>> = .c0(.c0(.c0(.c0(CA()))))
    let px6 = UnsafeRawPointer(UnsafeMutablePointer(&x6))
    dump(px6, MemoryLayout<EA<EA<EA<EA<CA>>>>>.size)
    print("--")
    let ppx6 = px6.bindMemory(to: UnsafeRawPointer.self, capacity: 1).pointee
    dump(ppx6, 32)
    
    print("----: .c0(.c0(.c0(.c1)))")
    var x7: EA<EA<EA<EA<CA>>>> = .c0(.c0(.c0(.c1)))
    let px7 = UnsafeRawPointer(UnsafeMutablePointer(&x7))
    dump(px7, MemoryLayout<EA<EA<EA<EA<CA>>>>>.size)
    
    print("----: .c0(.c0(.c1))")
    var x8: EA<EA<EA<EA<CA>>>> = .c0(.c0(.c1))
    let px8 = UnsafeRawPointer(UnsafeMutablePointer(&x8))
    dump(px8, MemoryLayout<EA<EA<EA<EA<CA>>>>>.size)
    
    print("----: .c0(.c1)")
    var x9: EA<EA<EA<EA<CA>>>> = .c0(.c1)
    let px9 = UnsafeRawPointer(UnsafeMutablePointer(&x9))
    dump(px9, MemoryLayout<EA<EA<EA<EA<CA>>>>>.size)
    
    print("----: .c1")
    var x10: EA<EA<EA<EA<CA>>>> = .c1
    let px10 = UnsafeRawPointer(UnsafeMutablePointer(&x10))
    dump(px10, MemoryLayout<EA<EA<EA<EA<CA>>>>>.size)
}

struct SB {
    var v1: UInt32 = 0xA5B5C5D5
    var v2: UInt32 = 0xA6B6C6D6
}

class CB {
    var v1: UInt32 = 0xA5B5C5D5
    var v2: UInt32 = 0xA6B6C6D6
}

enum EB<X, Y> {
    case c0(X)
    case c1(Y)
}

func test2() {
    print("x1")
    var x1: EB<SA, SB> = .c0(SA())
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x1)),
         MemoryLayout<EB<SA, SB>>.size)
    
    print("x2")
    var x2: EB<SA, SB> = .c1(SB())
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x2)),
         MemoryLayout<EB<SA, SB>>.size)
    
    print("x3")
    var x3: EB<CA, CB> = .c0(CA())
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x3)),
         MemoryLayout<EB<CA, CB>>.size)
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x3))
        .bindMemory(to: UnsafeRawPointer.self, capacity: 1).pointee,
         32)
    
    print("x4")
    var x4: EB<CA, CB> = .c1(CB())
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x4)),
         MemoryLayout<EB<CA, CB>>.size)
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x4))
        .bindMemory(to: UnsafeRawPointer.self, capacity: 1).pointee,
         24)
    
    print("x5")
    var x5: EB<SA, CA> = .c0(SA())
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x5)),
         MemoryLayout<EB<SA, CB>>.size)
    
    print("x6")
    var x6: EB<SA, CA> = .c1(CA())
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x6)),
         MemoryLayout<EB<SA, CB>>.size)
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x6))
        .bindMemory(to: UnsafeRawPointer.self, capacity: 1).pointee,
         32)
    
    print("x7")
    var x7: EB<SA, EA<EA<CA>>> = .c0(SA())
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x7)),
         MemoryLayout<EB<SA, EA<EA<CA>>>>.size)
    
    print("x8")
    var x8: EB<SA, EA<EA<CA>>> = .c1(.c0(.c0(CA())))
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x8)),
         MemoryLayout<EB<SA, EA<EA<CA>>>>.size)
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x8))
        .bindMemory(to: UnsafeRawPointer.self, capacity: 1).pointee,
         32)
    
    print("x9")
    var x9: EB<SA, EA<EA<CA>>> = .c1(.c1)
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x9)),
         MemoryLayout<EB<SA, EA<EA<CA>>>>.size)
}

func test3() {
    print("x1")
    var x1: EA<CA?> = .c0(.some(CA()))
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x1)),
         MemoryLayout<EA<CA?>>.size)
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x1))
        .bindMemory(to: UnsafeRawPointer.self, capacity: 1).pointee,
         32)
    
    print("x2")
    var x2: EA<CA?> = .c1
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x2)),
         MemoryLayout<EA<CA?>>.size)
}

enum EA2<T> {
    case c0
    case c1(T)
}

func test4() {
    print("x1")
    var x1: EA2<CA?> = .c0
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x1)),
         MemoryLayout<EA2<CA?>>.size)
}

enum EA3<T> {
    case c0(T)
    case c1
    case c2
}

func test5() {
    print("x1")
    var x1: EA3<CA?> = .c1
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x1)),
         MemoryLayout<EA3<CA?>>.size)
    
    print("x2")
    var x2: EA3<CA?> = .c2
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x2)),
         MemoryLayout<EA3<CA?>>.size)
    
    print("x3")
    var x3: EA3<EA3<CA>> = .c0(.c1)
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x3)),
         MemoryLayout<EA3<CA?>>.size)
    
    print("x4")
    var x4: EA3<EA3<CA>> = .c0(.c2)
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x4)),
         MemoryLayout<EA3<CA?>>.size)
    
    print("x5")
    var x5: EA3<EA3<CA>> = .c1
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x5)),
         MemoryLayout<EA3<CA?>>.size)
    
    print("x6")
    var x6: EA3<EA3<CA>> = .c2
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x6)),
         MemoryLayout<EA3<CA?>>.size)
}

enum EA4 {
    case c0
    case c1
    case c2
}

func test6() {
    typealias ET = EB<EA4, CA>
    
    print("x1")
    var x1: ET = .c0(.c0)
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x1)),
         MemoryLayout<ET>.size)
    
    print("x2")
    var x2: ET = .c0(.c1)
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x2)),
         MemoryLayout<ET>.size)
    
    print("x3")
    var x3: ET = .c0(.c2)
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x3)),
         MemoryLayout<ET>.size)
    
    print("x4")
    var x4: ET = .c1(CA())
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x4)),
         MemoryLayout<ET>.size)
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x4))
        .bindMemory(to: UnsafeRawPointer.self, capacity: 1).pointee,
         32)
}

enum EC1<T> {
    case c0
    case c1(T)
    case c2
    case c3
}

enum EC2<T> {
    case c0
    case c1
    case c2(T)
    case c3
}

func test7() {
    typealias ET = EC1<EC2<EC1<EC2<EC1<CA>>>>>
    
    var x: ET = .c0
    
    print("--")
    x = .c0
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x)),
         MemoryLayout<ET>.size)
    
    print("--")
    x = .c1(.c0)
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x)),
         MemoryLayout<ET>.size)

    print("--")
    x = .c1(.c1)
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x)),
         MemoryLayout<ET>.size)
    
    print("--")
    x = .c1(.c2(.c0))
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x)),
         MemoryLayout<ET>.size)
    
    print("--")
    x = .c1(.c2(.c1(.c0)))
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x)),
         MemoryLayout<ET>.size)
    
    print("--")
    x = .c1(.c2(.c1(.c1)))
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x)),
         MemoryLayout<ET>.size)
    
    print("--")
    x = .c1(.c2(.c1(.c2(.c0))))
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x)),
         MemoryLayout<ET>.size)
    
    print("--")
    x = .c1(.c2(.c1(.c2(.c1(CA())))))
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x)),
         MemoryLayout<ET>.size)
   
    print("--")
    x = .c1(.c2(.c1(.c2(.c2))))
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x)),
         MemoryLayout<ET>.size)
    
    print("--")
    x = .c1(.c2(.c1(.c2(.c3))))
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x)),
         MemoryLayout<ET>.size)
    
    print("--")
    x = .c1(.c2(.c1(.c3)))
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x)),
         MemoryLayout<ET>.size)
    
    print("--")
    x = .c1(.c2(.c2))
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x)),
         MemoryLayout<ET>.size)
    
    print("--")
    x = .c1(.c2(.c3))
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x)),
         MemoryLayout<ET>.size)
    
    print("--")
    x = .c1(.c3)
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x)),
         MemoryLayout<ET>.size)
    
    print("--")
    x = .c2
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x)),
         MemoryLayout<ET>.size)
    
    print("--")
    x = .c3
    dump(UnsafeRawPointer(UnsafeMutablePointer(&x)),
         MemoryLayout<ET>.size)
}


print("test1")
test1()
print("test2")
test2()
print("test3")
test3()
print("test4")
test4()
print("test5")
test5()
print("test6")
test6()
print("test7")
test7()