[Swift🦩] #23 Generic ⭐️⭐️

• 모든 타입에서 동작하는 유연한 함수, 타입을 작성할 수 있다.
• 중복되는 코드를 피하기 위해서 작성
• 타입을 추상화 한다고 보면됨.

1. 제너릭이 해결하는 문제

• 아래의 세 함수는 같은 역할을 하지만, input 타입 때문에 다 따로 씀.
• 여기에서 중요한 것은 a, b 인자의 타입이 모두 같다는 것.

func swapTwoInts(_ a: inout Int, _ b: inout Int) {
    let temporaryA = a
    a = b
    b = temporaryA
}

func swapTwoStrings(_ a: inout String, _ b: inout String) {
    let temporaryA = a
    a = b
    b = temporaryA
}

func swapTwoDoubles(_ a: inout Double, _ b: inout Double) {
    let temporaryA = a
    a = b
    b = temporaryA
}

2. Generic Function

• T 라는 임의의 타입 이름을 사용해서 나타낸다.
• a, b 가 무슨 타입이든 서로 같은 타입이기만 하면 되는 것임.
• 임의의 타입 이름이라고 <T> 로 전달하는 것임.

func swapTwoValues<T>(_ a: inout T, _ b: inout T) {
    let temporaryA = a
    a = b
    b = temporaryA
}

+) 사실 swap 의 경우 이미 애플에서 제공하니까 구현해서 쓰지 말자.

3. Type Parameters

• 위의 T 가 타입 파라미터의 예시.
• 타입 파라미터를 지정해두면, 함수의 파라미터, 반환 타입, 함수 바디 내에서 타입 주석으로 사용할 수 있다.

이름

• 보통 Dictionary<Key, Value> , Array<Element> 처럼 기본적인 이름이 정해져 있는 경우가 있음.
• 직접 사용할 때는 T U V 같은 단일 문자를 사용해서 지정해주는 것이 일반적.

4. Generic Types

• Generic 을 이용해서 함수만 정의 가능한 것이 아님.
• Type 도 정의할 수 있음.
• Array Dictionary 처럼 모든 타입에서 동작할 수 있는 사용자 정의 클래스, 구조체, 열거형

예시) 스택 구현

// 만약 Int 라면 이런식으로 코드를 짤거다.
struct IntStack {
    var items: [Int] = []
    mutating func push(_ item: Int) {
        items.append(item)
    }
    mutating func pop() -> Int {
        return items.removeLast()
    }
}

// 스택 안에 있는 것이 모두 같은 타입이기만 하면 되니까
// 구조체이름<타입>
struct Stack<Element> {
    var items: [Element] = []
    mutating func push(_ item: Element) {
        items.append(item)
    }
    mutating func pop() -> Element {
        return items.removeLast()
    }
}

• 실제로 사용할 때는 어떤 타입으로 만들건지 명시해주면 된다.

var stackOfStrings = Stack<String>()
stackOfStrings.push("uno")
stackOfStrings.push("dos")
stackOfStrings.push("tres")
stackOfStrings.push("cuatro")
// the stack now contains 4 strings

5. Extenseion in Generic

• extension 으로 Generic Type 을 확장할 때는, \ 를 쓸 필요 없다.

extension Stack {
    var topItem: Element? {
        return items.isEmpty ? nil : items[items.count - 1]
    }
}

6. Type Constraints

• Generic 을 사용하면 모든 타입에 사용이 가능해지는데,
• 항상 모든 타입에 가능하면 안되는 순간이 있음.
• ex) Dictionery<Key, Value> 의 Key: Hashable

타입 제약 구문

• <T: SomeClass, U: SomeProtocol> 처럼 임의의 타입이 따라야 하는 것을 뒤에 써주기.

func someFunction<T: SomeClass, U: SomeProtocol>(someT: T, someU: U) {
    // function body goes here
}

타입 제약 동작

// String 배열에서 선형탐색.
func findIndex(ofString valueToFind: String, in array: [String]) -> Int? {
    for (index, value) in array.enumerated() {
        if value == valueToFind {
            return index
        }
    }
    return nil
}

• String 만이 아니라 그냥 전체 배열에서 가능했으면 좋겠음.
• == 이 어떤 타입에서나 사용 가능한 것이 아니므로 T 는 Equatable

func findIndex<T: Equatable>(of valueToFind: T, in array:[T]) -> Int? {
    for (index, value) in array.enumerated() {
        if value == valueToFind {
            return index
        }
    }
    return nil
}

7. Associated Values ⭐️⭐️

• 프로토콜을 정의할 때, 연관된 타입을 선언할 수 있다.
• 프로토콜의 부분으로 사용되는 타입에 임의의 이름을 넣는다.
• 실제 프로토콜이 채택되면 해당 타입이 무엇인지 지정됨.

associatedtype

// Item 이라는 임의의 타입.
// Item 이 무엇일진 모르지만 해당 타입을 이용해서 프로토콜을 정의할 수 있음.
protocol Container {
    associatedtype Item
    mutating func append(_ item: Item)
    var count: Int { get }
    subscript(i: Int) -> Item { get }
}


// Container Type 을 따르는데, Item 이 Int 라고 정의해줄 수 있따.
struct IntStack: Container {
    // original IntStack implementation
    var items: [Int] = []
    mutating func push(_ item: Int) {
        items.append(item)
    }
    mutating func pop() -> Int {
        return items.removeLast()
    }
    // conformance to the Container protocol
    typealias Item = Int
    mutating func append(_ item: Int) {
        self.push(item)
    }
    var count: Int {
        return items.count
    }
    subscript(i: Int) -> Int {
        return items[i]
    }
}

// 혹은 정해져있지 않아도, Generic 하게 사용 가능.
struct Stack<Element>: Container {
    // original Stack<Element> implementation
    var items: [Element] = []
    mutating func push(_ item: Element) {
        items.append(item)
    }
    mutating func pop() -> Element {
        return items.removeLast()
    }
    // conformance to the Container protocol
    mutating func append(_ item: Element) {
        self.push(item)
    }
    var count: Int {
        return items.count
    }
    subscript(i: Int) -> Element {
        return items[i]
    }
}

extension 으로 associatedtype 지정

• associatetype 을 정의할 때, 타입 제약을 추가해서
• 특정 구조체, 클래스, 프로토콜을 준수하게 할 수 있다.

protocol Container {
    associatedtype Item: Equatable
    mutating func append(_ item: Item)
    var count: Int { get }
    subscript(i: Int) -> Item { get }
}

• associatedtype 제약조건 하에서 프로토콜 사용하기.

protocol SuffixableContainer: Container {
    associatedtype Suffix: SuffixableContainer where Suffix.Item == Item
    func suffix(_ size: Int) -> Suffix
}


extension Stack: SuffixableContainer {
    func suffix(_ size: Int) -> Stack {
        var result = Stack() // Stack 도 Generic Type 이니까, Stack<Int>() 로 제한할 수도 있음.
        for index in (count-size)..<count {
            result.append(self[index])
        }
        return result
    }
    // Inferred that Suffix is Stack.
}
var stackOfInts = Stack<Int>()
stackOfInts.append(10)
stackOfInts.append(20)
stackOfInts.append(30)
let suffix = stackOfInts.suffix(2)
// suffix contains 20 and 30

8. Generic Where 절

• 타입 제약 <T: Equatable> 을 이용해서 Generic function, subscript, Type, parameter 의 타입에 대한 요구사항을 정의할 수 있다.
• associatetype 도 역시 요구사항 정의가 가능하다. where 절과 함께라면~
• 특정 프로토콜을 준수하거나, 특정 타입 파라미터와 연관된 타입이 동일해야함을 나타낼 수 있다.

// 컨테이너 2개가 같은 순서로 아이템을 가지고 있는지 확인하는 함수.
// C1, C2 가 컨테이너이나 같은 타입은 아닐수도 있는 상황.
func allItemsMatch<C1: Container, C2: Container>
    (_ someContainer: C1, _ anotherContainer: C2) -> Bool
    where C1.Item == C2.Item, C1.Item: Equatable {

        // Check that both containers contain the same number of items.
        if someContainer.count != anotherContainer.count {
            return false
        }

        // Check each pair of items to see if they're equivalent.
        for i in 0..<someContainer.count {
            if someContainer[i] != anotherContainer[i] {
                return false
            }
        }

        // All items match, so return true.
        return true
}

9. extension with Generic Where

• 확장에서 Generic Where 절을 사용할 수 있다.

// Stack 의 Element 가 Equatable 할 때만 이 메서드 추가.
extension Stack where Element: Equatable {
    func isTop(_ item: Element) -> Bool {
        guard let topItem = items.last else {
            return false
        }
        return topItem == item
    }
}

// Item 이 Double 일때만 메서드 추가.
extension Container where Item == Double {
    func average() -> Double {
        var sum = 0.0
        for index in 0..<count {
            sum += self[index]
        }
        return sum / Double(count)
    }
}
print([1260.0, 1200.0, 98.6, 37.0].average()) // Prints "648.9"

10. 상황별 Where 절

• 선언에 where 절을 쓸 수 있다.

extension Container {
    // Int 일 때 사용 가능한 메서드.
    func average() -> Double where Item == Int {
        var sum = 0.0
        for index in 0..<count {
            sum += Double(self[index])
        }
        return sum / Double(count)
    }
    // Equatable 일 때 사용 가능한 메서드
    func endsWith(_ item: Item) -> Bool where Item: Equatable {
        return count >= 1 && self[count-1] == item
    }
}
let numbers = [1260, 1200, 98, 37]
print(numbers.average())  // Prints "648.75"
print(numbers.endsWith(37))  // Prints "true"

• contextual Where 를 사용하지 않고 싶다면 위에서 작성한 것처럼 각각 extension 으로 where 절 추가.
• 결국 함수에 직접 where 절 쓰던지..
• extension 으로 쓰던지 모두 가능하다.

11. Associated Types with a Generic Where Clause

• associatedtype 에 where 절을 포함시킬 수 있다.

protocol Container {
    associatedtype Item
    mutating func append(_ item: Item)
    var count: Int { get }
    subscript(i: Int) -> Item { get }

    // Iterator.Element 가 Item 일 때 사용 가능한 타입 Iterator
    associatedtype Iterator: IteratorProtocol where Iterator.Element == Item
    func makeIterator() -> Iterator
}

• 다른 프로토콜을 상속할 때도 where 절로 조건 추가 가능.

protocol ComparableContainer: Container where Item: Comparable { }

12. Generic Subscripts

• 서브스크립트를 Generic 으로 작성할 수 있다.
• 함수처럼 Subscript 문법 다음에 where 절 사용.

extension Container {
    subscript<Indices: Sequence>(indices: Indices) -> [Item]
        // 반복하는 값이 Int 일때만 가능하게.
        where Indices.Iterator.Element == Int {
            var result: [Item] = []
            for index in indices {
                result.append(self[index])
            }
            return result
    }
}

질문

Generic에 대해 설명하시오.

• Swift 의 Type 시스템에서 제공하는 Type 을 좀 더 유연하게 사용할 수 있게 해주는 문법이다.
• Int, Double 같은 제공하는 타입이나 직접 선언한 struct, class 같은 타입을 인자나 반환값 키워드에 직접 써야하는데,
• 같은 역할을 하는 함수인데 인자의 타입만 달라서 추상화를 할 수 없는 경우에
• 그 대신 임의의 타입 이름을 하나 선언해서 두 타입이같기만 하면된다던지, 타입이 특정 프로토콜을 준수하거나 특정 클래스라면 범용적으로 함수를 쓸 수 있게 할 수 있다.<T>

• 클래스 구조체 열거형을 선언할 때도 사용할 수 있다.
• where 절을 이용해서 해당 Generic function, Generic Type 에 대한 조건을 줄 수도 있다.