WWDC 2015 세션중 "Protocol-Oriented Programming in Swift" 라는 흥미로운 세션이 있습니다. 애플에서 Standard Library 그룹의 리더를 맡고 있는 Dave Abrahams 라는 분이 발표한 세션입니다. 세션에서 제공하는 슬라이드와 InfoQ에서 이 세션을 정리한 아티클을 바탕으로 내용을 요약했습니다.

• WWDC 2015, Protocol-Oriented Programming in Swift
• InfoQ 아티클

클래스는 멋집니다!

다음과 같은 멋진 특징들을 제공하지요.

• 캡슐화 (Encapsulation)
• 접근제어 (Access Cotrol)
• 추상화 (Abstraction)
• 네임스페이스 (Namespace)
• 풍부한 문법 (Epressive Syntax)
• 확장성 (Extensibility)

그런데...

구조체로도 다 할수 있습니다.

클래스는 훌륭합니다. 타입은 훌륭합니다!

사실 위 특징들은 모든 타입들의 특징이며 클래스는 그것을 구현하는 하나의 방법에 불과합니다. 그렇다면 클래스 사용으로 인한 단점은 무엇이 있을까요?

1. 암묵적인 참조(Reference) 공유

• 두 객체가 동시에 어떤 객체를 참조하는 경우, 서로 그 사실을 모른채 그 객체를 변경할 수 있습니다.
• 참조 공유를 방지하기 위해 참조하는 객체를 복사할 수 있지만, 그렇게 하면 효율성이 나빠집니다.
• 참조를 공유하는 객체에 Race Conditions 이 발생할 수도 있습니다.
• Lock을 사용하여 레이스 컨디션을 방지할수 있지만 효율성은 더 나빠집니다.
• Lock을 잘못 사용하면 Deadlock 상태에 빠질 수 있습니다.
• 잦은 Lock 사용은 코드를 복잡하게 합니다.
• 복잡성은 더 많은 버그를 유발합니다.

Values Don't Share. (That's a good thing)

2. 상속 (비지니스에 관한 모든 것을 가지고 있습니다.)

• 슈퍼 클래스를 하나 밖에 가질수 없기 때문에, 초기에 잘 선택해야합니다.
• 슈퍼 클래스를 나중에 변경하는 것은 매우 어렵습니다.
• 슈퍼클래스가 갖는 모든 저장속성은 서브클래스에도 (강제적으로) 상속됩니다.
• 초기화 처리가 복잡해집니다.
• 수퍼클래스의 불변성을 깨뜨리지 않을수 없게됩니다.
• 언제 무엇을, 어떻게 재정의해야 하는지 (수퍼 클래스에 대해서)알아야 합니다.

More and more, we promote delegation.

3. 타입관계를 잃어버립니다.(Lost Type Relationships.)

• 추상 수퍼클래스와 서브클래스의 구현코드가 함께 존재하게 됩니다.

• 서브클래스 메소드에 접근하기 위해 수퍼클래스를  서브클래스로 다운캐스팅하면서 타입관계를 잃게됩니다.

• 이진탐색 클래스 모델 Ordered 정의

class Ordered {
    func precedes(other: Ordered) -> Bool { fatalError("메소드를 구현해주세요.") }
}

class Number:Ordered {
    var value:Double = 0
    override func precedes(other: Ordered) -> Bool {
        return value < (other as! Number).value // 
    }
}  

func binarySearch(sortedKeys: [Ordered], forkey k: Ordered) -> Int {
    var lo = 0
    var hi = sortedKeys.count
    while hi > lo {
        let mid = lo + (hi - lo) / 2
        if sortedKeys[mid].precedes(k) { lo = mid + 1 }
        else { hi = mid }
    }
    return lo
}

as! ASubclass 는 타입 관계를 잃어버렸다는 신호
대부분 추상화를 위해 클래스를 사용하기 때문이다.

4. 좋은 추상화 메커니즘이란?

• Value type을 지원합니다.(클래스 외에도)
• 정적 타입관계를 지원합니다. (동적 디스패치 외에도)
• 큰 덩어리로 뭉치지 않아야합니다.
• Retroactive 모델링을 지원합니다.
• 모델에 인스턴스 데이터를 강요하지 않아야 합니다.
• 모델에 초기화의 부담이 없어야 합니다.
• 무엇을 구현해야 하는지 명확해야 합니다.

Swift는 프로토콜 지향 프로그래밍 언어!

5. 프로토콜 지향 프로그래밍

• Swift에서 새롭게 추상화를 생각할 때 첫 번째 포인트는 프로토콜!

이진탐색 프로토콜 모델 Ordered 변경해보겠습니다.

protocol Ordered {
    func precedes(other:Self) -> Bool
}    

struct Number : Ordered {
    var value:Double = 0
    func precedes(other:Number) -> Bool {
        return self.value < other.value 
    }
}

이진탐색 함수를 정의합니다.

func binarySearch<T:Ordered>(sortedKeys:[T], forKey k: T) -> Int {
    var lo = 0
    var hi = sortedKeys.count
    while hi > lo {
        let mid = lo + (hi-lo)/2 
        if sortedKeys[mid].precedes(k) { lo = mid + 1 }
        else { hi = mid }
    }
    return lo
}

Int 배열에 이진탐색 함수를 적용해 보겠습니다.

• 먼저 Int가 프로토콜 Ordered를 구현해야합니다.

// Int형 Ordered 프로토콜 구현하기 

extension Int:Ordered {
    func precedes(other: Int) -> Bool {
        return self < other
    }
}

• Int 배열에 이진탐색을 적용합니다.

// 1. 키 정렬 
var keys = [10, 30, 1, 4, 5, 6, 7, 8, 55, 20]
var sortedKeys = keys.sorted {  $0 < $1 }
// sortedKeys: [1, 4, 5, 6, 7, 8, 10, 20, 30, 55]

// 2. 찾을 키
var searchKey = 30
// 키 30의 index는 8.

// 3. 이진탐색 
var searchIndex = binarySearch(sortedKeys, forkey: searchKey)
// searchIndex: 8

Number 배열에도 이진탐색을 적용해보겠습니다.

// 1. 정렬된 Number 배열 생성  
var numbers = sortedKeys.map { return Number(value: Double($0)) }
// numbers: [1.0, 4.0, 5.0, 6.0, 7.0, 8.0, 10.0, 20.0, 30.0, 55.0]

// 2. 찾을 키
var keyToSearch = 5.0

// 3. 이진탐색
var index = binarySearch(numbers, forkey: Number(value: keyToSearch))
// index: 2

프로토콜을 사용하면, 커스텀 Number 구조체 뿐만 아니라 기존 타입에도 이진탐색을 쉽게 적용할 수 있음을 알 수 있습니다.

Swift Language Changes

• payload를 가진 Enum case들은 함수처럼 사용될수 있습니다.

 enum Either<T, U> { 
    case Left(T), Right(U) 
 }
 let lefts: [Either<Int, String>] = [1, 2, 3].map(Either.Left)
 let rights: [Either<Int, String>] = [“one”, “two”, “three”].map(Either.Right) 
 // => {{Left 1}, {Left 2}, {Left 3}}

• 구조체, enum, 프로토콜의 non-mutationg 메소드들에 부분적으로 self 파라미터가 적용됩니다.

let a: Set<Int> = [1, 2, 3]
let b: [Set<Int>] = [[1], [4]]
b.map(a.union)   
// => [[1, 2, 3], [1, 2, 3, 4]]

• 정적타입 참조 또는 타입객체에 static 메소드처럼 .init를 사용하여 생성자를 초기화함수에 접근할 수 있습니다.

let x = String.init(5)
let stringType = String.self
let y = stringType.init(5)
let oneTwoThree = [1, 2, 3].map(String.init).reduce(“”, combine: +)  
// => "123"

• String(5) 처럼 정적타입을 사용해서 생성할때도 여전히 .init은 암묵적으로 호출됩니다. .init은 동적타입 객체를 사용할 때, 함수인자로 initializer를 참조할 때 사용됩니다.

• 거대한 구조체 또는 enum 타입의 코드를 생성할 때 코드 크기를 감소시키도록 개선되었습니다.

• 이제 Swift는 assertion이 활성화 된채 빌드됩니다. 실용적인 crash report를 생성하는데 도움이 될것입니다.

• 실행결과

Indexing and Slicing Strings

Swift string의 Indexing과 Slicing 대해서 알아보겠습니다.
string은 화면에 보여지는 문자들의 순서집합이라고 생각하는 것이 일반적입니다.
하지만 하나의 문자로 보일지라도 메모리 상에서는 다중 혹은 가변길이의 유니코드값으로 표현되는 경우도 있습니다.

유니코드 문자열

예를 들어 hat emoji (🎩)는 문자 a와 같은 문자보다 인코딩에 더 많은 비트가 필요로합니다.
Swift의 String 타입은 이러한 세부사항들을 처리해줍니다. string을 이루는 각 문자는 (메모리에서 차지하는 길이와는 상관없이)
사용자가 인식하는 유니코드 문자를 표현합니다. 이런 추상화 때문에 정수를 사용해서 string의 인덱스를 표현하는 것이 적합하지
않을수 있습니다.

대신 표준라이브러리는 string에서의 위치를 표현하기에 적합한 String.Index를 제공합니다.

문자열 카운팅

다음 문자열은 가변길이의 유니코드 문자들로 구성되어 있습니다.

var str = "Héllo, 🇺🇸laygr😮und!"

// str의 유니코드 문자의 개수: 18
str.characters.count  // swift2.0
count(str)            // swift1.2

// str의 UTF-16코드 포인트의 개수: 22
str.utf16.count      // swift2.0
count(str.utf16)     // swift1.2

깃발 (🇺🇸) 문자는 사실 2개의 유니코드 스칼라값이 결합되어 구성되지만 Swift는 1개의 문자로 카운팅합니다.
이런 특성이 폼 유효성 검사, 커서 포지셔닝, 텍스트 wrapping 구현을 더 쉽게합니다.
문자열 카운팅, 인덱싱, 슬라이싱은 모두 메모리가 아닌 사용자가 인식하는 문자 인덱스를 기반으로 하고있습니다.

문자열 slicing

string을 index하고 slice하는데 사용하는 Range 값을 생성해보겠습니다.

let badRange = 4..<12   // Range<Int>를 생성합니다.

str[badRange]   // error: 'subscript' is unavailable: cannot subscript String with range of Int

위 코드는 정수형을 string의 인덱스로 사용할수 없다는 컴파일 에러를 발생시킵니다.

대신 다음과 같이 String.Index 객체를 사용할 수 있습니다.

let range = advance(str.startIndex, 4)..<advance(str.startIndex, 12)

string은 startIndex 와 endIndex 속성을 갖습니다.
string의 successor(), predecessor() 함수(swift2.0에서 지원)는 인덱스를 증가 또는 감소시킵니다.

advance() 함수를 사용하여 파라미터의 값만큼 offset를 이동할수 있으며, advance()함수는 인자로 전달받은 offset 만큼 successor(),predecessor()를 호출합니다.

String.Index 타입은 유니코드를 인식할수 있어서 advance()함수가 항상 string index를 적절하게 이동시킬 수 있습니다.

advance() 함수는 인자로 받은 index 타입과 동일한 타입의 값을 반환하기 때문에 ..< range 연산자는 그 타입에 해당하는 range를
생성할수 있습니다.

advance() 함수를 사용하여 string의 특정 index의 문자를 조회해보겠습니다.

str[advance(str.startIndex, 7)] // 🇺🇸를 반환한다.
str[range.startIndex]            // o를 반환한다.
str[range.endIndex]              // 😮를 반환한다.
str[range]                       // o, 🇺🇸laygr를 반환한다.

advance() 함수

또 다른 버전의 advance()함수를 사용해서 메시지를 10자로 제한하는 기능을 구현해보겠습니다.

let messageCharacterLimit = 10
let range = advance(str.startIndex, messageCharacterLimit , str.endIndex)..<advance(str.endIndex, 0)
let result = str.substringWithRange(range)
if result.isEmpty {
    print("empty result")
}
// "ygr😮und!"를 출력합니다.

advance()함수는 startIndex, offset 외에 세번째 파라미터로 endIndex를 전달하면 offset이 endIndex를 초과하는 경우
end.Index를 반환해줍니다. 세번째 인자는 일종의 상한값으로 동작합니다.