[Swift] Opaque Type이란

SwiftUI를 보면

body에 some 키워드가 붙은걸 볼 수 있습니다.

이게 뭔지 궁금해져서 찾아보고 정리하고자 합니다  🤔

 

참고 자료 : https://docs.swift.org/swift-book/LanguageGuide/OpaqueTypes.html

Opaque Types — The Swift Programming Language (Swift 5.6)

https://jcsoohwancho.github.io/2019-08-24-Opaque-Type-%EC%82%B4%ED%8E%B4%EB%B3%B4%EA%B8%B0/

Opaque Type 살펴보기

 

Opaque type

리턴되는 값의 타입 정보를 숨기고자 합니다. 즉 함수가 메소드가 리턴하는 구체적인 타입을 제공하는 대신에 리턴값은 해당 타입이 채택하고 있는 프로토콜 측면에서 설명됩니다.

Opaque type은 실제 타입 정보를 감추어 모듈과 모듈의 결합성을 낮추는데 유용하다고 합니다.

예시 )
만약 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())
// *
// **
// ***

프로토콜 Shape을 준수하는 Triangle은 위의 코드와 같습니다.

이번엔 모양을 수직으로 뒤집는 FippledShape를 작성해보겠습니다.

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())
// ***
// **
// *

 

하지만 여기에는 제약사항이 있는데요. FlippedShape을 보면 <T: Shape>와 같이 제네릭 타입이 노출됩니다.

여기에 또 하나를 더 감싼다면 ?

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())
// *
// **
// ***
// ***
// **
// *

JoinedShape<FlippedShape<Triangle>, Triangle> 와 같이 타입이 중첩되고 불필요한 코드가 계속 작성됩니다.

Shape 프로토콜의 생성에 대한 구체적인 정보 노출은 전체 반환 타입을 명시해야 하기 때문에 ASCII 그림 모듈의 인터페이스 일부가 아닌 전체 타입이 노출 될수 있습니다. 
JoinedShape 및 FlippedShape와 같은 Wrapper 타입은 모듈 사용자에게 중요하지 않으며 표시되지 않아야 합니다. 

해당 구조체들이 모두 Shape 프로토콜을 채택하고 있다는 점에서 타입의 노출은 감추고  모듈의 인터페이스에서는 Shape임을 알려줄 필요가 있습니다. 

Returning an Opaque Type

 

Opaque Type을 Generic Type의 역으로 생각할 수 있습니다. Generic Type을 사용하면 함수를 호출하는 코드에서 해당 함수의 매개변수에 대한 타입을 선택하고 함수 구현에서 추상화된 방식으로 값을 반환합니다. 

func max<T>(_ x: T, _ y: T) -> T where T: Comparable { … }

이러한 역할은 Opaque를 리턴 타입으로 가지는 함수와는 정반대입니다. Opaque Type 사용하면 함수 구현이 함수를 호출하는 코드에서 추상화된 방식으로 반환하는 값의 유형을 선택할 수 있습니다.

 

generic type : 호출 하는 쪽 (구체적인 타입 지정) <-> 호출 받는 쪽(generic을 사용한 추상화)

opaque tyoe: 호출 하는 쪽 (모듈간 결합을 줄이기 위한 추상화) <-> 호출 받는 쪽(특정 인터페이스로 통합된다는 구체적인 타입 지정)

 

struct Square: Shape {
    var size: Int
    func draw() -> String {
        let line = String(repeating: "*", count: size)
        let result = Array<String>(repeating: line, count: size)
        return result.joined(separator: "\n")
    }
}

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 프로토콜을 채택하는 어떤 값을 반환합니다. 구체적인 type을 명시하지 않고 인터페이스의 근본적인 부분만을 표현합니다. 즉 리턴 값 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())
// *
// **
// ***
// ***
// **
// *

generic과 opaque를 결합하여 사용 할 수도 있습니다. flip(), join() 함수가 Shape를 채택하는 어떤 타입을 반환함으로써 타입이 가시화되는 것을 막을 수 있습니다. 

 

Opaque Type과 Protocol Type의 차이점

opaque type을 리턴하는 것과 protocol type을 리턴 타입으로 사용하는 것은 매우 비슷해보입니다.

하지만 type identity를 보존하는지 아닌지에 따라 다릅니다.
opaque type은 비록 함수의 호출자가 어떤 타입인지 볼수 없어도, 하나의 구체적인 타입을 나타냅니다. 반면 protocol type은 protocol을 순응하는 어떤 타입을 나타냅니다. 

일반적으로,  protocol type이 opaque type보다 더 유연함을 제공합니다. opaque type은 타입에 대해 강력한 보장을 제공합니다. 

예를 들어봅시다.

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

Shape라는 protocol type을 리턴하는 protoFlip 함수가 있습니다. 
flip() 함수와 달리 protoFlip() 함수는 Shape 프로토콜을 순응하고 있을뿐, 항상 같은 타입을 필요로 하지 않습니다. 즉, 여러 타입을 반환 할수 있는 유동성을 가집니다.

 

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

만약 protoFlip 함수가 위와 같이 수정되었다면, Square 객체 또는 FlippedShape 객체를 반환 할 것입니다. 즉 protoFlip()의 명확하지 않은 반환값은 타입에 의존하는 많은 곳에서 사용할 수 없음을 의미합니다. 

예를 들어 == 연산자를 쓰는 것은 불가능할 것입니다. (구체적인 타입을 가지지 않으므로 !)

let protoFlippedTriangle = protoFlip(smallTriangle)
let sameThing = protoFlip(smallTriangle)
protoFlippedTriangle == sameThing  // Error

먼저, 양쪽 타입에 대한 구체적인 타입을 보장할 수 없으며 프로토콜의 일부 인터페이스만 이용할 수 있게 되는 문제가 생깁니다. Shape에 ==을 사용 할 수 있도록 Equatable을 추가로 준수한다 하더라도 구체적인 타입이 없기 때문에 자신의 타입 정보가 필요한 == 메소드를 호출할 수 없습니다.

또다른 문제는 프로토콜로 반환한 값은 중첩해서 사용 할 수 없다는 것입니다.

let flippedTriangle = protoFlip(smallTriangle)
let original = protoFlip(filppedTriangle) // Error!

프로토콜 타입으로 반환한 값은 프로토콜을 채택하지 않은 것으로 여겨지기 때문입니다.
결국 protocol type은 명확한 타입이 없기 때문에 ~ 로부터 발생하는 여러가지 이슈들이 있습니다. 이를 보완하기 위해 명확한 타입이 있는 opaque type을 이용합니다.

 

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

< protocol type >

// Error: Protocol with associated types can't be used as a return type.
    func makeProtocolContainer<T>(item: T) -> Container {
        return [item]
    }

    // Error: Not enough information to infer C.
    func makeProtocolContainer<T, C: Container>(item: T) -> C {
        return [item]
    }

프로토콜 Container가 연관 타입 Item을 가지고 있기 때문에 에러가 발생합니다.

any Container를 쓰면 해결된다구 하네요 ,,, 하지만 도큐먼트에선 some으로 해결했는데 둘의 차이가 뭔지는 좀 더 찾아봅시담 ...

또한 두번째 함수는 Container를 추론할 정보가 없기 때문에 에러가 발생합니다.

<Opaque type 사용하여 해결>

func makeOpaqueContainer<T>(item: T) -> some Container {
    return [item]
}
let opaqueContainer = makeOpaqueContainer(item: 12)
let twelve = opaqueContainer[0]
print(type(of: twelve))
// Prints "Int"

 

 

---

 

우선 generic의 반대 개념이 필요할 때도 있다는것을 처음 느꼈습니다. 모듈간 결합은 복잡함을 유발하니 some 키워드로 명확한 타입을 보장한다는 점에서 프로토콜과 제네릭의 절충한 같다는 느낌을 받았습니다. 사용해본적이 없어 잘 와닿진 않으니 개념을 반복적으로 읽어봐야 할거 같습니다 허허 새로운 개념을 배워서 배워도 배워도 부족함이 끝이 없는거 같슴다 ,,, any도 한번 찾아봐야겠군요 그럼 이만 ~~