Swift 공식 문서 정리 - 제너릭 (Generics)

안녕하세요. 오늘은 Swift '제너릭(Generics)'에 대해 알아보겠습니다.

📌 제너릭이란? 그리고 왜 필요할까요?

제너릭 코드는 특정 타입에 구애받지 않고, 정의한 요구사항을 충족하는 모든 타입에 대해 동작할 수 있는 유연한 코드를 작성할 수 있게 해줍니다. Swift의 Array, Dictionary와 같은 표준 라이브러리의 대부분은 제너릭으로 구현되어 있습니다.

제너릭이 해결하는 문제

아래 예제를 통해 제너릭의 필요성을 살펴보겠습니다:

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
}

세 함수의 본문이 완전히 동일하다는 것을 알 수 있습니다. 이런 코드 중복은 제너릭을 통해 해결할 수 있습니다.

📌 제너릭 함수 작성하기

제너릭 함수는 모든 타입에 대해 동작할 수 있습니다. 위의 함수들을 제너릭으로 다시 작성해 봅시다:

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

이 함수는 어떤 타입이든 사용할 수 있으며, 다음과 같이 호출할 수 있습니다:

var someInt = 3
var anotherInt = 107
swapTwoValues(&someInt, &anotherInt)
// someInt는 이제 107, anotherInt는 이제 3

var someString = "hello"
var anotherString = "world"
swapTwoValues(&someString, &anotherString)
// someString은 이제 "world", anotherString은 이제 "hello"

참고: 실제로 Swift 표준 라이브러리에는 swap(_:_:) 함수가 이미 구현되어 있어, 직접 구현할 필요 없이 사용할 수 있습니다.

타입 파라미터 (Type Parameters)

<T>에서 T는 타입 파라미터입니다. 함수가 호출될 때마다 실제 타입으로 대체됩니다. 타입 파라미터의 이름은 대개 대문자로 시작하며, T, U, V 같은 단일 문자나 Element, Key, Value와 같은 설명적인 이름을 사용합니다.

여러 타입 파라미터를 사용하고 싶다면 <T, U, V>와 같이 콤마로 구분하여 나열할 수 있습니다.

📌 제너릭 타입 정의하기

함수뿐만 아니라 클래스, 구조체, 열거형도 제너릭으로 정의할 수 있습니다. 다음은 제너릭 스택(Stack) 구현의 예입니다:

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")
// 스택에는 이제 4개의 문자열이 있음

let fromTheTop = stackOfStrings.pop()
// fromTheTop은 "cuatro"와 같음

제너릭 타입 확장하기

제너릭 타입을 확장할 때는 타입 파라미터 목록을 다시 작성하지 않습니다:

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

이 확장을 통해 모든 Stack 인스턴스에 topItem 속성이 추가됩니다:

if let topItem = stackOfStrings.topItem {
    print("스택의 최상위 항목은 \(topItem)입니다.")
}
// "스택의 최상위 항목은 tres입니다." 출력

📌 타입 제약 (Type Constraints)

때로는 제너릭 함수나 타입이 특정 프로토콜을 준수하거나 특정 클래스를 상속하는 타입에만 작동하도록 제한해야 할 필요가 있습니다. 예를 들어, Swift의 Dictionary는 키 타입이 Hashable 프로토콜을 준수해야 합니다.

다음은 타입 제약을 사용한 예제입니다:

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

이 함수는 T가 Equatable 프로토콜을 준수하는 타입이어야만 사용할 수 있습니다. 덕분에 == 연산자를 사용할 수 있게 됩니다:

let doubleIndex = findIndex(of: 9.3, in: [3.14159, 0.1, 0.25])
// doubleIndex는 nil(배열에 9.3이 없기 때문)

let stringIndex = findIndex(of: "Andrea", in: ["Mike", "Malcolm", "Andrea"])
// stringIndex는 2의 값을 가진 Int?

📌 연관된 타입 (Associated Types)

프로토콜을 정의할 때 하나 이상의 연관된 타입을 선언하는 것이 유용할 수 있습니다. 연관된 타입은 프로토콜의 일부로 사용되는 타입에 대한 플레이스홀더 이름을 제공합니다.

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

이 프로토콜은 컨테이너가 어떤 타입의 항목을 저장할지 지정하지 않습니다. 대신, 프로토콜을 채택하는 타입이 Item의 실제 타입을 지정합니다:

struct IntStack: Container {
    // 원래 IntStack 구현
    var items: [Int] = []
    mutating func push(_ item: Int) {
        items.append(item)
    }
    mutating func pop() -> Int {
        return items.removeLast()
    }
    
    // Container 프로토콜 준수
    typealias Item = Int
    mutating func append(_ item: Int) {
        self.push(item)
    }
    var count: Int {
        return items.count
    }
    subscript(i: Int) -> Int {
        return items[i]
    }
}

제너릭 타입에서는 연관 타입이 자동으로 추론됩니다:

struct Stack<Element>: Container {
    // 원래 Stack<Element> 구현
    var items: [Element] = []
    mutating func push(_ item: Element) {
        items.append(item)
    }
    mutating func pop() -> Element {
        return items.removeLast()
    }
    
    // Container 프로토콜 준수
    mutating func append(_ item: Element) {
        self.push(item)
    }
    var count: Int {
        return items.count
    }
    subscript(i: Int) -> Element {
        return items[i]
    }
}

연관된 타입에 제약 추가하기

연관된 타입에도 타입 제약을 추가할 수 있습니다:

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

📌 제너릭 Where 절 (Generic Where Clauses)

타입 제약 외에도, 제너릭 함수나 타입의 요구사항을 더 세부적으로 정의하기 위해 제너릭 where 절을 사용할 수 있습니다:

func allItemsMatch<C1: Container, C2: Container>
    (_ someContainer: C1, _ anotherContainer: C2) -> Bool
    where C1.Item == C2.Item, C1.Item: Equatable {
        
        // 두 컨테이너의 항목 수가 같은지 확인
        if someContainer.count != anotherContainer.count {
            return false
        }
        
        // 각 항목이 동일한지 확인
        for i in 0..<someContainer.count {
            if someContainer[i] != anotherContainer[i] {
                return false
            }
        }
        
        // 모든 항목이 일치하면 true 반환
        return true
}

이 함수는 두 컨테이너가 같은 항목 타입을 가지고 있으며, 그 항목 타입이 Equatable을 준수해야 한다는 제약을 설정합니다:

var stackOfStrings = Stack<String>()
stackOfStrings.push("uno")
stackOfStrings.push("dos")
stackOfStrings.push("tres")

var arrayOfStrings = ["uno", "dos", "tres"]

if allItemsMatch(stackOfStrings, arrayOfStrings) {
    print("모든 항목이 일치합니다.")
} else {
    print("일치하지 않는 항목이 있습니다.")
}
// "모든 항목이 일치합니다." 출력

Where 절이 있는 확장

where 절을 사용해 제너릭 타입을 확장할 수도 있습니다:

extension Stack where Element: Equatable {
    func isTop(_ item: Element) -> Bool {
        guard let topItem = items.last else {
            return false
        }
        return topItem == item
    }
}

이 확장은 Stack의 요소가 Equatable을 준수할 때만 적용됩니다:

if stackOfStrings.isTop("tres") {
    print("최상위 요소는 tres입니다.")
} else {
    print("최상위 요소는 다른 것입니다.")
}
// "최상위 요소는 tres입니다." 출력

프로토콜 확장에도 where 절을 사용할 수 있습니다:

extension Container where Item: Equatable {
    func startsWith(_ item: Item) -> Bool {
        return count >= 1 && self[0] == item
    }
}

또한, 특정 타입에만 적용되는 확장도 가능합니다:

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())
// 648.9 출력

상황별 Where 절

제너릭 타입의 컨텍스트에서 이미 작업 중인 경우, 개별 메서드나 속성에 where 절을 적용할 수도 있습니다:

extension Container {
    func average() -> Double where Item == Int {
        var sum = 0.0
        for index in 0..<count {
            sum += Double(self[index])
        }
        return sum / Double(count)
    }
    
    func endsWith(_ item: Item) -> Bool where Item: Equatable {
        return count >= 1 && self[count-1] == item
    }
}

📌 제너릭 서브스크립트

서브스크립트도 제너릭으로 정의할 수 있으며, 제너릭 where 절을 포함할 수 있습니다:

extension Container {
    subscript<Indices: Sequence>(indices: Indices) -> [Item]
        where Indices.Iterator.Element == Int {
            var result: [Item] = []
            for index in indices {
                result.append(self[index])
            }
            return result
    }
}

이 서브스크립트는 정수 시퀀스를 받아 해당 인덱스에 있는 항목들의 배열을 반환합니다.

📌 정리

Swift의 제너릭은 타입 안전성을 유지하면서 코드 재사용성을 높이는 강력한 기능입니다. 제너릭을 통해:

1. 코드 중복을 줄일 수 있습니다 - 다양한 타입에 대해 동일한 기능을 제공하는 코드를 한 번만 작성하면 됩니다.
2. 타입 안전성을 보장합니다 - 컴파일 시점에 타입 검사가 이루어져 런타임 오류를 줄일 수 있습니다.
3. 유연한 API를 설계할 수 있습니다 - 사용자가 다양한 타입과 함께 API를 사용할 수 있도록 합니다.
4. 성능 저하 없이 추상화를 제공합니다 - 제너릭은 컴파일 시간에 해결되므로 런타임 성능에 영향을 주지 않습니다.