Swift 공식 문서 정리 - 불투명한 타입 (Opaque Types)

안녕하세요. 오늘은 Swift의 '불투명 타입(Opaque Types)'에 대해 알아보겠습니다. 불투명 타입은 값의 구체적인 타입 정보를 숨기면서도 타입 안전성을 유지하는 도구입니다.

📌 불투명 타입이 해결하는 문제

먼저 불투명 타입이 필요한 이유와 해결하는 문제를 이해해보겠습니다. 다음과 같이 ASCII 문자로 도형을 그리는 간단한 예제를 살펴봅시다:

protocol Shape {
    func draw() -> String
}

struct Triangle: Shape {
    var size: Int
    func draw() -> String {
        var result: [String] = []
        for length in 1...size {
            result.append(String(repeating: "*", count: length))
        }
        return result.joined(separator: "\n")
    }
}

let smallTriangle = Triangle(size: 3)
print(smallTriangle.draw())
// 출력:
// *
// **
// ***

여기서 도형을 변형하는 기능을 추가해봅시다:

struct FlippedShape<T: Shape>: Shape {
    var shape: T
    func draw() -> String {
        let lines = shape.draw().split(separator: "\n")
        return lines.reversed().joined(separator: "\n")
    }
}

let flippedTriangle = FlippedShape(shape: smallTriangle)
print(flippedTriangle.draw())
// 출력:
// ***
// **
// *

그리고 두 도형을 결합하는 기능도 추가해봅시다:

struct JoinedShape<T: Shape, U: Shape>: Shape {
    var top: T
    var bottom: U
    func draw() -> String {
        return top.draw() + "\n" + bottom.draw()
    }
}

let joinedTriangles = JoinedShape(top: smallTriangle, bottom: flippedTriangle)
print(joinedTriangles.draw())
// 출력:
// *
// **
// ***
// ***
// **
// *

여기서 문제점:

이렇게 제네릭을 사용하면 반환 타입에 모든 구현 세부 정보가 노출됩니다. 예를 들어 joinedTriangles의 타입은 JoinedShape<Triangle, FlippedShape<Triangle>>입니다. 이런 복잡한 타입은:

1. 구현 세부 정보를 노출시켜 API의 추상화를 깨뜨립니다
2. 내부 구현이 변경되면 공개 API가 변경될 수 있습니다
3. 코드를 이해하기 어렵게 만듭니다

📌 불투명 타입으로 해결하기

불투명 타입은 이런 문제를 해결합니다. some Protocol 구문을 사용하여 "특정 타입을 반환하지만 그 타입이 무엇인지는 알려주지 않겠다"라고 말할 수 있습니다.

func makeTrapezoid() -> some Shape {
    let top = Triangle(size: 2)
    let middle = Square(size: 2)
    let bottom = FlippedShape(shape: top)
    let trapezoid = JoinedShape(
        top: top,
        bottom: JoinedShape(top: middle, bottom: bottom)
    )
    return trapezoid
}

let trapezoid = makeTrapezoid()
print(trapezoid.draw())
// 출력:
// *
// **
// **
// **
// **
// *

여기서 makeTrapezoid() 함수는 some Shape을 반환합니다. 함수의 구현은 복잡한 중첩 타입을 사용하지만, 호출자는 단지 그것이 Shape 프로토콜을 준수한다는 것만 알면 됩니다.

제네릭과 불투명 타입을 결합할 수도 있습니다:

func flip<T: Shape>(_ shape: T) -> some Shape {
    return FlippedShape(shape: shape)
}

func join<T: Shape, U: Shape>(_ top: T, _ bottom: U) -> some Shape {
    JoinedShape(top: top, bottom: bottom)
}

let opaqueJoinedTriangles = join(smallTriangle, flip(smallTriangle))
print(opaqueJoinedTriangles.draw())
// 출력:
// *
// **
// ***
// ***
// **
// *

불투명 타입을 사용하면 함수가 구현 세부 정보를 숨기면서도 Shape 프로토콜을 준수하는 특정 타입을 반환할 수 있습니다.

주의사항: 동일한 타입 반환 요구

불투명 타입을 반환하는 함수의 중요한 제약사항은 항상 동일한 타입을 반환해야 한다는 것입니다. 아래 코드는 컴파일되지 않습니다:

func invalidFlip<T: Shape>(_ shape: T) -> some Shape {
    if shape is Square {
        return shape // 오류: 반환 타입이 일치하지 않음
    }
    return FlippedShape(shape: shape) // 오류: 반환 타입이 일치하지 않음
}

이 함수는 때로는 Square를, 때로는 FlippedShape<T>를 반환하려고 시도하기 때문에 에러가 발생합니다.

📌 박스형 프로토콜 타입(Boxed Protocol Types)

불투명 타입과 비슷하지만 다른 개념인 '박스형 프로토콜 타입'을 살펴봅시다. Swift에서는 any Protocol 구문을 사용하여 표현합니다.

struct VerticalShapes: Shape {
    var shapes: [any Shape]
    func draw() -> String {
        return shapes.map { $0.draw() }.joined(separator: "\n\n")
    }
}

let largeTriangle = Triangle(size: 5)
let largeSquare = Square(size: 5)
let vertical = VerticalShapes(shapes: [largeTriangle, largeSquare])
print(vertical.draw())

여기서 [any Shape]는 박스형 프로토콜 타입의 배열입니다. 이 배열은 Shape 프로토콜을 준수하는 서로 다른 타입의 값들을 포함할 수 있습니다.

박스형 프로토콜 타입을 사용하면 타입 정보가 런타임까지 지워지므로(type erasure), 필요할 때 타입 캐스팅을 통해 원래 타입으로 다시 접근할 수 있습니다:

if let downcastTriangle = vertical.shapes[0] as? Triangle {
    print(downcastTriangle.size)  // 5 출력
}

📌 불투명 타입과 박스형 프로토콜 타입의 차이점

이 두 개념은 유사해 보이지만 중요한 차이점이 있습니다:

1. 타입 정체성 유지

• 불투명 타입(some Protocol): 특정 타입의 정체성을 유지합니다. 컴파일러는 실제 타입을 알고 있지만, 호출자에게는 숨깁니다.
• 박스형 프로토콜 타입(any Protocol): 타입 정체성을 지우고 런타임에 다양한 타입을 허용합니다.

2. 유연성과 성능

• 불투명 타입: 컴파일 시간에 실제 타입이 결정되므로 최적화가 가능하고 성능이 좋습니다.
• 박스형 프로토콜 타입: 런타임 유연성을 제공하지만 간접 참조(박싱)로 인한 성능 비용이 있습니다.

3. 타입 작업

다음 예는 반환 타입이 박스형 프로토콜인 함수입니다:

func protoFlip<T: Shape>(_ shape: T) -> any Shape {
    return FlippedShape(shape: shape)
}

// 다른 조건에 따라 다른 타입 반환 가능
func protoFlip<T: Shape>(_ shape: T) -> any Shape {
    if shape is Square {
        return shape
    }
    return FlippedShape(shape: shape)
}

let protoFlippedTriangle = protoFlip(smallTriangle)
let sameThing = protoFlip(smallTriangle)
// protoFlippedTriangle == sameThing  // 오류: '==' 연산 불가능

불투명 타입과 달리 박스형 프로토콜 타입은 타입 정보를 보존하지 않기 때문에 == 같은 연산자를 사용할 수 없습니다. 또한 타입 정보가 지워지기 때문에 연관 타입(Associated Types)이 있는 프로토콜과 함께 사용하는 데 제약이 있습니다.

4. 연관 타입이 있는 프로토콜

불투명 타입은 연관 타입이 있는 프로토콜을 반환 타입으로 사용할 수 있게 해줍니다:

protocol Container {
    associatedtype Item
    var count: Int { get }
    subscript(i: Int) -> Item { get }
}
extension Array: Container { }

// 오류: 연관 타입이 있는 프로토콜은 반환 타입으로 사용할 수 없음
func makeProtocolContainer<T>(item: T) -> Container {
    return [item]
}

// 불투명 타입으로 해결
func makeOpaqueContainer<T>(item: T) -> some Container {
    return [item]
}

let opaqueContainer = makeOpaqueContainer(item: 12)
let twelve = opaqueContainer[0]  // Int 타입
print(type(of: twelve))  // "Int" 출력

이 예제에서 불투명 타입은 연관 타입이 있는 프로토콜을 반환 타입으로 사용할 수 있게 해주며, 타입 추론까지 가능하게 합니다.

📌 불투명 파라미터 타입(Opaque Parameter Types)

함수 파라미터에서도 some Protocol 구문을 사용할 수 있습니다:

func drawTwiceSome(_ shape: some Shape) -> String {
    let drawn = shape.draw()
    return drawn + "\n" + drawn
}

그러나 중요한 차이점이 있습니다. 파라미터 타입에서 some을 사용하는 것은 진정한 불투명 타입이 아니라 제네릭의 간편 구문입니다. 위 함수는 다음과 동일합니다:

func drawTwiceGeneric<SomeShape: Shape>(_ shape: SomeShape) -> String {
    let drawn = shape.draw()
    return drawn + "\n" + drawn
}

여러 파라미터에 some을 사용하면 각각은 독립적인 제네릭 타입으로 간주됩니다:

func combine(shape s1: some Shape, with s2: some Shape) -> String {
    return s1.draw() + "\n" + s2.draw()
}

// 서로 다른 타입으로 호출 가능
combine(shape: smallTriangle, with: trapezoid)

이 간편 구문은 제네릭 where 절이나 동일 타입 제약(==)을 지원하지 않으므로, 복잡한 제약이 필요한 경우에는 전통적인 제네릭 구문을 사용해야 합니다.

📌 실전 사용 예시와 권장 사항

불투명 타입 사용이 좋은 경우:

1. 라이브러리/프레임워크 API 디자인: 구현 세부 정보는 숨기되 타입 안전성은 유지하고 싶을 때
2. 동일한 타입을 보장해야 하는 경우: 함수가 항상 동일한 구체적 타입을 반환해야 할 때
3. 연관 타입이 있는 프로토콜: 제네릭 제약으로 사용하기 어려운 프로토콜을 반환해야 할 때
4. 컴파일 시간 최적화가 중요한 경우: 성능이 중요하고 타입 정보가 필요할 때

박스형 프로토콜 타입 사용이 좋은 경우:

1. 이종 컬렉션: 다양한 타입의 객체를 하나의 컬렉션에 저장해야 할 때
2. 런타임에 타입이 결정되는 경우: 사용자 입력이나 동적 데이터에 따라 다른 타입을 사용해야 할 때
3. 타입 정체성이 중요하지 않은 경우: 다양한 타입의 객체를 처리하는 코드에서

📌 요약

불투명 타입(some Protocol)은 Swift의 강력한 기능으로, 구현 세부 정보를 숨기면서도 타입 안전성을 유지할 수 있게 해줍니다. 이는 제네릭과 결합하여 API를 더욱 표현력 있고 유연하게 만들 수 있습니다.

반면 박스형 프로토콜 타입(any Protocol)은 런타임 유연성을 제공하지만 타입 정보를 지우므로 일부 타입 기반 작업이 제한됩니다.