[WWDC 2022] Swift로 프로토콜 인터페이스 설계하기 (Design protocol interface in Swift)

안녕하세요 Foma 입니다!

 

오늘은 저번 글인 Embrace Swift Generics에서 계속 언급하던 Design protocol interface in Swift 세션에 대해서 다뤄보려고 합니다!

 

(저번 글과 많이 연관되어 있으니 안보신 분들은 꼭 여기 에서 보고 와주세요!) 

 

바로 시작할게요~

---

Understand type erasure

 

 

가장 먼저 타입 이레이져에 대해서 알아보도록 하겠습니다. (erasure를 정확히 어떻게 해석해야 할지 모르겠네요.. 삭제? 지움?)

 

가장 먼저 동물 프로토콜을 살펴보도록 하겠습니다.

 

동물 프로토콜은 associatedtype으로 먹이타입과 생산품타입이 있고, 메서드로 먹이타입을 파라미터로 받는 eat, 생산품 타입을 반환하는 produce 메서드가 있습니다.

 

protocol Animal {
    associatedtype FeedType: AnimalFeed
    associatedtype ProductType: Product
    func eat(_ food: FeedType)
    func produce() -> ProductType
}

 

각 구체적인 동물들은 동물 프로토콜을 따르며 구체적인 먹이와 생산품 타입을 명시하죠.

 

struct Cow: Animal {
    func eat(_ food: Hay) {}
    func produce() -> Milk {
        return Milk()
    }
}

struct Chicken: Animal {
    func eat(_ food: Grain) {}
    func produce() -> Egg {
        return Egg()
    }
}

struct Horse: Animal {
    func eat(_ food: Carrot) {}
    func produce() -> Vehicle {
        return Vehicle()
    }
}

 

동물들에게 먹이와 생산품을 길러내는 농장 스트럭트가 있습니다.

 

여기서는 any Animal, any Product와 같이 앞에 any 키워드와 함께 프로토콜이 명시된 배열들이 있습니다.

 

이것들은 "해당 프로토콜을 따르는 어떤 구체적인 타입들이 채워질거야" 라고 명시만 할 뿐 구체적인 타입들이 지워져 있습니다.

 

([any Animal] == [Cow, Horse, Chicken], [any Product] == [Milk, Vehicle, Egg]와 같은 것이죠.)

 

바로 이렇게 타입을 명시하지 않고 지워져 있는 상태를 "타입 이레이져" 라고 부르는 것이죠.

 

struct Farm {
    var animals:[any Animal]
    
    func feed(_ animal: some Animal) {
        let crop = type(of: animal).FeedType.grow()
        let produce = crop.harvest()
        animal.eat(produce)
    }
    
    func feedAll(_ animals: [any Animal]) {
        for animal in animals {
            feed(animal)
        }
    }
    
    func produce() -> [any Product] {
        return animals.map { animal in
            animal.produce()
        }
    }
}

---

Hide implementation details

 

그 다음으로 알아볼 것은 구체적인 타입을 숨기는 것 입니다.

 

이것은 정적 타입 할당을 더 모듈화하고 견고하게 만들 수 있는데요.

 

예를 들면 아래와 같이 동물 프로토콜에 isHungry 프로퍼티가 있다고 가정하겠습니다.

 

protocol Animal {
    var isHungry:Bool { get }
	...
}

 

농장에선 이 배고픈 동물들에게만 먹이를 주려고 하는데요.

 

이것을 위해 isHungry가 true로 된 동물들을 filter 메서드로 걸러 먹이를 주도록 구현하겠습니다.

 

struct Farm {
    var hungryAnimals: [any Animal] {
        animals.filter(\.isHungry)
    }
    
    func feedToHungryAnimals() {
        for animal in hungryAnimals {
			...
        }
    }
    ...

 

위에서 filter 메서드를 사용하여 hungryAnimals를 만드는 과정에서 문제점이 발생하는데요.

 

filter를 사용하여 걸러내는 hungryAnimals는 항상 임시적으로 생겨나고 사라지게 됩니다.

 

이것은 만약 엄청나게 많은 배고픈 동물들이 존재한다면 계속해서 많은 수의 연산해야 하기 때문에 굉장히 비효율적인 코드가 될 것 입니다.

 

이 문제를 개선하기 위해서 아래와 같이 Lazy를 사용할 수 있는데요.

 

lazy에 대해 간단하게 설명드리면 항상 연산을 실행하는 것이 아닌 게으른 상태로 있다가 feedToHungryAnimals가 실행될 때만 연산을 하게 되어 임시적으로 할당되는 것을 피해줍니다.

 

(lazy에 대한 자세한 설명은 여기 갓제드님의 설명을 보면 이해하기 쉬우실 거에요!)

 

struct Farm {
    var hungryAnimals: LazyFilterSequence<[any Animal]> {
        animals.lazy.filter(\.isHungry)
    }
    ...

 

LazyFilterSequence는 Collection 프로토콜을 따르고 있기 때문에

 

 

저번 글에서 배운 some을 활용하면 불투명한 결과 타입을 사용하여 복잡한 구체적인 타입(LazyFilterSequence)을 숨길 수 있습니다.

 

이렇게 코드를 작성하면 사용하는 클라이언트는 Collection 프로토콜을 따르며 그 안에 Animal 프로토콜을 따르는 무엇인가를 얻고 있다는 것만 알 뿐, 구체적인 타입에 대해 알 수가 없습니다.

 

struct Farm {
    var hungryAnimals: some Collection<any Animal> {
        animals.lazy.filter(\.isHungry)
    }
	...

 

 

만약 hungryAnimals를 어떤 경우엔 LazyFilterSequence로 어떤 경우엔 Array로 반환하게 하려면 어떻게 해야 할까요?

 

아래와 같이 작성할 수 있을 것 입니다.

 

    var hungryAnimals: some Collection<any Animal> {
        if isLazy {
           return animals.lazy.filter(\.isHungry)
        }else {
           return animals.filter(\.isHungry)
        }
    }

 

 

하지만 이렇게 작성하면 불투명하게 반환하기 때문에 기본 유형을 추론할 수가 없다는 오류가 발생합니다.

 

 

고로 이 문제를 해결하기 위해선 some 대신 any 키워드를 사용하여 Collection 프로토콜을 따르는 타입을 모두 반환할 수 있도록 만들어 줍니다.

 

이렇게 하면 구체적인 결과 타입을 숨기면서 해당 프로토콜을 따르는 모든 타입을 반환할 수 있는 것이죠!

 

    var hungryAnimals: any Collection<any Animal> {
        if isLazy {
           return animals.lazy.filter(\.isHungry)
        }else {
           return animals.filter(\.isHungry)
        }
    }

---

Identify type relationships

 

이제부터는 여러 추상화된 프로토콜의 관계를 식별하고 보장하는 법에 대해서 다뤄 보겠습니다.

 

동물에게 주는 먹이를 기르기 위해선 아래와 같이 3단계가 필요합니다.

 

1. 동물의 먹이 타입을 기르면 곡물이 되고

2. 곡물을 수확하면 먹이가 되고

3. 동물들에게 그 먹이를 주게 되는 것 입니다.

 

    func feed(_ animal: some Animal) {
        let crop = type(of: animal).FeedType.grow()
        let food = crop.harvest()
        animal.eat(food)
    }

 

그러면 동물의 먹이엔 곡물에 대한 정보를 가지고 있어야 하겠죠?

 

protocol AnimalFeed {
    associatedtype CropType: Crop
    static func grow() -> CropType
}

 

마찬가지로 곡물도 동물의 먹이에 대한 정보를 가지고 있어야 할 것 입니다.

 

protocol Crop {
    associatedtype FeedType: AnimalFeed
    func harvest() -> FeedType
}

 

하지만 위와 같이 구현되어 있다면 Crop의 FeedType을 알아내고 해당 Feed의 CropType을 알아내고 Cropt의 FeedType을 알아내고... 이런 식으로 무한대로 연결이 되는 문제점이 발생합니다.

 

 

그래서 구현부에선 아래와 같은 오류가 발생하게 되는 것이죠.

 

 

또 다른 문제점이 하나 더 존재하는데요.

 

Hay를 길러내면 Alfalfa가 되고 

 

struct Hay: AnimalFeed {
    static func grow() -> Alfalfa {
        return Alfalfa()
    }
}

 

Alfalfa를 수확하면 Hay가 됩니다.

 

struct Alfalfa: Crop {    
    func harvest() -> Hay {
        return Hay()
    }
}

 

하지만 여기서 Alfalfa를 닭이 먹는 Scratch으로 변경이 가능하다는 것 입니다.

 

struct Alfalfa: Crop {    
    func harvest() -> Scratch {
        return Scratch()
    }
}

 

이렇게 되면 Alfalfa의 먹이 타입은 Scratch가 됙고 해당 Crop 타입은 Millet으로 변경되어 버리는 것이죠.

 

그러면 소에게 줄 먹이가 건초에서 밀레로 바뀌어 버리는 것이죠.

 

 

이러한 문제를 해결할 수 있는 방법은 where절을 사용하여 아래와 같이 정확한 타입을 명시해 주는 것 입니다.

 

Self는 자신의 타입을 의미하는 것이므로 Crop의 Feed는 Feed 자신이 되어야 해 그리고 Crop의 Feed는 Crop 자신이 되어야 한다고 구현하는 것이죠.

 

이렇게 구현하면 동물에게 알맞은 곡물과 먹이를 실수없이 줄 수 있게 되는 것이죠!

 

protocol AnimalFeed {
    associatedtype CropType: Crop
        where CropType.FeedType == Self
    static func grow() -> CropType
}

protocol Crop {
    associatedtype FeedType: AnimalFeed
        where FeedType.CropType == Self
    func harvest() -> FeedType
}

 

또한 무한대로 이어졌던 두 프로토콜의 관계는 이렇게 한 쌍으로 간단하게 관계가 변하게 됩니다.

 

---

Source Code

 

GitHub - fomagran/WWDC: Repository to study content published by WWDC

---

Reference

 

Design protocol interfaces in Swift - WWDC22 - Videos - Apple Developer