[Swift🦩] #24 불투명한 타입 Opaque Type

• 함수의 반환 타입을 가린다.
• 함수의 반환 타입으로 구체적인 타입을 제공하지 않고, 프로토콜 측면에서 서술한다.
• 프로토콜 타입인 어떤 값을 반환하는 것이 아니라, 프로토콜 타입의 정체성을 보존한다.
• 컴파일러는 타입 정보에 접근이 되는데, 클라이언트 모듈은 타입 정보에 접근할 수 없다.
• 해당 프로토콜을 따르는 (상속된 프로토콜 안됨) 타입만이 Opaque Type 으로 return 될 수 있음.

1. 불투명한 타입이 해결하는 문제

• ASCII 그림을 그리는 모듈을 작성한다고 가정하면,
• ASCII 의 특성은 Shape 프로토콜에 요구사항인
• 어떤 모양의 문자열 표현을 반환하는 draw() 함수.

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



// 위의 코양을 수직으로 뒤집는 코드를 구현.
// Triangle 을 넣으면 FlippedShape<Triangle> 이 생성됨.
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())
// ***
// **
// *


// 위의 두 코드를 결합
// 역시 Triangle 을 넣으면?
// JoinedShape<FlippedShape<Triangle>, Triangle> 이런 타입이 생성됨.
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> 이런걸 반환 타입으로 쓰고 싶지도 않다...
• 어떤 모양이라도 뒤집어 줄 수 있고, 데칼코마니 해줄 수 있어야 하기 때문에,
• Generic 으로 두 타입을 똑같이 맞추고, return type 도 Shape 가 되는 것.

• 그래서 JoinedShape 와 FlippedShape 와 같은 래퍼 타입은 모듈의 사용자에게는 중요하지 않은 정보이므로 표시되지 않아야 함 -> 우리에게 필요한건 그게 Shape 라는 것 뿐.
  • 어떻게 뒤집고 합치는지에 대한 정보는 공개할 필요가 없다.
  • Generic 의 경우, 아래처럼 Element 를 사용하여 프로퍼티나 메서드를 구현하고, 실제 호출 시 Stack<Int> (Int는 Equatable) 이렇게 Element 가 정해지게 되는데,
  • 불투명한 타입의 경우, 정확히 뭔지는 필요없고 Equatable 을 따르는 some Equatable 로 리턴하고 싶다는 뜻.
  • 왜냐면 / 이렇게 생긴 FilppedShape 인지 > 이렇게 생긴 JoinedShape 인지가 중요해?
  • Shape 이면서 draw 함수를 쓸 수 있어서 모양만 출력되면 되잖아!!!!

struct Stack<Element: Equatable> {
    var list: [Element]
    mutating func append(_ element: Element) {
        list.append(element)
    }
    // Generic
    mutating func pop() -> Element {
        return list.remove(at: list.count - 1)
    }
    
    // Opaque Type
    mutating func pop() -> some Equatable {
        return list.remove(at: list.count - 1)
    }
}

2. 불투명한 타입 반환

• Generic 과 반대.
• Generic
  • 호출하는 코드에서 파라미터 타입을 선택
  • 함수를 구현부에서 추상화 된 인자로 값을 반환할 수 있음.
• 원래는!!! Generic 으로 T 라는 type 을 정하고 그걸 return 값에까지 적용해서 함수 외부에서까지 사용해야하므로, 타입을 외부에서 명시를 해야함.

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

• max 를 실제로 호출할 때, 넣는 x, y 파라미터 타입에 따라 달라지는 T를 반환하게 된다.

some Type - Opaque Type

하지만 Opaque Type 의 경우?

• 함수를 호출할 때 return 값이 추상화된 타입으로 반환되게 할 수 있다.
• some 키워드 사용.

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")
    }
}

// 그래서 some Shape 라는 값으로 반환.
// JoinedShape<Triangle, FilppedShape<Triangle>> 처럼 타입을 정해줄 필요가 없다.
// <T: Shape>  -> T 가 없는데도, some Shape 라는 값으로 반환이 가능한 것.
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())
// *
// **
// **
// **
// **
// *

wrapping 함수 Generic 과 결합

• Opaque Types 는 파라미터 타입에는 사용할 수가 없으므로,
• Generic 과 결합해서 파라미터가 프로토콜을 따르도록 사용할 수 있다.

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

• 기본 타입을 filp join 함수로 래핑해서 FlippedShape, JoinedShape 가 어떤 타입인지 드러나지 않게 한다.
• 모두 some Shape 일 뿐.

return 이 모두 같은 Type 이어야 함.

• 반환하는 값이 모두 Shape 여야 한다. (단일 타입을 반환한다고 표현함)
• Shape 를 따르는 어떤 구현체도 안됨.

func invalidFlip<T: Shape>(_ shape: T) -> some Shape {
    if shape is Square {
        return shape // Error: return types don't match
    }
    return FlippedShape(shape: shape) // Error: return types don't match
}

struct FlippedShape<T: Shape>: Shape {
    var shape: T
    func draw() -> String {
        if shape is Square { 
            return shape.draw() // 이렇게. 사용하자.
        }
        let lines = shape.draw().split(separator: "\n")
        return lines.reversed().joined(separator: "\n")
    }
}

• 타입을 반환할 때 Generic 도 사용할 수 있다.
• 대신 기본 타입 T 를 주기 때문에, 단일 타입을 따르게 되어서 가능한 것임.
• Collection 이라고 분기타서 Dictionary 와 Array 를 반환하는 경우는 안된다는 것.

// 반환값의 기본 타입을 Array<Shape> 로 설정.
// 대신 Shape 가 원소로 들어가야함.
func `repeat`<T: Shape>(shape: T, count: Int) -> some Collection {
    return Array<T>(repeating: shape, count: count)
}

• 꼭 함수의 반환값만이 아니라 변수의 타입으로도 지정 가능. (파라미터는 안됨)

var f1: CarFactory = TeslaFactory()
// ERROR : Protocol 'CarFactory' can be only used as a generic constraint ...
var f1: some CarFactory = TeslaFactory()
print(f1.produce())
// OK

3. Opaque Type vs Protocol

• 프로토콜을 사용하는 것과 불투명 타입을 return 하는 것은 비슷한데,
• 반환 타입이 타입 정체성을 유지하는지 여부로 갈린다.
• Opaque Type 은 하나의 특정 타입을 참조하지만, 함수를 호출하는 녀석이 어떤 타입인지는 모른다.
• 프로토콜 타입은 프로토콜을 준수하는 모든 타입을 참조할 수 있다.

• 프로토콜은 프로토콜을 준수하는 모든 타입을 유연하게 반환할 수 있다.
  • 하지만 Type Casting 을 하지 않으면 반환된 값에 대한 일부 작업을 수행할 수 없다.
• 불투명한 타입은 기본 타입에 대한 강력한 보장을 할 수 있다. (무조건 Shape 로 반환.)
  • 프로토콜 타입을 반환값으로 쓸 수 없는 위치에 쓴다.

// 프로토콜로 구현한 위의 함수. 
// Shape 프로토콜을 따르는 여러 타입의 값을 반환할 수 있다.
func protoFlip<T: Shape>(_ shape: T) -> Shape {
    if shape is Square {
        return shape // Square return 가능.
    }

    return FlippedShape(shape: shape)
}

let protoFlippedTriangle = protoFlip(smallTriangle)
let sameThing = protoFlip(smallTriangle)
protoFlippedTriangle == sameThing  // Error : == 이 구현이 안되어 있음.


protoFlip(protoFlip(smallTriangle)) // Error : 한 번 뒤집은게 유효한 인수가 아님. 
// Generic T: Shape 에는 Shape 를 구현한 구체적인 타입만이 갈 수 있는데,
// Shape 가 반환 타입이므로 Shape 프로토콜 자체를 인자로 넣은 것이 됨.

protoFlip(protoFlippedTriangle as! FlippedShape<Triangle>)
// 정확한 타입으로 downcast 하면 가능함.

• Error : 프로토콜 타입을 사용해서 특정 정보가 보존되지 않음.
• Shape 에는 == 이 구현이 안되어있기 때문.
• 근데 == 을 추가하려고 하면, 프로토콜을 채택한 구체적인 타입을 나타내는 Self 타입의 인수를 사용해야함.
• 하지만 Self 를 프로토콜에 추가한다면?
  • 어떤 타입인지를 알아야 Self 를 쓸 수 있어서 Type Erasure 그게 뭔데... 가 허용되지 않음.

protocol Container {
    associatedtype Item 
    // Item 이라는 associatedtype 이 있어서 Container 를 반환타입으로 사용할 수 없음.
    // Item 이 어떤 타입인지를 모르니까.
    // 반환 제약 조건으로도 사용이 안됨.
    var count: Int { get }
    subscript(i: Int) -> Item { get }
}
extension Array: Container { }


// 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]
}


// 그치만 이렇게 some 을 붙여서 불투명한 타입을 보내주면?
// 컨테이너를 반환하되, 타입 지정은 거부하게 되므로 연관 타입이 있는 protocol 반환이 가능해진다.
func makeOpaqueContainer<T>(item: T) -> some Container {
    return [item]
}
let opaqueContainer = makeOpaqueContainer(item: 12)
let twelve = opaqueContainer[0]
print(type(of: twelve))  // Prints "Int" : 타입 추론 가능.

Type Erasure 그게 뭔데...

func getComparable() -> Comparable { // error : 프로토콜을 따르는 타입을 반환할 수가 없음.
  return 1
}

// 그래서 아래처럼 Generic 을 통해서 Comparable 을 따르는 어떤 타입을 사용한다고 명시해야 했음.
// 그러면 함수 외부에서 이 타입이 뭔지... 명시가 필요함.
func getComparable<T: Comparable>() -> T {
  return 1 as! T
}
func getComparable<T>() -> T 
    where T: Comparable {
  return 1 as! T
}

• 그래서 Opaque Type 이 등장했는데...?

func getComparable() -> some Comparable {
  return 1
}

• 아래처럼 분기를 타서 여러 comparable 을 따르는 값을 return 하고 싶다면..?

func getComparable() -> some Comparable {
	if true { return 1 }
    else { return "oh my god" }
}

• Opaque Type 에서 return 값이 만족해야 하는 조건을 따르게 하기 위해.
• Type 을 지워서 뭉뚱그려줘야함.

• AnyComparable 같은 구조체를 만들어서 타입을 지운다.
• 자세한 코드는 https://minsone.github.io/programming/swift-opaque-type-and-erase-type
• 아무튼 Self 를 프로토콜에 추가하게 되면, Type 을 지울수가 없다.
  • Self 라는 해당 객체의 정확한 타입을 나타내는 거니까.

https://sanichdaniel.tistory.com/16

• Generic 은 타입을 추상화 하되, 해당 타입이 어떤 프로토콜을 따르는지나 어떤 타입인지 등을 <T: Equtable> where 키워드로 지정해줄 수 있었음.
• 그리고 실제로 사용할 때, 아 이거 정확하게 어떤 타입이다! 라고 지정이 되어서 들어감.

• 그렇기 때문에 Generic 으로 T 라는 type 을 정하고 그걸 return 값에까지 적용해서 함수 외부에서까지 사용해야하므로, 들어가는 타입을 외부에서 명시해야함. Array<Int>

• 하지만 Opaque 타입은 정확하게 어떤 타입이다! 없음. 추상화된(상위) 타입을 그대로 return.
• 함수 외부에서 어떤 프로토콜을 따르는 타입을 정확하게 명시하는걸 피하기 위해서 사용

func getComparable<T>() -> T 
    where T: Comparable {
  return 1
}

질문

some 키워드에 대해 설명하시오.

• some 키워드는 해당 프로토콜(예를 들어서 Comparable) 을 따르는 타입을 반환할 때 사용한다.
• 지금까지는 프로토콜을 따르는 타입을 반환하려면, Generic 의 타입 제한을 이용해야 했는데,
• 그렇게 하면 함수 바깥에서 해당 타입이 (Comparable 을 따르는) 정확히 어떤 타입인지 (Int, String, ...) 를 명시해주어야 했다.
• 일반화해서 return 하고 외부에서 명시를 안하고 싶어... : some Comparable 를 사용한다.
• 대신 해당 프로토콜을 상속한 프로토콜을 채택하는 객체가 반환될 순 없음. 정확하게 Comparable 만이 반환되어야 함.
• 그러므로 Type Erasing 을 사용한다.