출처 : https://docs.swift.org/swift-book/LanguageGuide/Generics.html
Remind
- 제네릭 타입은 static stored 프로퍼티를 정의할 수 없다
🐶 서론
제네릭은 어떤 타입과도 작업할 수 있는 유연하고 재사용가능한 함수와 타입을 쓸 수 있게 해줍니다 ('어떤 타입'의 범위를 우리가 정의할 수 있습니다)
제네릭 코드를 통해, 반복코드를 피하고 명확하고 추상화된 방식으로 의도를 표현할 수 있습니다
제네릭은 Swift의 가장 강력한 기능 중 하나로, 많은 Swift 기본 라이브러리가 제네릭으로 만들어져 있습니다
예로, Array와 Dictionary 타입은 모두 제네릭 Collection입니다
Array가 Int/String 등 어떤 타입이든 보관할 수 있도록 만들 수 있습니다
유사하게 Dictionary가 key와 value를 어떤 타입이로든 만들 수 있습니다
🐱 Generic으로 해결가능한 문제
먼저 두 개의 Int를 swap하는 함수를 non-Generic으로 구현한 예시입니다
func swapTwoInts(_ a: inout Int, _ b: inout Int) {
let temporaryA = a
a = b
b = temporaryA
}이 함수는 유용하지만 Int 타입만 사용가능하다는 문제가 있습니다
만약 Double 타입 swap이 필요하다면 별도의 함수를 만들어주어야 합니다
func swapTwoDoubles(_ a: inout Double, _ b: inout Double) {
let temporaryA = a
a = b
b = temporaryA
}우리는 두 함수의 body가 동일함을 알아챌 수 있습니다
유일한 차이점은 parameter와 retun 타입만 다릅니다
따라서, Any 타입이든 swap해주는 하나의 함수를 정의하는 것이 더 유용하고 훨씬 유연합니다
Generic은 그런 함수를 정의할 수 있게 해줍니다
🐭 Generic 함수
Generic 함수는 어떤 타입과도 작업할 수 있습니다
예시를 봅시다
뭔가 첫 줄의 생김새가 다릅니다
func swapTwoValues<T>(_ a: inout T, _ b: inout T) {
let temporaryA = a
a = b
b = temporaryA
}기존의 non-Generic 함수와 비교해봅시다
func swapTwoInts(_ a: inout Int, _ b: inout Int)
func swapTwoValues<T>(_ a: inout T, _ b: inout T)Generic 함수는 Double/Int같은 실제 타입대신 placeholder 타입을 사용합니다
placeholder는 위 예제처럼 T가 아니어도 되고, T가 어떤 타입인지에 대해선 아무말도 하지 않습니다
다만, 두 parameter가 동일한 타입일 것을 말하고 있습니다
T 대신 사용될 실제 타입은 Generic함수가 호출될 때 결정됩니다
swapTwoValues는 parameter로 Any 타입이든 올 수 있다는 점과, 두 parameter의 타입이 같아야 한다는 점을 제외하면 swapTwoInts와 같은 방식으로 호출됩니다
swapTowValues가 호출될 때마다 T로 사용될 타입은 추론과정을 거칩니다
(argument로 전달되는 값의 타입을 기반으로)
🐭 Type Parameter
위 예제에서 사용하던 placeholder, T에 대해 알아봅시다
'placeholder type T'는 type parameter의 한 예시입니다
type paramter는 placeholder type을 명시하고 이름을 부여합니다
그리고 함수 이름 바로 뒤에 '<>'과 함께 붙습니다
한번 type paramter를 명시하면, Generic 함수에서 다뤄질 paramter/return/기타(body에서다룰) 타입을 정의하기 위해 이를 사용할 수 있습니다
함수가 호출될 때, 각 type parameter는 실제 타입으로 대체됩니다
type paramter는 여러 개 제공될 수 있습니다
--
🐹 Type Parameter Naming
대부분의 경우, type parameter의 이름은 Generic과 type paramter 간 관계에 대한 '설명'이 포함되도록 지어집니다
(ex. Dictionary의 <Key, Value> 혹은 Array의 <Element>)
하지만, 둘 간에 유의미한 관계가 없다면 전통적으로 U, T, V를 사용합니다
type paramter의 이름은 upper camel case를 사용합니다
--
🐰 Generic 타입
Generic 함수에 더해 Generic 타입도 정의할 수 있습니다
예시로는 Array와 Dictionary가 있으며
어떤 타입과도 작업할 수 있는 custom class/struct/enum입니다
이번 section에서는 Stack을 예시로 Generic Collection을 정의하는 방법을 다룹니다
...Stack과 Array의 차이..중략...
non-Generic 버전
Int외에 다른 타입을 element로 사용하려면 별도 정의가 필요하다
struct IntStack {
var items: [Int] = []
mutating func push(_ item: Int) {
items.append(item)
}
mutating func pop() -> Int {
return items.removeLast()
}
}Generic 버전
struct Stack<Element> {
var items: [Element] = []
mutating func push(_ item: Element) {
items.append(item)
}
mutating func pop() -> Element {
return items.removeLast()
}
}✔️ Generic 타입은 인스턴스 생성구문이 다르다
Generic타입의 인스턴스를 생성할 때는, type paramter를 대신할 '실제 타입'을 명시해주어야 합니다
var stackOfStrings = Stack<String>()
stackOfStrings.push("uno")
stackOfStrings.push("dos")
stackOfStrings.push("tres")
stackOfStrings.push("cuatro")
// the stack now contains 4 strings🦊 Generic 타입 Extension
Generic 타입을 extension할 때는
original 정의부에 명시된 type paramter를 그대로 가져오므로
type paramter를 별도로 적어주지 않습니다
extension Stack {
var topItem: Element? {
return items.isEmpty ? nil : items[items.count - 1]
}
}✔️ 조건부 extension
extension 할 때도 다뤘던 내용인데
extension을 선택적으로 추가할 수 있습니다
아래는 Element가 Equatable 프로토콜을 준수하는 Stack인 경우에만 extension합니다
extension Stack where Element: Equatable {
func isTop(_ item: Element) -> Bool {
guard let topItem = items.last else {
return false
}
return topItem == item
}
}🐻 Type 제약걸기
위에서 다뤘던 예제의 swapTwoValues(_:_:) 함수와 Stack은 Any 타입과도 작업할 수 있습니다
하지만, 특정 조건을 만족하는 타입들만 사용하고 싶을 수도 있습니다
'Type 제약'은 type paramter가 특정 class를 상속받거나, 특정 프로토콜을 준수해야 함을 명시할 수 있습니다
예로, Swift의 Dictionary는 Key가 hashable해야 함을 명시하고 있습니다
즉, Key 간에 유일하게 구분할 방법을 제공해야한다는 뜻입니다
Dictionary는 어떤 key에 대해 이미 value를 가지고 있는 key인지 확인할 수 있도록 key가 hashable할 필요가 있습니다
✔️ Syntax
제약은 하나만 걸 수 있습니다
하나의 class 혹은 하나의 protocol을 걸 수 있습니다
다만, protocol은 composition을 이용하면 여러 개 걸 수도 있습니다
func someFunction<T: SomeClass, U: SomeProtocolA & SomeProtocolB>(someT: T, someU: U) {
// function body goes here
}✔️ 예제
1. non-Generic으로 우선
String말고도 광범위하게 사용될 수 있으므로 Generic으로 만들자
func findIndex(ofString valueToFind: String, in array: [String]) -> Int? {
for (index, value) in array.enumerated() {
if value == valueToFind {
return index
}
}
return nil
}2. Generic으로 만들긴 했는데..
컴파일이 안된다
value == valueToFind라는 '비교구문'이 있는데
이 비교 연산자는 아무 타입이나 갖고 있는 메서드가 아니므로
컴파일러 입장에서는 Swift의 모든 타입에 대해 허용할 수 없다
func findIndex<T>(of valueToFind: T, in array:[T]) -> Int? {
for (index, value) in array.enumerated() {
if value == valueToFind {
return index
}
}
return nil
}3. 적절한 제약 추가
우리는 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
}🐼 Associated Types (in 프로토콜)
프로토콜을 정의할 때, 때때로 associated type을 정의하는 것이 유용합니다
Associated Type은 프로토콜에서 사용하는 type parameter입니다
기존에 다루던 Generic함수/타입에서처럼 구체적으로 '어떤 타입인지'는 정의하지 않습니다
반면, '이런저런 요구사항들은 서로 같은 타입을 사용해야 해'를 정의합니다
예제로 살펴봅시다
✔️ 예제
associatedtype이라는 키워드로 정의됩니다
아래 예제는 associated type과 이를 사용하는 3가지 요구사항을 정의합니다
protocol Container {
associatedtype Item
mutating func append(_ item: Item)
var count: Int { get }
subscript(i: Int) -> Item { get }
}Container 프로토콜의 요구사항을 정리하면
Item이 어떤 타입이든 상관없다- 단, 적어도 하나의 타입에 대해 append()/count/subscript를 전부 구현해야 한다
이 요구사항을 준수하는 것은, Generic/non-Generic 타입 모두 가능합니다
1. non-Generic 타입이 준수할 때
프로토콜에서 Item이 어떤 타입인지는 상관없고
적어도 하나의 타입에서 요구사항을 전부 구현하기만 하면 됩니다
그러므로 아래의 예제는 Container프로토콜을 준수합니다
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]
}
}❗️주의❗️
여기서typealias구문은 정석적으로 명시해주는게 맞으나
'컴파일러가 추론 가능한 상황'이라면 생략할 수 있긴 합니다
위 예제처럼 Int에 대해서만 모든 요구사항을 맞췄다면
컴파일러는 Int가 Item임을 추론할 수 있습니다
2. Generic 타입이 준수할 때
아래는 Generic 타입 예시입니다
(여기서도 typealis Item = Element를 써주는게 정석이나 생략할 수 있습니다)
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
공식문서에서는 Array를 예시로 들었습니다
하지만, Array는 Container의 요구사항을 이미 준수하고 있기에
빈 extension에 프로토콜만 추가채택시키면 됩니다
(typealias도 추론가능한 상태)
extension Array: Container {}✔️ 제약걸기
associatedtype을 정의할 때, 제약을 걸어주면 됩니다
protocol Container {
associatedtype Item: Equatable
mutating func append(_ item: Item)
var count: Int { get }
subscript(i: Int) -> Item { get }
}Container 프로토콜을 준수하기 위해선,
Item이 Equatable해야 한다는 추가 조건이 생겼습니다
✔️ 자기자신 타입을 다루도록 하는 프로토콜
어떤 프로토콜은 자신의 요구사항의 일부로 나타날 수도 있습니다
예를 들면 아래와 같이,
SuffixableContainer의 요구사항에 SuffixableContainer이 등장합니다
protocol SuffixableContainer: Container {
associatedtype Suffix: SuffixableContainer where Suffix.Item == Item
func suffix(_ size: Int) -> Suffix
}위 프로토콜의 요구사항을 해석해보면,
func suffix()의 return타입인 Suffix는 2가지 룰이 있습니다
1. SuffixableContainer 프로토콜을 준수하는 타입이어야 합니다
이걸 준수하기 위한 대표적인 방법으론,
이 프로토콜을 채택하려는 타입, 자기자신 타입을 return하도록 만드는 것입니다.
물론 아래 예제와 같이,
SuffixableContainer을 채택하는 다른 타입이 와도 되긴 합니다
extension IntStack: SuffixableContainer {
func suffix(_ size: Int) -> Stack<Int> {
var result = Stack<Int>()
for index in (count-size)..<count {
result.append(self[index])
}
return result
}
// Inferred that Suffix is Stack<Int>.
}2. Container 프로토콜을 준수시키느라 결정한 Item 타입과 같아야 합니다
우선, 프로토콜 상속을 사용하므로
SuffixableContainer를 준수하려면, Container도 준수해야 합니다
Container를 준수시키느라 append() 등에 사용한 타입이 있을텐데
이 타입과 Suffix의 Item이 같은 타입이어야 합니다
물론, 위의 1번에서 대표적인 방법이라고 소개한 '자기자신 타입을 Suffix로 지정'한다면 이 조건은 신경쓸 필요가 없습니다 (같을 수 밖에 없기 때문)
하지만, '자기자신이 아닌 다른 타입을 Suffix로 지정'하고자 할 때는 조건이 맞지 않을 수 있습니다
Suffix로 쓰려는 다른 타입 또한 SuffixableContainer를 준수하므로
Container도 준수하려고 Item으로 지정한 타입이 있을텐데
그 타입과 현재 타입의 Item은 서로 다른 타입일 수 있기 때문입니다
역시 말로만 치면 힘드므로 예제를 만들어보았습니다
extension IntStack: SuffixableContainer {
func suffix(_ size: Int) -> Stack<Double> { //Error!
var result = Stack<Double>()
for index in (count-size)..<count {
result.append(self[index])
}
return result
}
// Inferred that Suffix is Stack<Int>.
}위에서 Stack<Double> 역시
SuffixableContainer를 준수하므로 1번 조건은 맞춰졌지만
Item 타입이 서로 다르므로 (Double / Int) 2번 조건이 맞춰지지 않아
에러를 유발합니다
🐻❄️ Generic Where 구문
Type 제약은 Generic과 관련한 type paramter에 요구사항을 정의할 수 있게 해줍니다
이는 associated type에 대한 요구사항을 정의할 때도 유용합니다
'Generic Where 구문'을 정의함으로써 그렇게 할 수 있습니다
(바로 위 section에서도 다룸)
Generic where 구문을 사용하여, associated type에 걸 수 있는 조건
- 특정 프로토콜을 준수할 것
- 특정 type parameter와 동일한 타입일 것
where 키워드로 시작해서 constraint 혹은 equality 관계를 명시하면 됩니다
✔️ 예제
아래는 Generic 함수에 where 구문을 추가한 예시입니다
where구문은 return 타입 뒤에 옵니다
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
}보이는 바와 같이, allItemsMatch()함수는 C1.Item과 C2.Item이 같으면서 Equatable해야 사용할 수 있습니다
🐨 Extension에서의 Generic Where 구문
Generic 타입/프로토콜에 어떤 기능을 추가하려는데
특정 조건에 부합하는 type parameter에 대해서만 추가하고 싶다면
extension에 where조건을 걸어 구현할 수 있습니다
extension에 Generic 조건을 걸 수 있습니다
(사실 위 section에서 이미 다뤘음)
아까봤던 예제를 다시 봅시다
extension Stack where Element: Equatable {
func isTop(_ item: Element) -> Bool {
guard let topItem = items.last else {
return false
}
return topItem == item
}
}만약 이 예제에서 where 조건을 걸 수 없었다면,
==연산자를 코드에 넣는데 있어 문제를 겪었을 것입니다
Protocol의 extension에도 where 조건을 걸 수 있습니다
이것도 이미 본 것 같은데..
extension Container where Item: Equatable {
func startsWith(_ item: Item) -> Bool {
return count >= 1 && self[0] == item
}
}Item에 비교연산자를 사용하기 위해 Equatable해야 한다는 조건을 설정
조건은 프로토콜이 아닌 특정 타입인지 여부를 확인하는 것일 수 있습니다
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"조건을 여러 개 걸 수도 있습니다
콤마로 구분하면 됩니다
extension temptemp where Item: Equatable, Item == Int {
func printprint() {
print("good")
}
}🐯 where 조건을 작은 단위로 걸 수도 있다 (contextual)
조건을 타입 통째로 걸지 않고
특정 subscript나 메서드에만 where 조건을 걸 수도 있습니다
(물론, 해당 type이 Generic type이어야 함)
이를 문서에선 contextual where clause라고 표현합니다
아래 예제에서 Container 구조체는 Generic이며
extension으로 추가하는 메서드 별로 조건을 걸어주고 있습니다
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
}
}average()와 endsWith()는 원본 정의부에 있는 Item type paramter에 각각 type 제약을 걸고 있습니다
extension에 걸어서 분리시켜는 방식도 있다
위 예제에서 의도한 것처럼, 메서드별로 서로 다른 조건을 걸어주기 위한 방법으로
extension에 type 제약을 걸고 extension을 분리시켜버리는 방법도 있습니다
extension Container where Item == Int {
func average() -> Double {
var sum = 0.0
for index in 0..<count {
sum += Double(self[index])
}
return sum / Double(count)
}
}
extension Container where Item: Equatable {
func endsWith(_ item: Item) -> Bool {
return count >= 1 && self[count-1] == item
}
}개인적으로 이게 가독성이 더 좋아보입니다
🦁 Associated Type에서의 Generic Where 구문
슬슬 익숙하니 바로 예제로 봅시다
protocol Container {
associatedtype Item
mutating func append(_ item: Item)
var count: Int { get }
subscript(i: Int) -> Item { get }
associatedtype Iterator: IteratorProtocol where Iterator.Element == Item
func makeIterator() -> Iterator
}위 예제를 해석해보면
Container 프로토콜을 준수하려면 Iterator의 타입을 정의해야 하는데
이 Itertor는 IteratorProtocol을 준수하면서 Element가 Item과 동일한 타입이어야 합니다
프로토콜 상속관계가 있는 경우
부모 프로토콜(아래 예제에선 Container)의 associated type(Item)으로 조건을 걸 수도 있습니다
protocol ComparableContainer: Container where Item: Comparable { }🐮 Generic subscript
subscript 역시 generic으로 정의할 수 있고 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
}
}위 예제를 해석하면
1. subscript의 index는 Sequence 프로토콜을 준수할 것
2. 또한, Sequence.Iterator.Element의 타입이 Int일 것
(self[index]와 result가 같은 index 타입을 사용하도록)
3. return 타입은 Container 원본 정의부에 정의한 Item과 같은 타입의 배열일 것
이 제약들을 종합해보면 indices로 전달되는 값은 integer의 sequence임을 의미합니다
