[Swift] 공식 문서 정리 (22) - Protocols (프로토콜)

안녕하세요, 감자입니다! (왜..오랜만에 인사하는것 같지..)
일주일만에 돌아온 공식 문서 정리입니다.. 이번주 내내 프로토콜 관련해서만 정리한 것 같아요. 그리고 애플아카데미의 시작으로 시간이 너무너무 부족하네요 ㅠㅠ 그래도 지치지도 않고 프로토콜 정리내용을 가져왔습니다. 내용이 너~~~~~무 많아서,, 모든 내용이 다 머릿속에 들어오진 않은 것같아요 ㅠ 더 읽어보고, 실무에서 접해보는 방법 뿐이겟죠? 그럼 즐거운 마음으로 시작해봅시다! gogo

Swift Document chap.22 Protocols (프로토콜) 바로가기

Protocols — The Swift Programming Language (Swift 5.6)

---

Protocols (프로토콜 ; 규약)

프로토콜은 특별한 임무 또는 기능 조작에 적합한 메서드와, 프로퍼티, 요구사항의 청사진을 정의한다. 그런 뒤 이런 요구사항의 실제 구현을 위해 class, struct, enum에서 protocol을 채택할 수 있다. 이때 protocol이 요구하는 사항들을 모두 충족하면 해당 타입은 Protocol을 준수한다고 말한다.

준수해야하는 타입의 요구사항을 정의하는 것 외에도 요구사항의 일부를 구현하거나 준수하는 타입에 추가 기능을 구현하기 위해 프로토콜을 확장할 수도 있다.

 

Protocol Syntax (프로토콜 구문)

프로토콜은 클래스, 구조체 및 열거형과 비슷한 방식으로 정의한다.

protocol SomeProtocol {
  // 프로토콜 정의는 여기에 둠
}

사용자 정의 타입은, 자신의 정의 부분에서 타입 이름 뒤에 프로토콜 이름을 콜론으로 구분하여 둠으로써 프로토콜을 채택한다고 알릴 수 있다. 여러개의 프로토콜을 쉼표,로 나누어 나열할 수도 있다.

struct SomeStructure: FirstProtocol, AnotherProtocol {
  // 구조체 정의는 여기에 둠
}

클래스에 상위 클래스가 있다면, 상위 클래스 이름 먼저 작성한 후, 그 뒤에 쉼표,를 활용하여 프로토콜을 채택한다.

class SomeClass: SomeSuperclass, FirstProtocol, AnotherProtocol {
  // 클래스 정의는 여기에 둠
}

 

1. 프로퍼티 필수 조건 (Property Requirements)

• 프로토콜은 특정 이름과 타입을 갖는 인스턴스 프로퍼티, 타입 프로퍼티를 사용해서 요구하는 타입을 정의할 수 있음.
• 프로토콜은 프로퍼티가 저장 프로퍼티인지 계산 프로퍼티인지 지정하지 않고 필요한 프로퍼티의 이름과 타입만 지정함.
• 프로토콜은 각각의 프로터피가 gettable, settable 한지도 지정해주어야 함.
• 프로토콜에서 gettable, settable 둘 다 요구하는 경우, 해당 프로퍼티는 상수 저장 프로퍼티 혹은 읽기 전용 계산 프로퍼티로는 요구사항을 만족시킬 수 없음.
• 프로토콜이 gettable 프로퍼티만 요구할 경우, 모든 종류의 프로퍼티로 요구사항을 만족시킬 수 있고, 이런 프로퍼티는 settable 에서도 유효함.

프로퍼티 요구사항은 항상 var 키워드와 함께 선언된다. gettable , settable 프로퍼티는 타입 선언 뒤에 { get set } 으로 작성해서 나타내며, gettable 프로퍼티는 { get } 으로 작성하면 된다.

protocol SomeProtocol {
  var mustBeSettable: Int { get set }
  var doesNotNeedToBeSettable: Int { get }
}

프로토콜에서 타입프로퍼티를 정의할 땐 항상 static 키워드를 사용해주어야 한다. 이 규칙은 Class 에 프로토콜을 채택한 경우에 class, static 키워드를 쓰는 경우에도 적용된다.

protocol AnotherProtocol {
  static var someTypeProperty: Int { get set }
}

 

▶️ 이제 예시를 살펴보자.

protocol FullyNamed {
  var fullName: String { get }
}

FullyNamed 프로토콜은 풀네임을 제공하기 위해 준수해야하는 타입을 요구한다. 프로토콜은 다른 준수하는 타입의 특성에 대한 다른 것을 지정하지는 않는다. 프로토콜은 타입에게 fullName을 제공할 수 있어야 한다는 것만 정해준다. 프로토콜을 준수하는 모든 FullyNamed 타입에는 String 타입의 fullName이라는 gettable 인스턴스 프로퍼티가 존재해야한다.

다음은 FullyNamed 프로토콜을 채택하고 준수하는 struct에 대한 에시이다.

struct Person: FullyNamed {
  var fullName: String
}
let john = Person(fullName: "John Appleseed")
// john.fullName 은 "John Appleseed" 임

위 코드는 특정 이름을 가진 사람을 나타내는 Person이라는 구조체를 정의한다. 정의 첫 줄에서 FullyNamed 프로토콜을 채택한다고 작성했다.

각각의 Person 인스턴스는 String 타입의 FullName이라는 단일 저장 프로퍼티를 갖는다. 이는 FullyNamed 프로토콜의 단일 필수 조건과 일치하며 Person이 프로토콜을 올바르게 준수한다는 의미이다. 만약 프로토콜의 필수 조건을 충족하지 않는다면 컴파일 에러가 발생할 것이다.

FullyNamed 프로토콜을 채택하고 준수하는 더 복잡한 예시를 보자.

class Starship: FullyNamed {
  var prefix: String?
  var name: String
  init(name: String, prefix: String? = nil) {
    self.name = name
    self.prefix = prefix
  }
  var fullName: String {
    return (prefix != nil ? prefix! + " " : "") + name
  }
}
var ncc1701 = Starship(name: "Enterprise", prefix: "USS")
// ncc1701.fullName 은 "USS Enterprise" 임

이 클래스는 fullName 프로퍼티 필수 조건을 starship의 읽기 전용 계산 프로퍼티로 구현했다. 각각의 Starship 클래스 인스턴스는 의무적인 name과 옵션인 prefix를 저장한다. prefix 값이 존재하면, fullName 프로퍼티가, name앞에 이를 붙여 우주선 전체 이름을 생성한다.

 

2. 메서드 필수 조건 (Method)

프로토콜은 자신을 채택한 타입에게 특정 인스턴스나 타입 메서드를 요구할 수도 있다. 이러한 메서드는 일반적인 인스턴스 메서드, 타입 메서드와 같은 방식으로 프로토콜 내부에 작성되지만, 중괄호나 메서드 본문은 없다. 일반적인 메서드와 동일한 규칙에 따라 가변 매개변수는 허용되지만, 프로토콜 정의 내에서는 메서드 매개변수에 기본 값을 지정할 수는 없다.

타입 프로퍼티와 마찬가지로, 프로토콜에서 타입 메서드 조건을 정의할 때는 항상 static 키워드 접두사를 붙인다. 타입 메서드 필수 조건을 클래스가 구현할 때 class 나 static 키워드 접두사를 붙더라도 마찬가지이다.

protocol SomeProtocol {
  static func someTypeMethod()
}

다음 예제는 단일 인스턴스 메서드 필수 조건을 가진 프로토콜을 정의하는 코드이다.

protocol RandomNumberGenerator {
  func random() -> Double
}

RandomNumberGenerator 이라는 이 프로토콜은 어떤 준수 타입이든 random이라는 인스턴스 메서드를 가지기를 요구하는데, 이를 호출할 때마다 double 값을 반환한다. 프로토콜에서 지정하지 않긴 하지만, 이 값은 0.0에서 1.0까지의 값이라 가정한다. (1.0 미포함)

RandomNumberGenerator 프로토콜은 각각의 난수 발생 방법에 대해선 어떤 가정도 하지 않는다. 생성자가 새로운 난수를 생성하는 표준 방법을 제공하기만 하면 된다.

다음으로는 RandomNumberGenerator 프로토콜을 채택하고 준수하는 class를 구현한 코드이다. 이 클래스는 linear congruential generator로 알려진 pseudorandom number generator 알고리즘을 구현한다.

class LinearCongruentialGenerator: RandomNumberGenerator {
  var lastRandom = 42.0
  let m = 139968.0
  let a = 3877.0
  let c = 29573.0
  func random() -> Double {
    lastRandom = ((lastRandom * a + c)
      .truncatingRemainder(dividingBy:m))
    return lastRandom / m
  }
}
let generator = LinearCongruentialGenerator()
print("Here's a random number: \\(generator.random())")
// "Here's a random number: 0.3746499199817101" 를 인쇄함
print("And another one: \\(generator.random())")
// "And another one: 0.729023776863283" 를 인쇄함

 

3. 변경 메서드 필수 조건 (Mutating Methods)

메서드가 자신이 속한 인스턴스를 수정(변경)하는 것이 필요할 때가 있다. 값 타입의 (구조체와 열거형)인스턴스 메서드이면, 메서드의 func 키워드 앞에 mutating 키워드를 작성하여 메서드가 자신이 속한 인스턴스 및 그 인스턴스에 있는 어떤 속성의 수정이든 허용한다고 지시할 수 있다.

프로토콜을 채택한 어떤 타입의 인스턴스든 변경할 의도로 프로토콜 인스턴스 메서드 필수 조건을 정의하는 거라면, 프로토콜 정의 부분에서 mutating 키워드로 메서드를 표시한다. 이는 구조체 및 열거형이 프로토콜을 채택해서 그 메서드 필수 조건을 만족할 수 있게 한다.

▶️ Note

프로토콜이 요구하는 인스턴스 메서드에 mutating 을 표시하더라도 클래스는 해당 메서드를 구현할 때 mutating키워드를 사용할 필요가 없다. mutating 은 구조체, 열거형의 경우에만 사용한다.

 

다음은 하나의 인스턴스 메서드를 요구하는 Togglable 프로토콜 이다. 이름에서 알 수 있듯, toggle() 메서드는 일반적으로 해당 타입의 프로퍼티를 수정해서 해당 타입의 상태를 전환하기 위한 메서드이다.

toggle() 메서드는 Togglable 프로토콜 정의의 일부로 mutating 키워드로 표시되어 메서드가 호출될 때 해당 인스턴스의 상태를 변경할 수 있다는 것을 알려준다.

protocol Togglable {
  mutating func toggle()
}

구조체나 열거형이 Togglable 프로토콜을 구현하면, mutating 으로도 표시한 toggle()메서드를 구현함으로써 그 구조체나 열거형이 프로토콜을 준수할 수 있다.

아래 예제는 OnOffSwitch 라는 열거형을 정의한다. 이 열거형은 on 과 off 열거형 case 로 표시한 두 상태 사이를 전환한다. Togglable 프로토콜의 필수 조건과 일치하도록, 열거형의 toggle 구현에 mutating 을 표시했다.

enum OnOffSwitch: Togglable {
  case off, on
  mutating func toggle() {
    switch self {
    case .off:
      self = .on
    case .on:
      self = .off
    }
  }
}
var lightSwitch = OnOffSwitch.off
lightSwitch.toggle()
// lightSwitch 는 이제 .on 과 같음

 

4. 생성자 필수 조건 (Initializer requirements)

프로토콜은 준수 타입에게 특정 생성자 구현을 요구할 수 있다. 이 생성자들은 보통의 생성자와 정확히 똑같은 방식으로 프로토콜의 정의 부분에 작성하지만, 중괄호나 메서드 본문이 없다.

protocol SomeProtocol {
  init(someParameter: Int)
}

프로토콜 생성자 필수 조건의 클래스 구현 (required 키워드)

프로토콜 생성자 필수 조건은 준수 클래스에서 designated 생성자나 convenience 생성자 어느 것으로든 구현할 수 있다. 두 경우 모두 **required 키워드**를 표시해야한다.

class SomeClass: SomeProtocol {
  **required** init(someParameter: Int) {
    // 초기자 구현은 여기에 둠
  }
}

required 생성자를 사용하면 class의 모든 서브 클래스도 해당 생성자를 명시적으로 혹은 상속된 구현을 통해 구현하므로, 부모 클래스가 채택중인 프로토콜을 준수하도록 할 수 있다. reqiured 생성자에 대한 더 많은 정보는 chap.14에서 살펴보도록 하자.

▶️ Note

final 클래스는 서브클래싱 할 수 없기 때문에 final 클래스는 프로토콜이 요구하는 생성자에 required를 필요할 표시가 없다.

 

하위 클래스가 상위 클래스의 designated 생성자를 오버라이드 하면서 프로토콜의 일치하는 생성자 필수 조건도 구현한다면, 생성자 구현에 required 와 override 키워드를 모두 표시한다.

protocol SomeProtocol {
  init()
}

class SomeSuperClass {
  init() {
    // 초기자 구현은 여기에 둠
  }
}

class SomeSubClass: SomeSuperClass, SomeProtocol {
  // "required" 는 SomeProtocol 준수에서; "override" 는 SomeSuperClass 에서 온 것임
  **required override** init() {
    // 초기자 구현은 여기에 둠
  }
}

 

5. Failable Initializer Requirement (실패 가능한 생성자 필수 조건)

chap.14에서 Failable Initializer에 정의된 것처럼, 프로토콜은 실패 가능한 생성자 요구사항으로 정의할 수 있다.

프로토콜의 실패 가능한 생성자 요구사항은 자신을 채택한 타입이 실패 가능, 실패 불가능한 생성자가 있을 때 만족된다. 실패할 수 없는 생성자를 요구하는 프로토콜을 채택한 경우, 실패할 수 없는 생성자 또는 암시적으로 래핑되지 않는 실패 가능한 생성자로 만족시킬 수 있다.

---

 

Protocols as Types (타입으로써의 프로토콜)

프로토콜은 자체적으로 어떤 기능을 구현하지는 않는다. 하지만 코딩을 할 때 프로토콜은 하나의 타입처럼 사용할 수 있다. 프로토콜을 타입처럼 사용하는 것을 **existential type** 이라고 부르는데, 이는 ‘T가 프로토콜을 준수하도록 타입 T 가 존재합니다’ 라는 문구에서 유래되었다. (?)

다음을 포함하여 다른 타입이 허용되는 여러 위치에서 프로토콜을 사용할 수 있다.

• 함수, 메서드, 생성자의 매개변수 타입 또는 반환 타입
• 상수, 변수, 프로퍼티의 타입
• 배열, 딕셔너리 등의 항목 타입

▶️ Note

프로토콜이 타입이므로 (앞에서 봤던 FullyNamed, RandomNumberGenerator 처럼) , Swift의 다른 타입들 (Int, String,,,,) 처럼 이름이 대문자로 시작한다.

 

프로토콜을 타입을 사용하는 예제를 살펴보자.

class Dice {
  let sides: Int
  let generator: RandomNumberGenerator
  init(sides: Int, generator: RandomNumberGenerator) {
    self.sides = sides
    self.generator = generator
  }
  func roll() -> Int {
    return Int(generator.random() * Double(sides)) + 1
  }
}

▶️ 코드 설명

• 이 예제는 보드게임에서 사용할 n 면체 주사위를 나타내는 Dice라는 새 클래스를 정의한다
• Dice 인스턴스에는, sides 라는 정수 속성, 주사위 굴림 값 생성을 위한 난수 생성 generator 속성이 있다.
• **generator** 속성타입 설명
  • generator 속성 타입은 RandomNumberGenerator 이다. 따라서 RandomNumberGenerator 프로토콜을 채택하는 모든 타입의 인스턴스를 사용할 수 있다.
  • 인스턴스가 RandomNumberGenerator 프로토콜을 채태한다는 점을 제외하고 이 속성에 해당될 인스턴스 요구사항은 없다.
  • generator의 타입이 RandomNumberGenerator 이므로, Dice 클래스 내부 코드는 이 프로토콜이 준수하는 모든 인스턴스에 적용되는 방식으로만 generator을 사용할 수 있다. 즉, generator의 기본 타입에 정의된 메서드나 프로퍼티를 사용할 수 없다.
  • 하지만 다운캐스팅에서 설명한 슈퍼클래스를 서브클래스로 다운클래싱하는 것처럼 프로토콜 타입을 기본타입으로 다운캐스트해서 사용할 수는 있다.
• **init** 생성자
  • Dice의 초기상태를 설정하기 위한 생성자
  • RandomNumberGenerator 타입의 generator 라는 매개변수가 존재.
  • 새로운 Dice 인스턴스를 생성할 때 generator 매개변수에는 RandomNumberGenerator를 채택한 모든 인스턴스 값을 전달할 수 있음.
• **roll()** 메서드
  • Dice는 1과 sided 사이의 정수값을 반환하는 인스턴스 메서드
  • 이 메서드는 generator의 random() 메서드를 호출해서 0.0~1.0 사이의 새로운 난수를 생성해주고, 이 난수를 사용해서 범위 내의 값을 만들어준다.
  • generator는 RandomNumberGenerator를 채택했기 때문에 random() 메서드가 반드시 존재함!!

위의 Dice 클래스를 사용하여 LinearCongruentialGenerator 인스턴스를 generator로 사용해서 6면 주사위를 만드는 방법은 다음과 같다.

var d6 = Dice(sides: 6, generator: LinearCongruentialGenerator())
for _ in 1...5 {
  print("Random dice roll is \\(d6.roll())")
}

// Random dice roll is 3
// Random dice roll is 5
// Random dice roll is 4
// Random dice roll is 5
// Random dice roll is 4

 

---

 

Delegation (위임)

Delegation은 클래스나 구조체가 일부 책임을 다른 타입의 인스턴스에 넘길 수 있도록 하는 디자인 패턴이다. Delegation패턴은 위임된 책임을 캡슐화하는 프로토콜을 정의하여 구현된다. 따라서 프로토콜을 채택한 타입이 위임된 기능을 제공하도록 보장된다. Delegation을 사용하여 특정 작업에 응답하거나, 해당 소스의 기본 타입을 알 필요 없이 외부 소스에서 데이터를 검색할 수 있다.

아래 예시는 주사위 기반 보드게임에서 사용하기 위한 2개의 프로토콜을 정의한 코드이다.

protocol DiceGame {
  var dice: Dice { get }
  func play()
}

protocol DiceGameDelegate: AnyObject {
  func gameDidStart(_ game: DiceGame)
  func game(_ game: DiceGame, didStartNewTurnWithDiceRoll diceRoll: Int)
  func gameDidEnd(_ game: DiceGame)
}

DiceGame 프로토콜은 주사위와 엮인 어떤 게임이든 채택할 수 있는 프로토콜이다.

DiceGameDelegate프로토콜을 채택하면 DiceGame의 진행상황을 추적할 수 있다. 강한 참조 사이클을 방지하기 위해서 delegate는 weak참조로 선언된다. weak 참조에 대한 설명은 여기서 살펴보자.

잠시 뒤에 나오는 class-only 프로토콜 섹션에서 나올 내용을 미리 말씀드리면, class 전용 프로토콜은 AnyObject를 상속하는 것으로 표시하면 된다. 프로토콜을 클래스 전용으로 표시하면 이번 챕터의 뒷 부분에 나오는 SnakesAndLadders 클래스의 delegate처럼 weak참조로 선언할 수 있다.

다음은 원래 chap.5 Control Flow 에서 소개된 snake and ladders 게임 버전이다. 이 버전은 DiceGame 프로토콜을 채택하고 DiceGameDeleagate에게 진행상황을 알리기 위해 dice-roll에 Dice 인스턴스를 사용하도록 되어있다.

class SnakesAndLadders: DiceGame {
  let finalSquare = 25
  **let dice** = Dice(sides: 6, generator: LinearCongruentialGenerator())
  var square = 0
  var board: [Int]
  init() {
    board = Array(repeating: 0, count: finalSquare + 1)
    board[03] = +08; board[06] = +11; board[09] = +09; board[10] = +02
    board[14] = -10; board[19] = -11; board[22] = -02; board[24] = -08
  }
  weak var delegate: DiceGameDelegate?
  **func play()** {
    square = 0
    delegate?.gameDidStart(self)
    gameLoop: while square != finalSquare {
      let diceRoll = dice.roll()
      delegate?.game(self, didStartNewTurnWithDiceRoll: diceRoll)
      switch square + diceRoll {
      case finalSquare:
        break gameLoop
      case let newSquare where newSquare > finalSquare:
        continue gameLoop
      default:
        square += diceRoll
        square += board[square]
      }
    }
    delegate?.gameDidEnd(self)
  }
}

이 버전의 게임은 DiceGame 프로토콜을 채택한 SnakesAndLadders 클래스로 래핑된다.

이는 프로토콜 준수를 위해서 gettable dice 프로퍼티와 play() 메서드를 제공한다. (dice 프로퍼티는 생성 후 변경할 필요가 없기 때문에 let으로 선언되며 프로토콜은 gettable만 요구하므로 문제가 없다.)

snakes and Ladders 게임은 class 의 init() 생성자에서 이루어진다. 모든 게임 논리는 프로토콜의 필수 요소인 dice 프로퍼티를 사용해서 주사위 역할을 제공하는 프로토콜의 play() 메서드로 진행된다.

delegate 프로퍼티는 옵셔널 DiceGameDelegate 타입으로 정의되어 있다. 옵셔널인 이유는 게임을 플레이하기 위해 delegate는 필요하지 않기 때문이다. 옵셔널 타입이기 때문에 delegate 프로퍼티의 초기값은 nil 이다. 그런 뒤 게임을 생성한 곳에서 적절한 delegate값을 설정할 수 있다. DiceGameDelegate 프로토콜은 클래스 전용이므로 참조 주기를 방지하기 위해 weak 으로 선언할 수 있는 것도 볼 수 있다.

DiceGameDelegatge는 게임 진행상황을 추적하는 세 가지 메서드를 제공한다. 이러한 세 가지 메서드는 위의 play() 메서드 내에서 게임 논리에 통합되어 새로운 게임이 시작되거나 새 차례가 오거나 게임이 종료될 때까지 호출된다.

delegate프로퍼티는 옵셔널 DiceGameDelegate이므로, play() 메서드는 delegate 메서드를 호출할 때마다 옵셔널 체이닝을 사용한다. delegate 프로퍼티가 nil 이라면 이러한 호출은 정상적으로 실패하게 되고, nil 이 아니라면 delegate 메서드가 호출되고 SnakesAndLadders 인스턴스가 매개변수로 전달된다.

다음 예시는 DiceGameDelegate 프로토콜을 채택한 DiceGameTracker라는 클래스를 정의한 코드이다.

class DiceGameTracker: DiceGameDelegate {
  var numberOfTurns = 0
  func gameDidStart(_ game: DiceGame) {
    numberOfTurns = 0
    if game is SnakesAndLadders {
      print("Started a new game of Snakes and Ladders")
    }
    print("The game is using a \\(game.dice.sides)-sided dice")
  }
  func game(_ game: DiceGame, didStartNewTurnWithDiceRoll diceRoll: Int) {
    numberOfTurns += 1
    print("Rolled a \\(diceRoll)")
  }
  func gameDidEnd(_ game: DiceGame) {
    print("The game lasted for \\(numberOfTurns) turns")
  }
}

DiceGagmeTracker는 DiceGameDelegate에 필요한 세 가지 메서드를 모두 구현해뒀다. 이런 메서드를 사용해서 게임에서 수행한 차례의 횟수를 알아낸다. 게임이 시작되면 numberOfTurns 프로퍼티를 0으로 재설정하고, 새로운 턴이 시작되면 값을 증가시키며 게임이 끝나면 총 턴 수를 출력한다.

위 코드에 있는 gameDidStart(_: )구문은 game매개변수를 사용하여 플레이하려는 게임에 대한 이부 소개 정보를 출력한다. game 매개변수는 SnakesAndLadders가 아닌 DiceGame타입이므로,gameDidStart(_: )는 DiceGame프로토콜의 일부로 구현된 메서드와 프로퍼티에만 접근하고 사용할 수 있다. 그러나 메서드는 여전히 타입 캐스팅을 사용하여 기본 인스턴스 형식을 쿼리할 수도 있다. 이 예제에서는 게임이 종료되면 back 단에서 SnakeAndLadders 인스턴스인지 확인하고 그렇다면 적절한 메시지를 출력한다.

gameDidSet(: )메서드는 전달된 game 매개변수의 dice 프로퍼티에도 접근한다. game 은 DiceGame 프로토콜을 관계 없이 준수하므로 dice 프로퍼티가 반드시 존재하기 때문에 gameDidStart( _:) 메서드는 어떤 종류의 게임이 플레이되는지 상관 없이 dice의 side 프로퍼티에 접근하여 출력할 수 있다*.*

DiceGameTracker가 작동하는 모습을 나타낸 코드는 아래와 같다.

let tracker = DiceGameTracker()
let game = SnakesAndLadders()
game.delegate = tracker
game.play()
// Started a new game of Snakes and Ladders (새로운 뱀과 사다리 게임을 시작함)
// The game is using a 6-sided dice (6-면체 주사위를 사용하는 게임임)
// Rolled a 3 (3이 나옴)
// Rolled a 5 (5가 나옴)
// Rolled a 4 (4가 나옴)
// Rolled a 5 (5가 나옴)
// The game lasted for 4 turns (게임을 4턴 동안 지속함)

---

 

확장으로 프로토콜 준수성 추가하기 (Adding Protocol Conformance within an extension)

기존 타입의 소스코드에서는 접근할 수 없는 경우에, 기존 타입의 extension을 통해 새로운 protocol을 채택할 수 있다.

extension은 기존 타입에 새로운 프로퍼티, 메서드, 서브 스크립트를 추가할 수 있으므로 프로토콜이 요구하는 것도 만족시킬 수 있다.

▶️ Note

타입의 기존 인스턴스에도 해당 타입의 extension에 의해 프로토콜이 채택 되면 자동으로 반영된다.

 

예를들어 아래에서 예시로 보여준 TextRepresentable이라는 프로토콜은 텍스트로 표현되는 방법이 있는 모든 타입을 구현할 수 있는 프로토콜이다. 이는 자신에 대한 설명 혹은 현재 상태에 대한 텍스트 일 수 있겠다.

protocol TextRepresentable {
  var textualDescription: String { get }
}

위에 있는 Dice 클래스를 확장하여 TextRepresentable 을 채택해보자.

extension Dice: TextRepresentable {
  var textualDescription: String {
    return "A \\(sides)-sided dice"
  }
}

이 extension은 마치 Dice가 자신의 원본 구현에서 제공하는 것과 동일한 방법으로 새로운 프로토콜을 채택한다. 프로토콜 이름은 타입 뒤에 콜론(:)을 이용하여 작성하면 되고, 프로토콜의 모든 요구사항은 해당 extension의 중괄호 안에서 정의하면 된다. 이제 모든 Dice인스턴스를 TextRepresentable로도 처리할 수 있게 되었다.!!

let d12 = Dice(sides: 12, generator: LinearCongruentialGenerator())
print(d12.textualDescription)
// "A 12-sided dice" 를 인쇄함

이와 비슷하게 SnakesAndLadders 클래스도 TextRepresentable 프로토콜을 채택하고 준수하게 만들 수 있다.

extension SnakesAndLadders: TextRepresentable {
  var textualDescription: String {
    return "A game of Snakes and Ladders with \\(finalSquare) squares"
  }
}
print(game.textualDescription)
// "A game of Snakes and Ladders with 25 squares" 를 인쇄함

 

조건에 따라 프로토콜 준수하기

제네릭 타입은 제네릭 매개변수가 프로토콜을 준수하는 경우와 같은 조건에서만 프로토콜의 요구사항을 만족시킬 수 있다.

타입에 extension을 사용할때 제약조건을 나열하여 제네릭 타입이 조건부로 프로토콜을 준수하도록 만들었다. where 을 사용하여 채택하려는 프로토콜 이름뒤에 제약조건을 작성하면 되는데, where 절에 대한 자세한 설명은 다음 섹션 chap.23 Generic 을 참고해보자

다음 extension은 저장한 원소의 타입이 TextRepresentable 을 준수할 때마다 Array 인스턴스가 TextRepresentable 프로토콜을 준수하게 한다.

extension Array: TextRepresentable where Element: TextRepresentable {
  var textualDescription: String {
    let itemsAsText = self.map { $0.textualDescription }
    return "[" + itemsAsText.joined(separator: ", ") + "]"
  }
}
let myDice = [d6, d12]
print(myDice.textualDescription)
// "[A 6-sided dice, A 12-sided dice]" 를 인쇄함

 

확장으로 프로토콜 채택 선언하기

타입이 프로토콜의 모든 필수조건을 이미 준수하고 있지만, 그 프로토콜을 채택한다고 아직 알리지 않은 경우라면 빈 extension으로 프로토콜을 채택하게 할 수도 있다.

struct Hamster {
  var name: String
  var textualDescription: String {
    return "A hamster named \\(name)"
  }
}
extension Hamster: TextRepresentable {}

let simonTheHamster = Hamster(name: "Simon")
let somethingTextRepresentable: TextRepresentable = simonTheHamster
print(somethingTextRepresentable.textualDescription)
// "A hamster named Simon" 을 인쇄함

프로토콜의 필수 조건을 만족한다고 해서 타입이 이를 자동으로 채택하진 않는다. 반드시 자신이 프로토콜을 채택한다는 것을 명시적으로 선언해주어야 한다.

---

 

Adopting a Protocol Using a Synthesized Implementation (통합 구현을 써서 프로토콜 채택하기)

스위프트는 많은 간단한 경우에 Equatable, Hashable 및 Comparable에 대한 프로토콜 준수성을 자동으로 제공할 수 있다. 이런 통합구현을 사용하면 스스로 프로토콜 필수 조건을 구현하고자 획일된 코드를 반복 작성하지 않아도 된다는 걸 의미한다.

▶️ Equatable 통합 구현

스위프트는 다음 종류의 사용자 정의 타입에 대해서 Equatable Synthesized Implementation을 사용할 수 있다.

• Equatable 프로토콜을 준수하는 저장 프로퍼티만 있는 구조체
• Equatable 프로토콜을 준수하는 associated type 만 있는 열거형
• associated type이 없는 열거형

== 의 통합구현을 사용하려면 == 연산자를 직접 구현하지 말고 코드에 Equatable 프로토콜을 채택한다. Euatalbe 프로토콜은 !=의 기본 구현을 제공한다.

다음 코드는 Vector2D 구조와 유사한 3차원 위치 벡터 (x,y,z)에 대한 Vector 3D 구조체를 정의한 코드이다. x,y,z 프로퍼티 모두 Equatable 타입이므로 Vector3D는 ==연산자의 통합구현을 사용할 수 있다.

struct Vector3D: Equatable {
  var x = 0.0, y = 0.0, z = 0.0
}

let twoThreeFour = Vector3D(x: 2.0, y: 3.0, z: 4.0)
let anotherTwoThreeFour = Vector3D(x: 2.0, y: 3.0, z: 4.0)
if twoThreeFour == anotherTwoThreeFour {
  print("These two vectors are also equivalent.")
}
// "These two vectors are also equivalent." 를 인쇄함

 

▶️ Hashable 통합 구현

스위프트는 다음 종류의 사용자 정의 타입에서 Hashable 통합 구현을 제공한다.

• Hashable 프로토콜을 준수하는 저장 프로퍼티만 있는 구조체
• Hashable 프로토콜을 준수하는 associated type 만 있는 열거형
• associated type이 없는 열거형

hash(into: )의 통합구현을 사용하려면, hash(into: )메서드를 직접 구현하지 않고 코드에 Hashable 프로토콜을 채택하면 된다.

스위프트는 raw Value가 없는 열거형에 대해 Comparable의 통합 구현을 제공한다. 열거형에 associated 타입이 있다면 이들은 모두 반드시 Comparable 프로토콜을 준수해야한다.

<의 통합 구현을 사용하려면, < 연산자를 직접 구현하지 않고 원래 열거형이 선언된 코드에 Comparable 프롵콜을 채택하면 된다. Comparealbe 프로토콜의 기본구현인 <=, > >=는 나머지 비교연산자를 제공한다.

다음 코드는 beginner, intermediate, expert 케이스를 갖는 SkillLevel 열거형을 정의한 코드이다. expert는 보유한 별의 수에 따라 추가로 순위가 매겨진다.

enum SkillLevel: Comparable {
  case beginner
  case intermediate
  case expert(stars: Int)
}
var levels = [SkillLevel.intermediate, SkillLevel.beginner,
              SkillLevel.expert(stars: 5), SkillLevel.expert(stars: 3)]
for level in levels.sorted() {
  print(level)
}
// "beginner" 를 인쇄함
// "intermediate" 를 인쇄함
// "expert(stars: 3)" 를 인쇄함
// "expert(stars: 5)" 를 인쇄함

---

 

프로토콜 타입의 집합체 (collections)

위에서 타입으로써의 프로토콜에서 언급한 것처럼, 배열이나 딕셔너리 같은 집합체에 저장할 타입으로 프로토콜을 사용할 수 있다.

다음 예제는 TextRepresentable 것들의 배열을 생성한다.

let things: [TextRepresentable] = [game, d12, simonTheHamster]

이제 배열의 항목을 반복하고, 각 항목의 설명 문장을 인쇄하는게 가능하다.

for thing in things {
  print(thing.textualDescription)
}
// A game of Snakes and Ladders with 25 squares (정사각형이 25칸 있는 뱀과 사다리 게임)
// A 12-sided dice (12-면체 주사위)
// A hamster named Simon (이름이 Simon 인 햄스터)

thing 상수의 타입은 TextRepresentable 임을 기억하자. 실제 인스턴스의 이면이 Dice나 DiceGame, Hamster 타입인 경우에도 이 타입들인게 아니고 TextRepresentable 인 것이다. 실제로 그런 타입이더라도 모두 TextRepresentable 타입이고, 해당 타입에는 textualDescription 프로퍼티가 있으므로 위와 같이 사용 가능하다.

---

 

프로토콜 상속

프로토콜은 하나 이상의 다른 프로토콜을 상속(inherit)할 수 있으며 자신이 상속한 필수 조건 위에 필수 조건을 더 추가할 수 있다. 프로토콜 상속 구문은 클래스 상속구문과 비슷하지만, 옵션으로 상속할 프로토콜이 여러개라면 쉼표(,) 로 구분하여 나열할 수 있다.

protocol InheritingProtocol: SomeProtocol, AnotherProtocol {
  // 프로토콜 정의는 여기에 둠
}

위에 있는 TextRepresentable 프롵토콜을 상속한 프로토콜 예제를 살펴보자.

protocol PrettyTextRepresentable: TextRepresentable {
  var prettyTextualDescription: String { get }
}

위 코드는 PrettyTextRepresentable 이라는 TextRepresentable을 상속한 새 프로토콜을 정의한다. PrettyTextRepresentable를 채택한 어떤 것이든 반드시 TextRepresentable 이 강제로 지정한 모든 필수 조건과, 더불어서 PrettyTextRepresentable 이 추가한 필수조건까지 모두 만족해야한다.

이 코드에서는 PrettyTextRepresentable는 String을 반환하는 prettyTextualDescription이라는 gettable 프로퍼티를 제공하라는 단일 필수조건을 추가한다.

이렇게 생성한 프로토콜을 SnakeAndLadders 클래스에 extension을 활용하여 프로토콜을 채택해보자.

extension SnakesAndLadders: PrettyTextRepresentable {
  var prettyTextualDescription: String {
    var output = textualDescription + ":\\n"
    for index in 1...finalSquare {
      switch board[index] {
      case let ladder where ladder > 0:
        output += "▲ "
      case let snake where snake < 0:
        output += "▼ "
      default:
        output += "○ "
      }
    }
    return output
  }
}

이 익스텐션은 SnakesAndLadders 타입이 PrettyTextRepresentable 프로토콜을 채택한다는 걸 알리며 이를 위해 prettyTextualDescription 프로퍼티의 구현을 제공한다고 명시한다. PrettyTextRepresentable 프로콜에서 textualDescription 프로퍼티에 접근하며 시작된다. 콜론:과 줄 바꿈\\n을 추가하고 이를 예쁜 텍스트 표현의 시작으로 사용한다. 그런 뒤 board 배열의 square 값을 통해 도형을 추가한다.

• 정사각형 값이 0 보다 크면, 사다리의 기초이므로, ▲ 로 나타낸다.
• 정사각형 값이 0 보다 작으면, 뱀의 머리이므로, ▼ 로 나타낸다.
• 그 외의 경우, 정사각형 값은 0 이고, “자유 (free)” 정사각형이라, ○ 로 나타낸다.

이제 prettyTextualDescriptoin 프로퍼티를 사용하면 어떤 SnakesAndLadders 인스턴스의 꾸밈 문장 설명도 인쇄할 수있다.

print(game.prettyTextualDescription)
// A game of Snakes and Ladders with 25 squares:
// ○ ○ ▲ ○ ○ ▲ ○ ○ ▲ ▲ ○ ○ ○ ▼ ○ ○ ○ ○ ▼ ○ ○ ▼ ○ ▼ ○

---

 

Class-only 프로토콜

프로토콜 상속 목록에 AnyObject 프롵코ㅗㄹ을 추가함으로써 프로토콜 채택을 클래스타입으로만 제한할 수있다. (구조체 x, 열거형 x, class only)

protocol SomeClassOnlyProtocol: AnyObject, SomeInheritedProtocol {
  // 클래스-전용 프로토콜 정의는 여기에 둠
}

이 코드의 SomeClassonlyProtocol은 클래스 타입만 채택 가능하다. SomeClassOnlyProtocol을 채택하려는 구조체 또는 열거형 정의를 작성하면 컴파일에러가 발생한다.

▶️ Note

그 프로토콜의 필수 조건이 정의한 동작이 준수타입은 값 의미 구조보다는, 참조 의미 구조를 가진다고 가정 또는 요구할 때 class only 프로토콜을 사용한다. 참조 및 값 타입 구조에 대한 내용은 이전 챕터 chap.9 Structures and Classes 를 다시보자.

---

 

프로토콜 합성 (Protocol Composition)

동시에 여러개의 프로토콜을 준수하는 타입을 요구하는 것이 유용할 때가 있다. 프로토콜 composition을 사용하여 여러개의 프로토콜을 하나의 프로토콜로 결합할 수 있다. 프로토콜 composition은 composition안에 있는 모든 프로토콜의 요구사항이 결합된 임시 로컬 프로퍼티를 정의한 것 처럼 작동한다. 프로토콜 composition은 새로운 프로토콜 타입을 정의하지는 않는다.

프로토콜 composition의 형식은 SomProtocol & AnotherProtocol이다. 앤드 기호 (&)로 구분하여 필요한 만큼 많은 프로토콜을 나열할 수 있다. 자신의 프로토콜 목록에 더하여, 프로토콜 composition은 클래스타입도 하나 담을 수 있는데, 이를 사용하여 필수 상위 클래스를 지정할 수도 있다.

Named와 Aged라는 두 프로토콜을 함수 매개변수에 대한 단일 프로토콜 composition 필수 조건으로 조합한 예제를 살펴보자.

protocol Named {
  var name: String { get }
}
protocol Aged {
  var age: Int { get }
}
struct Person: Named, Aged {
  var name: String
  var age: Int
}
func wishHappyBirthday(to celebrator: Named & Aged) {
  print("Happy birthday, \\(celebrator.name), you're \\(celebrator.age)!")
}
let birthdayPerson = Person(name: "Malcolm", age: 21)
wishHappyBirthday(to: birthdayPerson)
// "Happy birthday, Malcolm, you're 21!" 를 인쇄함

▶️ 코드 설명

• Named 프로토콜
  • Named 프로토콜에는 단일 필수 조건으로 name이라는 gettable String 속성이 있다.
  • Person이라는 구조체가 해당 프로퍼티를 채택한다.
• Aged 프로토콜
  • Aged 프로토콜에는 단일 필수 조건으로 age라는 gettable Int 속성이 있다.
  • Person이라는 구조체가 해당 프로퍼티를 채택한다.
• wishHappyBirthday(to:) 메서드
  • celebrator 라는 매개변수 : Named & Aged타입. 즉 Named 와 Aged 프로토콜을 둘 다 준수하는 타입.
  • 두 프로토콜을 모두 준수하는 한 함수에 전달한 특정 타입이 어느것인지는 중요하지 않다.
• birthdayPerson 이라는 Person 인스턴스
  • wishHappyBirthday(to: ) 함수에 이 인스턴스 전달
  • Person 이 두 프로토콜을 준수하기 때문에 이 호출이 유효하고, wishHappyBirthday(to: )함수가 자신의 생일 인사말을 인쇄한다.

이전 예제의 Named 프로토콜과 Location 클래스를 조합한 예제를 보자.

class Location {
  var latitude: Double
  var longitude: Double
  init(latitude: Double, longitude: Double) {
    self.latitude = latitude
    self.longitude = longitude
  }
}
class City: Location, Named {
  var name: String
  init(name: String, latitude: Double, longitude: Double) {
    self.name = name
    super.init(latitude: latitude, longitude: longitude)
  }
}
func beginConcert(in location: Location & Named) {
  print("Hello, \\(location.name)!")
}

let seattle = City(name: "Seattle", latitude: 47.6, longitude: -122.3)
beginConcert(in: seattle)
// "Hello, Seattle!" 를 인쇄함

▶️ 코드 설명

beginConcert(in: ) 함수가 취하는 매개변수의 타입은 Location & Named 인데, 이는 Location 하위 클래스이면서, Named 프로토콜을 준수하는 어떤 타입이라는 뜻이다. 이 경우 City는 필수조건 둘 다를 만족한다.

beginConcert(in: ) 함수에 birthdayPerson을 전달하는 것은 무효화 되는데, Person 은 Location의 하위클래스가 아니기 떄문이다~

마찬가지로 Location의 하위 클래스를 만들었는데, Named 프로토콜을 준수하지 않으면 그 타입의 인스턴스를 가지고 beginConcert(in: )을 호출하는것도 무효화 된다.

---

 

프로토콜 준수성 검사하기

이전섹션인 Chap.19 type casting 에서 설명한 is, as 연산자를 사용해서 프로토콜 준수성을 검사하고, 특정 프로토콜로 변환할 수 있다. 프로토콜 검사 및 변환은 타입 검사 및 변환과 정확하게 동일한 구문을 따른다.

• is 연산자는 인스턴스가 프로토콜을 준수하면 true 를 반환하고 그렇지 않으면 false 를 반환한다.
• as? 버전의 내림 변환 연산자는 프로토콜 타입의 옵셔널 값을 반환하며, 인스턴스가 그 프로토콜을 준수하지 않으면 이 값이 nil 이다.
• as! 버전의 내림 변환 연산자는 프로토콜 타입으로 강제로 내림 변환하며 내림 변환이 성공하지 않으면 실행 시간 에러를 발생시킨다.

아래 코드는 단일 속성 필수 조건으로, area라는 gettable Double 속성을 가진 HasArea 라는 프로토콜을 정의한 것이다.

protocol HasArea {
  var area: Double { get }
}

Circle과 Country라는 두 클래스 모두 HasArea 프로토콜을 준수한다.

class Circle: HasArea {
  let pi = 3.1415927
  var radius: Double
  var area: Double { return pi * radius * radius }
  init(radius: Double) { self.radius = radius }
}
class Country: HasArea {
  var area: Double
  init(area: Double) { self.area = area }
}

▶️ 코드 설명

• Circle 클래스
  • radius 저장 프로퍼티에 기초한 계산 프로퍼티로 area속성 필수 조건을 구현한다.
• Country클래스
  • 저장 프로퍼티로 직접 area필수 조건을 구현한다.
• 두 클래스 모두 HasArea 프로토콜을 올바르게 준수한다.

Animal 이라는 HasArea프로토콜을 준수하지 않는!! 클래스를 정의해보자.

class Animal {
  var legs: Int
  init(legs: Int) { self.legs = legs }
}

Circle, Country, Animal 클래스는 기초 클래스를 제공하지 않는다. 그럼에도 불구하고 모두 클래스라서, 저장 값 타입이 AnyObject 인 배열을 초기화하는데 세 타입의 인스턴스 모두를 사용할 수 있다.

let objects: [AnyObject] = [
  Circle(radius: 2.0),
  Country(area: 243_610),
  Animal(legs: 4)
]

Objects 배열을 초기화하는 배열 글자 값은 반지름이 2인 Circle 인스턴스, 제곱 키로미터 단위의 영국 국토 면적으로 초기화한 Country 인스턴스, 네 발 달린 Animal 인스턴스를 담고있다.

이제 objects 배열을 반복하고, 배열 안의 각 객체를 검사하여 HasArea 프로토콜을 준수하는지 확인해보자.

for object in objects {
  if let objectWithArea = object as? HasArea {
    print("Area is \\(objectWithArea.area)")
  } else {
    print("Something that doesn't have an area")
  }
}
// Area is 12.5663708
// Area is 243610.0
// Something that doesn't have an area

▶️ 코드 설명

배열 안의 객체가 HasArea 프로토콜을 준수할 때마다 as? 연산자가 반환한 옵셔널 값을 옵셔널 연결로 풀고 objectWithArea라는 상수에 넣는다. objectWithArea 상수 타입은 HasArea임을 알고 있어서, 자신의 area 속성에 타입-안전하게 접근하고 인쇄할 수 있다.

casting(변환)과정에서 실제 객체가 바뀌는 것은 아님을 기억하자. 이들은 계속 Circle, Country, Animal 이다. 하지만 objectWithArea 상수에 저장한 시점에는 타입이 HasArea라는 것만 알아서, 자신의 area 속성에만 접근 가능 하다.

---

 

옵셔널 프로토콜 필수 조건

프로토콜을 위한 옵셔널 필수 조건을 정의할 수 있다. 이 필수조건들은, 프로토콜을 준수하는 타입이 구현되지 않아도 된다. ‘옵셔널 필수 조건'은 프로토콜 정의에서 접두사로 ‘optional’ 키워드를 붙인다. ‘옵셔널 필수조건'은 objective-c 와 상호 호환되는 코드를 작성하기 위하여 사용된다. ‘프로토콜'과 ‘옵셔널 필수조건'은 둘 다 반드시 ‘@objc’ 특성을 표시해야한다. objective-c클래스나 다른 @objc 클래스를 상속한 클래스만이 ‘@objc 프로토콜'을 채택할 수 있다는 것을 기억하자. 구조체나 열거형은 이를 채택할 수 없다.

‘옵셔널 필수 조건'에서 메서드나 프로퍼티를 사용할 때, 그 타입은 자동으로 ‘옵셔널’이 된다. 예를들어 **(Int) -> String** 타입의 메서드는 **((Int) -> String)?** 이 된다는 것이다. 메서드 반환값이 아니라, ‘전체 함수 타입'을 옵셔널로 포장한다는 것을 기억하자.

‘옵셔널 프로토콜 필수 조건'은 프로토콜을 준수하는 타입이 필수 조건을 구현하지 않을 가능성을 위해 ‘옵셔널 체이닝'을 가지고 호출할 수 있다. someOptionalMethod?(someArgument)와 같이 호출될 때 메서드 이름 뒤에 물음표를 넣어 옵셔널 메서드의 구현을 확인한다. (옵셔널 체이닝에 대한 내용은 이전 섹션 chap.16 을 확인하자.)

다음 예제에서는 외부 데이터 소스를 사용하여 increment(증가량)를 제공하는 Counter라는 정수 계산 class를 정의할 것이다. 이 데이터 소스는 두 가지 선택적 요구사항이 있는 CounterDataSource 프로토콜에 의해 정의된다.

@objc protocol CounterDataSource {
  @objc optional func increment(forCount count: Int) -> Int
  @objc optional var fixedIncrement: Int { get }
}

CounterDataSource 프로토콜은 incremental(forCount:) 라는 ‘옵셔널 메소드 필수 조건’ 과 fixedIncrement 라는 ‘옵셔널 속성 필수 조건’ 을 정의한다. 이 필수 조건들은 데이터 소스가 Count 인스턴스에 적절한 증가량을 제공하기 위한 서로 다른 두 방식을 정의한다.

▶️ Note

엄밀히 말하면 protocol 요구사항을 구현하지 않아도 CounterDataSource protocol을 준수하는 class를 만들 수 있다. 요구사항이 모두 옵셔널이기 때문이다. 물론 굳이 그럴 필요는 없다.

아래에서 정의한 Counter 클래스는, CounterDataSource? 타입의 ‘옵셔널 dataSource 속성'을 가진다.

class Counter {
  var count = 0
  var dataSource: CounterDataSource?
  func increment() {
    if let amount = dataSource?.increment?(forCount: count) {
      count += amount
    } else if let amount = dataSource?.fixedIncrement {
      count += amount
    }
  }
}

▶️ 코드 설명

• Counter 클래스
  • 현재 값을 count 라는 변수에 저장
  • 매 번 메서드를 호출할 때마다 count 속성을 증가시키는 increment 라는 메서드를 정의
• increment() 메서드
  • 증가량을 가져오기 위해 먼저 데이터 소스에 대한 incremental(forCount: )메서드가 구현됐는지 찾으려고 한다.
  • increment()메서드는 increment(forCount; )호출을 시도하기 위해 ‘옵셔널 체이닝'을 사용하며 메서드 단일인자로 현재의 count 값을 전달한다.
    • 여기에서 사용된 optional 체이닝 설명
      1. dataSource가 nil일 가능성이 있으므로, dataSource 가 nil이 아닐 때만 incremental(forCount: )가 호출돼야 함을 지시하도록 dataSource 뒤에 ?를 붙임
      2. dataSource가 존재할 지라도, 옵셔널 필수 조건이기 때문에 increment(forCount: )를 구현한다는 보장이 없다. 따라서 increment(forCount: )가 구현되어 있지 않을 가능성도 옵셔널 체이닝에 의해 처리된다. increment(forCount:) 에 대한 호출은 increment(forCount:) 가 존재하는 경우에만 발생한다. 이것이 increment(forCount:) 도 이름 뒤에 물음표가 있는 이유이다.
    • 이러한 두 가지 이유로 인해 increment(forCount: )호출이 실패할 수 있으므로 increment(forCount: )는 옵셔널 Int값을 반환한다. increment(forCount: )가 CounterDataSource의 정의에서 옵셔널이 아닌 Int값을 반환하도록 되어 있더라도 마찬가지이다. 두 개의 옵셔널 체이닝이 차례대로 있지만 결과는 하나의 옵셔널로 래핑된다.
  • increment(forCount: )를 초루한 뒤 반환하는 옵셔널 Int 는 옵셔널 바인딩을 사용하여 amount라는 상수로 래핑 해제 된다. 옵셔널 Int 값이 있으면 래핑 되지 않은 금액이 count 프로퍼티에 추가되고 증가가 완료된다.

dataSource가 nil이거나 increment(forCount:)를 구현하지 않아 increment(forCount:)의 값을 얻을 수 없는 경우 increment() 메서드는 dataSource의 fixedIncrement 프로퍼티에서 값을 가져오려고 한다.  fixedIncrement 프로퍼티도 옵셔널 요구사항이므로 해당 값이  CounterDataSource protocol에서 Int 타입으로 정의되어 있더라도 해당 값은 옵셔널 Int 타입이다.

다음 코드는 dataSource가 쿼리 될 때마다 상수 값 3을 반환하는 간단한 CounterDataSource 를 구현한 것이다 . 이는 옵셔널 요구사항인 fixedIncrement 프로퍼티를 구현한다.

class ThreeSource: NSObject, CounterDataSource {
  let fixedIncrement = 3
}

ThreeSource의 인스턴스를 새로운 Counter 인스턴스를 위한 데이터 소스로 사용할 수 있다.

var counter = Counter()
counter.dataSource = ThreeSource()
for _ in 1...4 {
  counter.increment()
  print(counter.count)
}
// 3
// 6
// 9
// 12

위 코드는 새로운 Counter 인스턴스를 생성하여 데이터 소스로 새로운 ThreeSource 인스턴스를 설정하며, counter의 increment()메서드를 네 번 호출한다. Counter의 count 속성은 increment()를 호출할 때마다 3씩 증가한다.

다음은 Counter인스턴스를 현재 count값에서 ‘0’으로 위로 세거나, 아래로 세는 TowardsZeroSource라는 조금 더 복잡한 데이터 소스이다.

class TowardsZeroSource: NSObject, CounterDataSource {
  func increment(forCount count: Int) -> Int {
    if count == 0 {
      return 0
    } else if count < 0 {
      return 1
    } else {
      return -1
    }
  }
}

TowardsZeroSource클래스는 CounterDataSource프로토콜에 있는 옵셔널 increment(forCount: )메서드를 구현하며 어느 방향으로 셀지 알아내기 위해 count 인자 값을 사용한다. count가 이미 ‘0’이면 더 이상 세지 말아야 함을 지시하기 위해 메서드가 0을 반환한다.

-4에서 ‘0’까지 세기 위해 기존 Counter인스턴스와 TowardsZeroSource의 인스턴스를 같이 사용할 수 있다. Counter가 ‘0’에 닿으면 더 이상 세지 않는다.

counter.count = -4
counter.dataSource = TowardsZeroSource()
for _ in 1...5 {
  counter.increment()
  print(counter.count)
}
// -3
// -2
// -1
// 0
// 0

---

 

Protocol Extensions (프로토콜 익스텐션)

프로토콜은 메서드, 생성자, 서브 스크립트, 계산 프로퍼티 구현을 자신을 채택한 타입에게 제공하려면 extension을 사용하면 된다. 이를 통해 각 타입의 적하성, 전역함수가 아닌 프로토콜 자체에 대한 동작을 정의할 수 있다.

예를들어, RandomNumberGenerator 프로토콜에 extension을 사용하여 randomBool() 메서드를 제공하도록 할 수 있다. 이 메서드는 필수적인 random() 메서드의 결과를 사용하여 임의의 Bool 값을 반환한다.

extension RandomNumberGenerator {
  func randomBool() -> Bool {
    return random() > 0.5
  }
}

프로토콜에 대한 익스텐션을 생성함으로써 모든 준수 타입은 어떤 추가적인 수정 없이도 이 randomBool() 메서드를 사용할 수 있게 된다.

let generator = LinearCongruentialGenerator()
print("Here's a random number: \\(generator.random())")
// "Here's a random number: 0.3746499199817101" 를 인쇄합니다.
print("And here's a random Boolean: \\(generator.randomBool())")
// "And here's a random Boolean: true" 를 인쇄합니다.

프로토콜 익스텐션은 준수 타입에 구현을 추가할 순 있지만, 프로토콜을 확장하도록 만들거나, 다른 프로토콜을 상속하게 할 수는 없다. 프로토콜 상속은 프로토콜 선언 그 자체에서만 가능하다.

 

기본 구현 제공하기

프로토콜 익스텐션을 사용해서 해당 프로토콜이 요구하는 모든 메서드 또는 계산 프로퍼티에 대한 기본 구현을 제공할 수 있다. 자신을 채택한 타입이 요구사항을 이미 구현한 경우에는, 프로토콜 익스텐션에서 구현한 것 말고 해당 타입 내에서 구현한 것이 사용된다.

▶️ Note

익스텐션에서 프로토콜의 요구사항을 구현하는 것은 옵셔널 프로토콜 요구사항과는 다르다. 채택한 타입이 자체적으로 요구사항을 구현할 필요는 없지만, 이미 프로토콜 익스텐션에 구현이 되어있으므로 옵셔널 체이닝 없이 바로 사용할 수 있다.

 

예를들어, TextRepresentable 프로토콜을 상속하는 PrettyTextRepresentable 프로토콜은 prettyTextualDescription 프로퍼티의 default 구현을 제공하여 단순하게 textualDescription프로퍼티에 접근한 결과를 반환할 수 있다.

extension PrettyTextRepresentable {
  var prettyTextualDescription: String {
    return textualDescription
  }
}

 

프로토콜 익스텐션에 Constraints (제약 조건) 추가하기

프로토콜 익스텐션을 정의할 때, 해당 타입이 익스텐션의 메서드와 프로퍼티를 사용할 수 있기 전에 충족해야하는 제약조건을 지정할 수 있다. 제네릭 where절을 사용하여 extension을 사용할 프로퍼티 이름 뒤에 제약조건을 작성할 수있다. generic where절에 대한 자세한 내용은 바로 다음장, chap.23 Generic Where Clauses 에서 배워보자.

예를들어 Element가 Equatable 프로토콜을 준수하는 모든 컬렉션에만 적용되는 프로토콜 익스텐션을 정의할 수 있다. 컬렉션의 element를 표준 라이브러리의 일부인 Equatable 프로토콜로 제한하면 ==, != 연산자를 사용하여 두 Element간 비교를 할 수있다.

extension Collection where Element: Equatable {
  func allEqual() -> Bool {
    for element in self {
      if element != self.first {
        return false
      }
    }
    return true
  }
}

allEqual() 메서드는 컬렉션의 모든 Element가 동일한 경우에만 true를 반환한다. 두 개의 Int Array에 직접 사용해보자. 하나는 다른 모든 Element가 동일하지만 다른 하나는 그렇지 않다.

let equalNumbers = [100, 100, 100, 100, 100]
let differentNumbers = [100, 100, 200, 100, 200]

Int 타입은 Equatable을 준수하기 때문에 equalNumbers, differentNumbers는 allEqual() 메서드를 사용할 수 있다.

print(equalNumbers.allEqual())
// "true" 를 인쇄합니다.
print(differentNumbers.allEqual())
// "false" 를 인쇄합니다.

▶️ Note

어떤 타입이 동일한 메서드, 프로퍼티에 대한 구현을 제공하는 여러 개의 제약된 extension의 조건을 만족하는 경우 Swift는 가장 specialezed 한 제약조건에 해당하는 구현을 사용한다.