30 · Span·InlineArray·~Escapable

@available(macOS 10.14.4, iOS 12.2, watchOS 5.2, tvOS 12.2, visionOS 1.0, *)
@frozen @safe public struct Span<Element>
    : ~Swift.Escapable, Swift.Copyable, Swift.BitwiseCopyable
    where Element : ~Copyable {
  @usableFromInline internal let _pointer: Swift.UnsafeRawPointer?
  @usableFromInline internal let _count: Swift.Int
  @unsafe @_alwaysEmitIntoClient internal func _start() -> Swift.UnsafeRawPointer {
    _pointer._unsafelyUnwrappedUnchecked
  }
}

print("Span<Int> size =", MemoryLayout<Span<Int>>.size)
print("RawSpan size =", MemoryLayout<RawSpan>.size)
print("MutableSpan<Int> size =", MemoryLayout<MutableSpan<Int>>.size)
print("[Int] size =", MemoryLayout<[Int]>.size)

Span<Int> size = 16
RawSpan size = 16
MutableSpan<Int> size = 16
[Int] size = 8

let arr = [10, 20, 30]
let s: Span<Int> = arr.span      // ❌

error: lifetime-dependent value escapes its scope
  note: it depends on the lifetime of variable 'arr'
  note: this use causes the lifetime-dependent value to escape

func sum(_ sp: Span<Int>) -> Int {
    var t = 0
    for i in 0..<sp.count { t += sp[i] }
    return t
}
let arr = [1, 2, 3, 4, 5]
print("Array.span 합 =", sum(arr.span))   // 15

Array.span 합 = 15

func checksum(_ s: Span<UInt8>) -> UInt8 {
    var x: UInt8 = 0
    for i in 0..<s.count { x ^= s[i] }
    return x
}

let bytes: [UInt8] = [1, 2, 3]
_ = checksum(bytes.span)                    // Array

var fixed: InlineArray<3, UInt8> = [1, 2, 3]
_ = checksum(fixed.span)                    // InlineArray — 힙 할당 없이

// Data·UnsafeBufferPointer 등도 대응되는 span 프로퍼티가 있다

@available(macOS 10.14.4, iOS 12.2, ...)
@frozen @safe public struct Span<Element>
    : ~Swift.Escapable, Swift.Copyable, Swift.BitwiseCopyable
    where Element : ~Copyable {
  @usableFromInline internal let _pointer: Swift.UnsafeRawPointer?
  @usableFromInline internal let _count: Swift.Int
}

@available(macOS 10.14.4, iOS 12.2, ...)
@safe @frozen public struct MutableSpan<Element>
    : ~Swift.Copyable, ~Swift.Escapable
    where Element : ~Copyable {
  @usableFromInline internal let _pointer: Swift.UnsafeMutableRawPointer?
  ...
}

var v: InlineArray<4, Int> = [10, 20, 30, 40]

// ① 변수에 담기 — 탈출
var m = v.mutableSpan
// error: lifetime-dependent value escapes its scope

// ② inout 인자로 넘기기 — mutableSpan은 get-only 프로퍼티
func double(_ m: inout MutableSpan<Int>) { /* ... */ }
double(&v.mutableSpan)
// error: cannot pass immutable value as inout argument:
//        'mutableSpan' is a get-only property

// ③ 첨자에 직접 대입
v.mutableSpan[0] = 99
// error: cannot assign through subscript:
//        'mutableSpan' is a get-only property

func double(_ m: consuming MutableSpan<Int>) {
    for i in 0..<m.count { m[i] *= 2 }
}

var v: InlineArray<4, Int> = [10, 20, 30, 40]
double(v.mutableSpan)                      // 직접 넘긴다
print("수정 후 v =", v[0], v[1], v[2], v[3])

var a2 = [1, 2, 3]
double(a2.mutableSpan)                     // Array에도 똑같이 통한다
print("수정 후 Array =", a2)

수정 후 v = 20 40 60 80
수정 후 Array = [2, 4, 6]

func applyGain(_ samples: consuming MutableSpan<Float>, gain: Float) {
    for i in 0..<samples.count { samples[i] *= gain }
}

var buffer = [Float](repeating: 0.5, count: 1024)
applyGain(buffer.mutableSpan, gain: 0.8)     // 복사 없음, 반환 없음

// ✅ 읽기만 하므로 Span — 호출자가 편하다
func maxValue(_ s: Span<Float>) -> Float {
    var m = -Float.infinity
    for i in 0..<s.count { m = max(m, s[i]) }
    return m
}

// ✅ 정말 고쳐야 할 때만 MutableSpan
func clampInPlace(_ s: consuming MutableSpan<Float>, to limit: Float) {
    for i in 0..<s.count { s[i] = min(s[i], limit) }
}

@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *)
@frozen @safe @_addressableForDependencies
public struct InlineArray<let count : Swift.Int, Element>
    : ~Swift.Copyable where Element : ~Copyable {
  @usableFromInline internal let _storage: Builtin.FixedArray<count, Element>
}

print("InlineArray<4,Int>   size =", MemoryLayout<InlineArray<4, Int>>.size)
print("InlineArray<64,Int>  size =", MemoryLayout<InlineArray<64, Int>>.size)
print("InlineArray<4,UInt8> size =", MemoryLayout<InlineArray<4, UInt8>>.size)
print("[Int] size =", MemoryLayout<[Int]>.size)

InlineArray<4,Int>   size = 32
InlineArray<64,Int>  size = 512
InlineArray<4,UInt8> size = 4
[Int] size = 8

var v: InlineArray<4, Int> = [10, 20, 30, 40]   // 리터럴 — 개수가 4와 일치해야 한다
let w = InlineArray<3, Int>(repeating: 7)       // 반복 초기화
print("v =", v[0], v[1], v[2], v[3], "| w[1] =", w[1], "| w.count =", w.count)

var s = 0
for i in v.indices { s += v[i] }                // indices로 순회한다
print("indices 순회 합 =", s)

for i in v.indices { v[i] *= 2 }                // 제자리 수정
print("2배 후 =", v[0], v[1], v[2], v[3])

v = 10 20 30 40 | w[1] = 7 | w.count = 3
indices 순회 합 = 100
2배 후 = 20 40 60 80

var a: [4 of Int] = [1, 2, 3, 4]
print("[4 of Int] size =", MemoryLayout<[4 of Int]>.size, "a[2] =", a[2])
print("같은 타입인가:", [4 of Int].self == InlineArray<4, Int>.self)

[4 of Int] size = 32 a[2] = 3
같은 타입인가: true

struct Token: ~Copyable {
    let id: Int
    deinit { }
}

// ✅ InlineArray — 컴파일·실행된다
var box: InlineArray<3, Token> = [Token(id: 1), Token(id: 2), Token(id: 3)]
print("count:", box.count, "| box[1].id =", box[1].id)
print("size:", MemoryLayout<InlineArray<3, Token>>.size)

// ❌ Array — 컴파일되지 않는다
// var a: [Token] = [Token(id: 1)]

count: 3 | box[1].id = 2
size: 24

$ swiftc -c array_version.swift
error: type 'Token' does not conform to protocol 'Copyable'

func sum(_ sp: Span<Int>) -> Int {
    var t = 0
    for i in 0..<sp.count { t += sp[i] }
    return t
}
var v: InlineArray<4, Int> = [10, 20, 30, 40]
print("InlineArray.span 합 =", sum(v.span))   // 100

struct RGBA {
    var channels: InlineArray<4, UInt8>      // 딱 4개 — 힙 할당 0
    init(r: UInt8, g: UInt8, b: UInt8, a: UInt8) { channels = [r, g, b, a] }
}
// MemoryLayout<RGBA>.size == 4 — struct 안에 그대로 들어간다

var big: InlineArray<64, Int> = ...           // 512바이트

// ❌ 값으로 받으면 512바이트 복사 가능성
func processByValue(_ v: InlineArray<64, Int>) -> Int { ... }

// ✅ 창으로 받으면 16바이트만 넘어간다
func processBySpan(_ s: Span<Int>) -> Int { ... }
_ = processBySpan(big.span)

func useSpan(_ s: Span<Int>) -> Int { s.count }
func useInline() -> Int {
    let v: InlineArray<4, Int> = [1, 2, 3, 4]
    return v.count
}

$ swiftc -target arm64-apple-macos15.0 -c avail.swift

avail.swift:3:12: error: 'InlineArray' is only available in macOS 26.0 or newer
  note: add '@available' attribute to enclosing global function
  note: add 'if #available' version check

avail.swift:4:14: error: 'count' is only available in macOS 26.0 or newer
  note: add '@available' attribute to enclosing global function
  note: add 'if #available' version check

$ swiftc -target arm64-apple-macos26.0 -c avail.swift
(에러 없음)

# 1) 배포 타깃 확인 (Xcode 프로젝트)
grep -r "IPHONEOS_DEPLOYMENT_TARGET" *.xcodeproj/project.pbxproj | sort -u

# 2) SPM 패키지라면
grep -A3 "platforms:" Package.swift

# 3) 직접 컴파일해 물어본다 — 가장 확실하다
swiftc -target arm64-apple-ios18.0-simulator -c probe.swift

// ✅ 공개 표면 — 배포 타깃 제약을 만들지 않는다
public func checksum(_ bytes: Span<UInt8>) -> UInt8 {
    var x: UInt8 = 0
    for i in 0..<bytes.count { x ^= bytes[i] }
    return x
}

// 내부 최적화 경로만 조건부로
@available(iOS 26, macOS 26, *)
func fastPath() -> UInt8 {
    var scratch: InlineArray<16, UInt8> = .init(repeating: 0)
    // ... scratch 사용
    return checksum(scratch.span)
}

struct Wrapper: ~Escapable {
    let s: Span<Int>
    init(_ s: Span<Int>) { self.s = s }
}

error: the 'get' accessor cannot return a ~Escapable result
  |     let s: Span<Int>
error: an initializer cannot return a ~Escapable result
  |     init(_ s: Span<Int>) { self.s = s }

struct Cursor: ~Escapable {
    private let base: Span<Int>
    @lifetime(copy base)
    init(_ base: Span<Int>) { self.base = base }
    var first: Int { base[0] }
}

warning: Unsupported use of @lifetime, use @_lifetime to specify
         lifetime dependencies
error: '@lifetime' attribute is only valid when experimental feature
       LifetimeDependence is enabled
error: the 'get' accessor cannot return a ~Escapable result
error: an initializer cannot return a ~Escapable result

error: '@_lifetime' attribute is only valid when experimental feature
       Lifetimes is enabled

struct Cursor: ~Escapable {
    private let base: Span<Int>
    @_lifetime(copy base)
    init(_ base: Span<Int>) { self.base = base }
    var first: Int { base[0] }
}
func use(_ s: Span<Int>) -> Int { Cursor(s).first }
let arr = [10, 20, 30]
print("Cursor.first =", use(arr.span))

Cursor.first = 10

# 실험 플래그 없이 컴파일해 본다 — 통과하면 정식 기능이 된 것이다
swiftc probe.swift -o /dev/null

# 관련 실험 기능 목록을 훑는다
swiftc -Xfrontend -help-hidden 2>&1 | grep -i lifetime

// ❌ 지금은 수명 애노테이션 없이 쓸 수 없다
// func slice(of a: [Int]) -> Span<Int> { a.span }

// ✅ 무엇을 할지 클로저로 받는다 — 정식 문법으로 충분하다
func withSlice<R>(of a: [Int], _ body: (Span<Int>) -> R) -> R {
    body(a.span)
}
let total = withSlice(of: [1, 2, 3]) { s in
    var t = 0
    for i in 0..<s.count { t += s[i] }
    return t
}
print(total)   // 6

$ IF=".../Swift.swiftmodule/arm64e-apple-macos.swiftinterface"
$ grep -oE "public struct (MutableSpan|RawSpan|MutableRawSpan|OutputSpan)<?" "$IF" | sort -u

public struct MutableRawSpan
public struct MutableSpan<
public struct OutputSpan<
public struct RawSpan

// ① Span — 읽기 전용. 기본값이고 대부분 여기서 끝난다
func checksum(_ s: Span<UInt8>) -> UInt8 {
    var x: UInt8 = 0
    for i in 0..<s.count { x ^= s[i] }
    return x
}

// ② MutableSpan — 개수는 그대로, 내용만 제자리 수정
func normalize(_ s: consuming MutableSpan<Float>, by d: Float) {
    for i in 0..<s.count { s[i] /= d }
}

// ③ RawSpan — 타입 없는 바이트열. 파일 헤더 파싱, 네트워크 프레임 등
func firstByte(_ r: RawSpan) -> UInt8? {
    r.byteCount > 0 ? r.unsafeLoad(fromByteOffset: 0, as: UInt8.self) : nil
}
let bytes: [UInt8] = [42, 7, 9]
print(firstByte(bytes.span.bytes) ?? 255)   // 42 — .bytes 로 Span → RawSpan

// ④ OutputSpan — 빈 용량을 채워 개수를 늘리는 역할 (초기화 담당)