[WWDC 2022] 제너릭과 프로토콜을 사용해 코드 추상화하기 (feat. some,any) (Embrace Swift generics)

안녕하세요 Foma 입니다!

 

오늘은 WWDC 2022에서 제너릭과 프로토콜을 사용하여 정석(?)으로 코드를 추상화하는 방법에 대해 다룬 Embrace Swift generics 세션에 대해 정리해 보려고 합니다.

 

바로 시작할게요~

 

(제 방식대로 해석하여 정리하는 것이니 틀린 점이나 궁금한 점이 있다면 언제든 댓글로 알려주세요!)

---

Model with concrete types

 

가장 먼저 어떠한 것도 추상화나 제너릭을 사용하지 않고 있는 그대로 즉, 구체적인 타입을 이용해서 농장 시스템을 구현해 보겠습니다.

 

 

농장에 소가 있다고 가정하고, 그 소는 건초(Hay)를 먹는 struct를 생성해 주겠습니다.

 

struct Cow {
    func eat(_ food:Hay) {...}
}

 

이제 소가 먹는 건초는 자라면 알팔파(Alfalfa)라는 식물이 되는 struct를 생성해 줍니다.

 

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

 

위에서 건초가 자라면 알팔파가 된다고 했죠? 고로 알팔파를 수확하면 건초가 되는 알팔파 struct를 생성해 줍니다.

 

struct Alfalfa {
    func havest() -> Hay {}
}

 

마지막으로 위 세 개의 struct를 이용하여 농장 struct를 만들어 줍니다.

 

소에게 먹이를 주기 위해선

 

1. 알팔파(건초의 원재료)를 기른다.

2. 알팔파를 수확하여 건초를 만든다.

3. 건초를 소에게 먹인다.

 

struct Farm {
    func feed(_ animal: Cow) {
        let alfalfa = Hay.grow() // 1
        let hay = alfalfa.harvest() // 2
        animal.eat(hay) // 3
    }
}

 

하지만 만약 여기서 동물이 소 뿐만 아니라 말이나 닭이 추가된다면 코드를 어떻게 작성해야 할까요?

 

struct Horse {
    func eat(_ food: Carrot) {}
}

struct Chicken {
    func eat(_ food: Grain) {}
}

 

추가된 동물의 수만큼 농장엔 먹이 주는 기능이 있는 코드를 추가로 작성하여 구현해야 할 것입니다.

 

struct Farm {
	//소 먹이
    func feed(_ animal: Cow) {
        let alfalfa = Hay.grow()
        let hay = alfalfa.harvest()
        animal.eat(hay)
    }
    
    //말 먹이
    func feed(_ animal: Horse) {
        let root = Carrot.grow()
        let carrot = root.harvest()
        animal.eat(carrot)
    }
    
    //닭 먹이
    func feed(_ animal: Chicken) {
        let wheat = Grain.grow()
        let grain = wheat.harvest()
        animal.eat(grain)
    }
}


farm.feed(Cow())
farm.feed(Horse())
farm.feed(Chicken())

 

 

하지만 이런 식으로 구현하면 동물을 추가하면 추가할수록 거의 비슷한 코드를 반복적으로 작성해야 하는 문제가 생깁니다.

---

Identify common capabilities

 

위 문제를 개선하기 위해서 각 struct에서 공통적으로 가지고 있는 특징을 나열합니다.

 

동물들이 공통적으로 가지고 있는 특징은 특정 먹이를 먹는 것이죠?

 

그러므로 동물이라는 클래스를 만들어 eat 메서드를 구현하여 추상화하여 동물마다 다르게 적용하면 될 것 입니다.

 

class Animal {
    func eat(_ food:???) { fatalError("Subclass must implement 'eat'")}
}

---

Polymorphism

 

이렇게 한 코드로 여러 행동을 수행하는 것을 "Polymorphism" 이라고 부르는데요. 

 

폴리 몰피즘은 세 가지 형태가 존재하는데요.

 

1. 오버로드를 통한 ad-hoc polymorphism

2. 서브타입을 이용한 subtype polymorphism

3. 제너릭을 이용한 parametric polymorphism

 

 

가장 먼저 오버로드를 이용해서 코드를 개선해 보겠습니다.

 

위에서 만들어 준 동물 struct들을 클래스로 바꿔주고 Animal 클래스를 상속 받아 메서드를 override 해줍니다.

 

class Cow: Animal {
    override func eat(_ food:Hay) {}
}

---

Using Any

 

하지만 위에서 만들어준 Animal 클래스의 food 타입을 구체적으로 정할 수가 없습니다.

 

고로 그나마 괜찮은 방법은 food를 Any 타입으로 만들어 주는 것 입니다.

 

class Animal {
    func eat(_ food:Any) { fatalError("Subclass must implement 'eat'")}
}

class Chicken: Animal {
    override func eat(_ food: Any) {
        guard let food = food as? Grain else { fatalError("Chicken cannot eat \(food)")}
    }
}

 

하지만 이 또한 타입이 맞지 않는 음식이 들어왔을 경우 오로지 런타임에만 버그가 발견될 수 있습니다.

---

Using type parameter

 

위 코드를 개선하기 위해선 Any를 사용하지 않고 슈퍼 클래스인 Animal에서 타입 파라미터를 받아 먹이의 타입을 결정하는 방법이 있습니다.

 

아래와 같이 Animal에 Food를 타입을 파라미터로 받게 하고, 상속받은 하위 클래스엔 특정 먹이 타입을 파라미터로 입력해 구체적인 타입을 갖도록 하는 것이죠.

 

class Animal<Food> {
    func eat(_ food:Food) { fatalError("Subclass must implement 'eat'")}
}

class Chicken: Animal<Grain> {
    override func eat(_ food: Grain) {}
}

 

이렇게 타입 파라미터를 이용해 작성하는 것은 먹이를 먹는 행동이 아닌 다른 기능을 구현할 때는 해당 타입 파라미터에 추가로 작성해 줘야한다는 문제점이 발생합니다.

 

아래와 같이 동물이 먹는 음식 뿐만 아니라, 사는 곳, 어떤 물품을 만들어 내는지 등을 추가적으로 구현하려면

 

class Animal<Food, Habitat, Commodity> {
    func eat(_ food:Food) { fatalError("Subclass must implement 'eat'")}
}

 

아래와 같이 동물마다 필요한 타입이 <> 안에 늘어나는 것을 볼 수 있습니다.

 

class Cow: Animal<Hay, Barn, Milk> {
    override func eat(_ food:Hay) {}
}

---

Build an interface

 

그렇다면 위 문제들을 어떻게 해결할 수 있을까요?

 

바로 수행하는 작업에 대한 아이디어를 구현 세부 정보와 분리하는 것, 즉 Protocol을 사용하는 것 입니다.

 

아래와 같이 Feed라는 임의의 타입을 정해놓고 eat 메서드엔 임의의 타입을 지정해 줍니다.

 

이렇게 하면 어떤 구체적인 타입이든 파라미터로 받을 수 있는 것이죠.

 

protocol Animal {
    associatedtype Feed: FeedType
    func eat(_ food: Feed)
}

 

그리고 기존 Class로 되어 있는 동물 클래스들을 다시 struct로 변경하고 메서드에 override를 제거해 줍니다.

(프로토콜은 enum,struct,actor 등에만 사용할 수 있기 때문입니다.)

 

struct Horse: Animal {
    func eat(_ food: Carrot) {}
}

---

Write generic code

 

그렇다면 이제부터 본격적으로 제너릭한 코드를 작성해 보겠습니다.

 

가장 문제가 됐던 Farm의 feed 코드를 어떠한 먹이가 와도 한 코드로 대체할 수 있게끔 만들어야 하는데요.

 

아래와 같이 animal에 Animal 프토토콜을 파라미터로 받으면 될까요?

 

struct Farm {
    func feed(_ animal: Animal){...}
}

 

프로토콜과 같은 구체적인 타입이 아닌 경우 불투명한 타입(Opaque Type) 이라고 하는데요.

 

불투명한 타입은 파라미터로 받거나, 결과값으로 반환하는 것이 불가능합니다.

 

 

그렇다면 어떻게 작성해야 할까요?

 

where

 

우선 첫 번째로는 where 절을 이용하는 방법이 있습니다.

 

아래와 같이 A라는 임의 타입 이름을 정해주고 A는 Animal이야 라는 것을 지정해 줘 파라미터로 Animal 프로토콜을 따르는 구체적인 타입을 받을 수 있는 것이죠.

 

struct Farm {
    func feed<A>(_ animal: A) where A:Animal{}
}

 

하지만 where절은 메서드가 실제보다 더 복잡해 보이는 단점이 존재했습니다.

 

some

 

이러한 where절의 단점을 보완하여 쉽게 표현할 수 있는 방법이 바로 "some" 입니다.

 

바로 아래와 같이 작성하면 Animal 프로토콜을 준수하는 특정 타입을 파라미터로 받을 수 있게 구현할 수 있습니다.

 

struct Farm {
    func feed(_ animal: some Animal) {}
}

 

이것은 SwiftUI를 경험해 보신 분들은 아래처럼 some View로 표시되는 경우를 많이 보셨을 거에요.

 

이 의미는 바로 View라는 프로토콜을 따르는 특정타입을 의미하는 것이죠.

 

 

some을 이용해서 feed 메서드를 작성하면 아래와 같이 어떤 동물이 추가되든 하나의 메서드로 대처할 수 있습니다.

 

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

 

위 메서드를 좀 더 구체적으로 설명하면 먼저 crop은 animal의 특정 타입을 알아낸 뒤 해당 Feed에 grow 메서드를 호출해 Crop 인스턴스를 할당합니다.

 

그 다음 해당 crop을 이용하여 harvest 메서드를 실행해 먹이를 할당한 뒤 animal의 eat메서드의 파라미터에 할당해 먹이를 주게 되는 것입니다.

 

(Feed는 직접적인 먹이 즉 Hay, Grain, Carrot을 의미하며 Crop은 그것의 원재료가 되는 Alfalfa, Wheat, Root가 됩니다. 자세한 건 아래 깃헙 소스코드를 참고해 주세요!)

 

아래 프로토콜에 대해 자세한 설명은 여기 에서 확인할 수 있습니다.

 

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
}

 

any

 

만약 여러 동물에게 먹이를 주려면 어떤 식으로 작성해야 할까요?

 

가장 먼저 떠올리는 것은 아래와 같을 것 입니다.

 

    func feedAll(_ animals: [Animal]) {
        for animal in animals {
            feed(animal)
        }
    }

 

하지만 위에서 프로토콜은 타입으로 직접 할당하지 못했죠?

 

어떤 동물이 들어올지 모르기 때문에 아래와 같이 some Animal로 작성해야 할까요?

 

some은 기본 유형이 고정되고 배열의 모든 요소가 동일한 유형을 가져야 하기 때문에 다른 동물을 한꺼번에 가질 순 없게 됩니다.

 

    func feedAll(_ animals: [some Animal]) {
        for animal in animals {
            feed(animal)
        }
    }​

 

이러한 것을 해결할 수 있는 방법이 바로 "any"를 사용하는 것 입니다.

 

 

프로토콜 앞에 any 키워드를 붙여주면 동적으로 타입을 저장하고 런타임 시에 확인하기 때문에 모든 유형을 배열에 담을 수 있습니다.

 

    func feedAll(_ animals: [any Animal]) {
        for animal in animals {
            feed(animal)
        }
    }

 

사용할 때도 아래와 같이 any와 함께 사용하면 프로토콜의 유형 인스턴스를 배열에 담을 수 있습니다.

 

        let farm = Farm()
        let animals:[any Animal] = [Horse(),Chicken(),Cow()]
        farm.feedAll(animals)

---

Source Code

 

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

---

Reference

 

Embrace Swift generics - WWDC22 - Videos - Apple Developer