[Swift] Noncopyable structs and enums

💫 SE-0390Noncopyable structs and enums

 

Motivation

현재 Swift에서 존재하는 모든 타입은 복사 가능(copyable) 하므로, 해당 타입의 값에 대해 여러 개의 동일하고 교환 가능한 표현을 생성할 수 있습니다.

하지만, 복사 가능한 구조체(struct)와 열거형(enum)은 고유한 자원(unique resource)을 모델링하는 데 적합하지 않습니다.

반면, 클래스(class)는 객체가 한 번 초기화되면 고유한 정체성(unique identity)을 가지므로 고유한 자원을 표현할 수 있습니다. 하지만 클래스의 참조(reference)는 여전히 복사 가능하기 때문에, 클래스는 항상 자원의 공유 소유권(shared ownership)을 요구합니다.

이러한 공유 소유권은 다음과 같은 부가적인 오버헤드를 초래합니다.

• 객체의 전체 수명이 불분명하기 때문에 힙 할당(heap allocation)이 필요함
• 현재 객체를 공유하는 소유자의 수를 추적하기 위해 참조 카운팅(reference counting)이 필요함

또한, 공유 접근 방식은 객체의 API를 복잡하게 만들거나, 안전성 문제를 초래하거나, 추가적인 오버헤드를 발생시키는 경우가 많습니다.

현재 Swift에는 고유한 소유권(unique ownership)을 가지는 고유한 자원을 표현하는 타입을 정의하는 메커니즘이 존재하지 않습니다.

 

Proposed Solution

우리는 구조체(struct)와 열거형(enum) 타입이 noncopyable 가능하도록 선언할 수 있도록 제안하며, 이를 위해 새로운 문법 ~Copyable을 사용하여 암시적인 제네릭 제약을 억제(suppress)하는 방식을 도입하려 합니다.

~Copyable을 사용하면 Swift가 제네릭 타입이 자동으로 Copyable을 따르도록 하는 암시적인 제약을 제거할 수 있다.

noncopyable 타입의 값은 항상 고유한 소유권(unique ownership)을 가지며, 절대로 복사될 수 없습니다(적어도 Swift의 암시적 복사 메커니즘을 통해서는 불가능합니다).

noncopyable 구조체와 열거형의 값은 고유한 정체성(unique identity)을 가지므로, 클래스처럼 deinit 선언을 가질 수 있습니다. 이는 해당 고유 인스턴스의 생명 주기가 끝날 때 자동으로 실행됩니다.

struct FileDescriptor: **~Copyable** {
  private var fd: Int32

  init(fd: Int32) { self.fd = fd }

  func write(buffer: Data) {
    buffer.withUnsafeBytes { 
      write(fd, $0.baseAddress!, $0.count)
    }
  }

  **deinit** {
    close(fd)
  }
}

NonCopyable 타입으로 선언되었기 때문에,

• 값을 복사할 수 없음 (즉, 두 개 이상의 동일한 FileDescriptor 인스턴스를 만들 수 없음)
• 값은 항상 고유한 소유권(unique ownership)을 가짐
• 값이 복사되지 않으므로 각 인스턴스가 유일한 파일 핸들을 관리
• 불필요한 참조 카운팅(reference counting)과 공유 비용이 없음 ⇒ 빠르고 안전한 성능

이제 Swift에서 ~Copyable을 활용하면 구조체(struct)를 통해 고유한 리소스를 안전하고 효율적으로 관리할 수 있습니다.

• 기존에는 클래스를 사용해야 했지만, 이제는 Heap 할당 없이, 더 안전하고 빠르게 관리 가능
• deinit 지원을 통해 자동 리소스 해제 가능
• 불필요한 복사 방지로 성능 최적화

따라서, ~Copyable은 파일 디스크립터, 네트워크 소켓, GPU 버퍼 같은 고유한 자원(unique resource)을 관리하는 데 매우 적합한 기능입니다.

 

Noncopyable 타입을 포함하는 경우

• 구조체(struct)가 비복사 타입을 저장 프로퍼티(stored property)로 포함하거나,
• 열거형(enum)이 비복사 타입을 연관 값(associated value)으로 포함하는 경우,

→ 해당 구조체 또는 열거형도 반드시 ~Copyable을 선언해야 합니다.

즉, noncopyable 타입을 포함하는 타입 역시 자동으로 noncopyable 타입이 되어야 합니다.

struct SocketPair: ~Copyable {
  var in, out: FileDescriptor
}

enum FileOrMemory: ~Copyable {
  // write to an OS file
  case file(FileDescriptor)
  // write to an array in memory
  case memory([UInt8])
}

// **ERROR**: **copyable value type cannot contain noncopyable members**
struct FileWithPath {
  var file: FileDescriptor
  var path: String
}

 

Class와 noncopyable

 

Class의 경우에는 ~Copyable을 채택하지 않아도 noncopyable 프로퍼티를 가질 수 있다.

class SharedFile {
  var file: FileDescriptor
}

클래스(class) 타입 선언은 ~Copyable을 사용할 수 없음

모든 클래스 타입은 여전히 복사 가능(copyable) 하며, ~Copyable을 선언할 수 없습니다.

이는 클래스가 객체에 대한 참조(reference)를 복사할 때, 참조 카운팅(retain/release)을 통해 메모리를 관리하는 방식 때문입니다. 즉, 클래스 인스턴스 자체가 복사되는 것이 아니라 객체의 참조만 복사되므로, ~Copyable을 적용할 필요가 없습니다.

✅ 즉, 클래스는 항상 참조 타입(reference type)이므로 복사 가능하며, ~Copyable을 적용할 수 없습니다.

// **ERROR: classes must be `Copyable`**
class SharedFile: ~Copyable {
  var file: FileDescriptor
}

 

Noncopyable 타입이 제네릭 타입 인자로 사용될 수 없음

 

현재 Swift의 제네릭 시스템은 제네릭 타입이 항상 Copyable할 것을 요구합니다.

즉, noncopyable 타입(~Copyable)을 제네릭 인자로 전달하는 것은 불가능합니다.

이로 인해 noncopyable 타입(~Copyable)이 할 수 없는 것들:

1. 프로토콜 준수 불가 (단, Sendable은 예외)✅ FileDescriptor는 비복사 타입이므로 CustomStringConvertible 같은 프로토콜을 따를 수 없음.
2. ✅ 단, Sendable 프로토콜은 예외적으로 구현 가능.
3. struct FileDescriptor: ~Copyable, CustomStringConvertible { ... } // ❌ 불가능!
4. 제네릭 함수의 타입 인자로 사용 불가

func process<T>(_ value: T) { ... }

let fd = FileDescriptor(fd: 10)
process(fd) // ❌ 불가능!

1. Any 또는 다른 존재 타입(existential)으로 캐스팅 불가

let anyValue: Any = FileDescriptor(fd: 10) // ❌ 불가능!

비복사 타입은 Any나 다른 존재 타입으로 변환할 수 없음.

• ✅ 비복사 타입(~Copyable)은 자체적으로만 사용 가능하며,
• ❌ 제네릭 인자로 전달하거나, 프로토콜을 따르거나, Any로 변환하는 등 복사가 가능한 컨텍스트에서는 사용 불가능

→

즉, ~Copyable한 구조체 또는 열거형은 오직 자기 자신만 하위 타입(subtype)으로 가질 수 있음

다른 타입과의 변환이 불가능하기 때문에 복사를 허용하는 컨텍스트에서 사용될 수 없음

 

noncopyable struct 인스턴스를 할당하는 것 자체가 consume

let x = FileDescriptor()
let y = x
use(x) // ERROR: x consumed by assignment to `y`

 

noncopyable types을 파라미터로 사용 시,  borrowing, consuming, or inout convention 사용 필수

// Redirect a file descriptor
// Require exclusive access to the FileDescriptor to replace it
func redirect(_ file: inout FileDescriptor, to otherFile: borrowing FileDescriptor) {
  dup2(otherFile.fd, file.fd)
}

// **Error: Noncopyable parameter must specify its ownership**
func redirect(_ file: FileDescriptor, to otherFile: borrowing FileDescriptor) {
  dup2(otherFile.fd, file.fd)
}

// Write to a file descriptor
// Only needs shared access
func write(_ data: [UInt8], to file: borrowing FileDescriptor) {
  data.withUnsafeBytes {
    write(file.fd, $0.baseAddress, $0.count)
  }
}

// Close a file descriptor
// Consumes the file descriptor
func close(file: consuming FileDescriptor) {
  close(file.fd)
}

 

 

함수도 마찬가지

extension FileDescriptor {
  mutating func replace(with otherFile: borrowing FileDescriptor) {
    dup2(otherFile.fd, self.fd)
  }

  // borrowing by default
  func write(_ data: [UInt8]) {
    data.withUnsafeBytes {
      write(file.fd, $0.baseAddress, $0.count)
    }
  }

  consuming func close() {
    close(fd)
  }
}

 

Noncopyable 타입의 프로퍼티 선언

 

1. Noncopyable 타입을 저장 프로퍼티로 선언

클래스 또는 ~Copyable struct는 Noncopyable 타입을 저장 프로퍼티(let 또는 var)로 선언할 수 있다.

let 저장 프로퍼티

• let 프로퍼티는 오직 borrow만 가능
• 즉, 읽을 수는 있지만 변경하거나 consume할 수 없음

var 저장 프로퍼티

• var 프로퍼티는 borrow와 mutate모두 가능
• 하지만 일반적으로 consume은 불가능 (제한적으로 가능)
  • 이유: 프로퍼티가 소비되면 해당 인스턴스(구조체/클래스)가 무효 상태가 될 수 있기 때문

struct NonCopyableResource: ~Copyable {
    var id: Int
}

struct Container: ~Copyable {
    let resource: NonCopyableResource // ✅ let 프로퍼티 (borrow만 가능)

    func consumeResource() {
        let resourceCopy = move(resource) // ❌ ERROR: 'resource' cannot be consumed because it is immutable
    }

    func move(_ resource: consuming NonCopyableResource) {
        consume resource
    }
}

struct Container: ~Copyable {
    var resource: NonCopyableResource // ✅ var 프로퍼티 (borrow + mutate 가능)

		mutating func updateResource(id: Int) {
        resource.id = id // ✅ mutate 가능 (수정 가능)
    }

    func consumeResource() {
        let resourceCopy = move(resource) // ❌ ERROR: 'resource' cannot be consumed
    }

    func move(_ resource: consuming NonCopyableResource) {
        consume resource
    }
}

 

2. Noncopyable 타입을 computed 프로퍼티로 선언

• 모든 타입은 Noncopyable 타입을 계산 프로퍼티로 선언 가능
• get 접근자는 소유권(owned value)을 반환할 수 있음 → 즉, 호출한 쪽에서 값을 consume할 수 있음
• set 접근자는 newValue를 consume하는 방식으로 받음 → 즉, 기존 값을 consume하여 새로운 값으로 교체 가능

consuming get을 활용한 소유권 이전

• consuming get을 사용하면 일부 값을 소유권과 함께 반환할 수 있음
• 이는 래퍼(wrapper) 타입에서 내부 값의 소유권을 넘겨주는 방식으로 유용

struct FileDescriptorWrapper: ~Copyable {
  private var _value: FileDescriptor

  var value: FileDescriptor { // 'self' is borrowed and cannot be consumed ?!
    consuming get { return _value }
  }
}

 

Class에서 Noncopyable 저장 프로퍼티 사용

 

1) 클래스의 저장 프로퍼티와 동적 배타성 검사(Dynamic Exclusivity Checking)

Swift에서는 객체(Class Instance)가 여러 참조(reference)를 가질 수 있기 때문에,

동시에 같은 저장 프로퍼티를 수정하는 것을 방지하기 위해 "동적 배타성 검사(Dynamic Exclusivity Checking)"를 수행합니다.

이 동적 검사(runtime check)는 ~Copyable 저장 프로퍼티에도 적용됩니다.

즉, 동시에 borrow(대여)와 mutate(변경)가 시도되면, 런타임 오류가 발생할 수 있습니다.

Swift는 borrow 상태에서 mutate가 불가능하도록 강제함

class Foo {
  var fd: FileDescriptor

  init(fd: FileDescriptor) { self.fd = fd }
}

func update(_: inout FileDescriptor, butBorrow _: borrow FileDescriptor) {}

func updateFoo(_ a: Foo, butBorrowFoo b: Foo) {
  update(&a.fd, butBorrow: b.fd)
}

let foo = Foo(fd: FileDescriptor())

// Will trap at runtime when foo.fd is borrowed and mutated at the same time
updateFoo(foo, butBorrowFoo: foo)

 

Noncopyable 변수가 escaping 클로저에서 캡처될 때의 동작

 

nonescaping vs. escaping 클로저에서 Noncopyable 변수 캡처 차이

• nonescaping 클로저는 유효 범위(scope)가 한정됨 → 따라서 변수를 borrow(대여)할 수 있음
• escaping 클로저는 프로그램이 실행되는 동안 언제든지 호출될 수 있음 → 따라서 변수의 소유권을 명확하게 관리해야 함

💡 즉, escaping 클로저에서 Noncopyable 변수를 캡처하면, 변수는 항상 borrow 상태가 되며 consume(소비)할 수 없음

• escaping 클로저는 현재 스코프를 벗어나서도 실행될 수 있음
• 일반적으로 Swift의 Copyable한 값들은 escaping 클로저에서 안전하게 복사 가능
• 하지만 비복사(~Copyable) 변수는 복사할 수 없으므로, consume하면 원본이 사라짐

🚨 즉, consume하면 변수가 더 이상 존재하지 않으므로, 이후 실행될 클로저에서 해당 변수를 사용할 수 없음

import Dispatch

struct FileDescriptor: ~Copyable {
  private var fd: Int32

  init(fd: Int32) { self.fd = fd }

  func read() {
    print("Reading from fd: \\(fd)")
  }

  consuming func close() {
    print("Closing fd: \\(fd)")
  }
}

func escape(_ closure: @escaping () -> Void) {
  DispatchQueue.global().asyncAfter(deadline: .now() + 1) {
    closure()
  }
}

func test() {
  let file = FileDescriptor(fd: 42)

  escape {
    file.read() // ✅ `borrow` 가능 (읽기 전용)
    // file.close() // ❌ ERROR: `file`은 `escaping` 클로저에서 `borrow` 상태이므로 `consume` 불가
  }
}

test()

 

구조체(struct) 및 열거형(enum)의 deinit 특징

• 클래스의 deinit과 마찬가지로, struct 및 enum의 deinit에서도 오류를 던질 수 없음
• deinit 내부에서 self는 borrow 상태
  • 즉, mutate(변경)하거나 consume(소비)할 수 없음

struct FileDescriptor: ~Copyable {
  private var fd: Int32

  init(fd: Int32) { self.fd = fd }

  deinit {
    print("Closing file descriptor \\(fd)")
    // self.fd = -1 ❌ ERROR: `deinit` 내부에서는 `mutate` 불가
    // consume self ❌ ERROR: `deinit` 내부에서는 `consume` 불가
  }
}

 

 

바깥 ~Copyable이 먼저 deinit 됨.

struct Inner: ~Copyable {
  deinit { print("destroying inner") }
}

struct Outer: ~Copyable {
  var inner = Inner()
  deinit { print("destroying outer") }
}

do {
  _ = Outer()
}

// destroying outer
// destroying inner

 

discard self를 활용하여 deinit 실행 억제

Noncopyable 타입에서 deinit이 실행되지 않도록 하기 위해 discard self 연산자를 도입

• discard self는 해당 객체(self)의 수명을 종료하지만, deinit을 호출하지 않음
• 이를 통해 리소스를 직접 제어 가능

struct FileDescriptor: ~Copyable {
  private var fd: Int32

  deinit {
    close(fd)
  }

  consuming func close() {
    close(fd)

    // The lifetime of `self` ends here, triggering `deinit` (and another call to `close`)!
  }
}

struct FileDescriptor: ~Copyable {
  private var fd: Int32

  // 파일 디스크립터를 닫을 때, `deinit`이 실행되지 않도록 억제
  consuming func close() throws {
    if close(fd) != 0 {
      throw CloseError(errno)
    }

    discard self // ✅ `deinit`이 실행되지 않음
  }
}

 

 

조건부로 deinit을 실행할지 여부를 결정 가능

✅discard self를 사용하면 deinit이 실행되지 않고, consume self를 사용하면 deinit 실행됨

struct MemoryBuffer: ~Copyable {
  private var address: UnsafeRawPointer

  init(size: Int) throws {
    guard let address = malloc(size) else {
      throw MallocError()
    }
    self.address = address
  }

  deinit {
    free(address)
  }

  consuming func takeOwnership(if condition: Bool) -> UnsafeRawPointer? {
    if condition {
      // Save the memory buffer and give it to the caller, who
      // is promising to free it when they're done.
      let address = self.address
      **discard self**
      return address
    } else {
      // We still want to free the memory if we aren't giving it away.
      **_ = consume self**
      return nil
    }
  }
}