Swift Advanced Operators

1. Advanced Operators 👩‍💻

Swift 는 C나 Objective-C와 유사한 Bitwise Operators를 포함해 여러 고급 연산자를 제공한다. Swift 는 C 의 Arithmetic Operators 와 달리 기본적으로 Overflow 되지 않는다. Overflow 는 trapped되어 에러로 보고된다.
Swift 에서 Overflow 행동을 하도록 하려면 Overflow Addition Operator($+)와 같은 연산자를 사용해야한다 (모든 Overflow Operators는 &로 시작한다).

Custom Classes, Structures, Enumerations 를 정의할 때, Custom Types 에 대해 Standard Swift Operators 의 구현을 제공하는 것이 유용할 수 있다. Swift 는 Custom Types 에 대해 Custom Operators 를 손쉽게 제공할 수 있도록 하며, 각 Types 에 대한 행동이 정확히 무엇인지 결정할 수 있다.

Custom Operators 는 사전에 정의된 Operators 로 제한되지 않으며, Swift 는 자신만의 Infix, Prefix, Assignment Operators를 정의함은 물론, 자신만의 우선순위를 자유롭게 정의할 수 있다. 이러한 Custom Operators 는 코드에서 Swift 가 기본적으로 제공하는 Predefined Operators 처럼 사용되며, Custom Operators 를 채택하도록 기존의 Types 를 확장할 수 있다.

---

2. Bitwise Operators 👩‍💻

1. Bitwise Operators

Bitwise Operators 는 Data Structure 내에서 개별 Raw Bits를 조작할 수 있게 해준다. 이것은 Graphics Programming 이나 디바이스 드라이버 생성 같은 Low-Level Programming 에서 주로 사용된다. 또한 외부 소스로부터 Custom Protocol 을 사용해 통신하는 데이터 Encoding/Decoding 작업에 사용하기도 한다. Swift 는 C 가 갖고 있는 모든 Bitwise Operators 를 지원한다.

func printToBinary(number: UInt8) {
    print(toBinary(number))

    func toBinary(_ number: UInt8) -> String {
        let binary = String(number, radix: 2)
        if binary.count < number.bitWidth {
            return String(repeating: "0", count: 8 - binary.count) + binary
        } else {
            return binary
        }
    }
}

위 함수를 만들고 비트 연산 결과를 확인해보자.

2. Bitwise NOT Operator ~

Bitwise NOT Operator ~는 Prefix Operator로 공백 없이 값 바로 앞에 위치해 숫자의 모든 비트를 반전시킨다.

let initialBits: UInt8 = 0b00001111
let invertedBits = ~initialBits
printToBinary(number: invertedBits) // 11110000

UInt8 정수는 8비트를 가지며 0 ~ 255 사이의 숫자를 저장할 수 있으며, 2진수 00001111로 이루어진 8비트 데이터 (10진수로 15와 같음)에 ~ Operator 를 적용해 2진수 11110000(10진수로 240과 같음)이 되었다.

3. Bitwise AND Operator &

Bitwise AND Operator &는 두 값 사이에 위치해 연산된 값을 반환한다. 비트의 각 자릿수가 모두 1이면 1을, 그 외에는 0을 반환한다.

let firstSixBits: UInt8 = 0b11111100
let lastSixBits: UInt8 = 0b00111111
let middleFourBits = firstSixBits & lastSixBits
printToBinary(number: middleFourBits)   // 00111100

2진수 11111100과 00111111에 & Operator 를 적용해 2진수 00111100이 되었다.

4. Bitwise OR Operator |

Bitwise OR Operator |는 두 값 사이에 위치해 연산된 값을 반환한다. 비트의 각 자릿수가 모두 0이면 0을, 그 외에는 1을 반환한다.

let someBits: UInt8 = 0b10110010
let moreBits: UInt8 = 0b01011110
let combinedBits = someBits | moreBits
printToBinary(number: combinedBits) // 11111110

2진수 10110010과 01011110에 | Operator 를 적용해 2진수 11111110이 되었다.

5. Bitwise XOR Operator ^

Bitwise XOR Operator(=Exclusive OR Operator) ^는 두 값 사이에 위치해 연산된 값을 반환한다. 비트의 각 자릿수가 서로 같으면 0을, 다르면 1을 반환한다.

let firstBits: UInt8 = 0b00010100
let otherBits: UInt8 = 0b00000101
let outputBits = firstBits ^ otherBits
printToBinary(number: outputBits)   // 00010001

2진수 00010100과 00000101에 ^ Operator 를 적용해 2진수 00010001이 되었다.

6. Bitwise Left and Right Shift Operators << >>

Bitwise Left Shift Operator <<는 모든 비트를 왼쪽으로 이동시키며 정수를 2배로 곱하는 효과가 있고, Bitwise Right Shift Operator >>는 모든 비트를 오른쪽으로 이동시키며 정수를 반으로 나누는 효과가 있다.

1 ) Shifting Behavior for Unsigned Integers

부호 없는 정수의 Bit-Shifting 행동은 다음과 같다.

• 기존의 비트를 요청된 숫자만큼 왼쪽 또는 오른쪽으로 이동시킨다.
• 정수의 저장 범위(UInt8 정수는 8비트를 가지며 0 ~ 255 사이의 숫자를 저장)를 넘는 비트는 제거된다.
• 비트 이동으로 빈 공간에 0이 삽입된다.

let shiftBits: UInt8 = 4
printToBinary(number: shiftBits)        // 00000100
printToBinary(number: shiftBits << 1)   // 00001000
printToBinary(number: shiftBits << 2)   // 00010000
printToBinary(number: shiftBits << 5)   // 10000000
printToBinary(number: shiftBits << 6)   // 00000000
printToBinary(number: shiftBits >> 2)   // 00000001

다음 예제는 16진수 Cascading Style Sheets 색상값을 각각 RGB 로 분리하는 연산을 수행한다.

let pink: UInt32 = 0xCC6699
let redComponent = (pink & 0xFF0000) >> 16    // redComponent is 0xCC, or 204
let greenComponent = (pink & 0x00FF00) >> 8   // greenComponent is 0x66, or 102
let blueComponent = pink & 0x0000FF           // blueComponent is 0x99, or 153

16진수 Cascading Style Sheets 색상값을 저장하기 위해 UInt32 상수를 사용했고 저장된 색상은 분홍색이다.

• 빨간색을 분리하기 위해 분홍색에 빨강색의 자릿값 0xFF0000을 & 연산한 다음 오른쪽으로 16비트를 이동시킨다.
• 녹색을 분리하기 위해 분홍색에 녹색의 자릿값 0x00FF00을 & 연산한 다음 오른쪽으로 8비트를 이동시킨다.
• 파란색을 분리하기 위해 파랑색의 자릿값 0x0000FF을 & 연산했고 자릿값 이동이 필요 없어 그대로 종료했다.

2 ) Shifting Behavior for Signed Integers

부호 있는 정수의 Bit-Shifting 행동은 이진으로 표현되는 방법 때문에 부호 없는 정수보다 더 복잡하다(다음 예제는 단순화를 위해 8비트의 부호 있는 정수를 사용하지만 동일한 원칙이 모든 부호 있는 정수에 적용된다).

부호 있는 정수는 첫 번째 비트를 부호로 사용한다. 이를 Sign Bit로 0은 양수를, 1은 음수를 표현한다. 그리고 나머지 비트는 Value Bits로 실제 값을 저장한다. 양수일 때는 부호 없는 정수와 동일한 방식을 사용한다.

부호 있는 정수의 +4

하지만 음수의 경우 우리가 직관적으로 사용하는 부호 + 절대값 숫자의 형태를 띄지 않는다. +4, -4 이런 식의 표현은 사람에게 쉽고 익숙한 것이지 컴퓨터 친화적이지 않기 때문이다. 컴퓨터는 Binary 로 데이터를 다루기 때문에 2의 보수를 사용해 표현한다.

부호 있는 정수의 -4

2진수가 가질 수 있는 보수는 2의 보수와 1의 보수다.

1. 2진수 양수 +4는 00000100이다.
2. +4의 1의 보수는 11111111 - 00000100 = 111110110이다.
3. +4의 2의 보수는 1의 보수에 1을 더해 111110110 + 00000001 = 11111100이 된다.

부호 있는 정수의 -4는 Sign Bit 1과 Value Bits 1111100으로 이루어진다. 10진수에서 이 값은 124를 갖는다. 따라서, 부호 있는 정수의 음수 표현은 2의 보수를 사용해 음수를 표현하는 Sign Bit와 2의 보수로 표현되는 Value Bits 128 - 4를 표현 방식으로 사용하고 있음을 확인할 수 있다. 이를 Two's Complement Representation(2의 보수 표현)이라 부른다.

2의 보수 표현을 사용하면 컴퓨터 연산에 여러 장점을 가질 수 있다.

• -1 + -4와 같은 연산을 단순히 표준 이진 덧셈으로 다룰 수 있다.

2의 보수로 표현된 -4와 -1을 표준 이진 덧셈 연산을 한 후 정수의 저장소 범위를 넘어 이동된 모든 비트를 삭제하면 손쉽게 -5의 2의 보수 표현을 얻는다.

• Bitwise Shift Operators 를 Unsigned Integers 와 유사하게 다룰 수 있다.

부호 있는 정수의 Bitwise Left Shift Operator 는 부호 없는 정수와 동일하게 행동하며 값을 2배로 늘린다.
부호 있는 정수의 Bitwise Right Shift Operator 는 부호 없는 정수와 유사하나, 비트 이동으로 빈 공간을 0으로 채우는 것이 아닌 Sign Bit 로 빈 자리를 채운다. 이것을 Arithmetic Shift라 한다.

---

3. Overflow Operators 👩‍💻

1. Overflow Operators

Swift 는 정수 상수 또는 변수에 저장할 수 없는 값을 삽입하려고 하면, 유효하지 않은 값을 생성을 허용하지 않으며 에러를 발생시킨다. 이러한 행동은 너무 크거나 작은 값을 다룰 때 추가적인 Safety 를 제공한다.

예를 들어 Int16 정수는 2^16 = 65,536 개의 값을 0을 기준으로 저장하므로 -32,768 ~ 32,767 의 값을 저장할 수 있으므로 이 범위를 초과하는 숫자를 저장하려고 하면 에러를 발생시킨다.

var potentialOverflow = Int16.max   // 32,767
potentialOverflow += 1  //  error, Swift runtime failure: arithmetic overflow

따라서 경계값 조건을 코딩할 때 에러 처리를 제공해 유연성을 높일 수 있다. 하지만 에러를 발생시키는 대신 &를 붙여 Overflow Operators를 사용할 수도 있다. Swift 는 3가지 Arithmetic Overflow Operators 를 제공한다.

• Overflow addition &+
• Overflow subtraction &-
• Overflow multplication &*

var potentialOverflow = Int16.max   // 32,767

print(potentialOverflow &+ 1)   // -32768
print(potentialOverflow &+ 2)   // -32767
print(potentialOverflow &+ 3)   // -32766

print(potentialOverflow &- 1)   // 32766

print(potentialOverflow &* 2)   // -2

2. Value Overflow

숫자는 Positive, Negative 양 방향으로 오버플로우 될 수 있다.

앞에서 정의한 printToBinary(number:) 함수를 다음과 같이 고치고 Overflow Operators 의 동작을 살펴보자.

func printToBinary<T: BinaryInteger>(number: T) {
    print("Binary: \(toBinary(number)), Decimal: \(number)")

    func toBinary(_ number: T) -> String {
        let absoluteNumber = abs(Int(number))
        let binary = String(absoluteNumber, radix: 2)
        if binary.count < 8 {
            return String(repeating: "0", count: 8 - binary.count) + binary
        } else {
            return binary
        }
    }
}

다음은 부호 없는 정수의 Positive 방향으로의 오버플로우 발생에 대한 예제다.

var unsignedOverflow = UInt8.max
printToBinary(number: unsignedOverflow)
// Binary: 11111111, Decimal: 255

unsignedOverflow = unsignedOverflow &+ 1
printToBinary(number: unsignedOverflow)
// Binary: 00000000, Decimal: 0

• 변수 unsignedOverflow 는 UInt8의 최댓값 11111111을 초깃값으로 저장한다.
• Overflow Addition Operator &+를 사용해 값을 1 증가시킨다.
• 정수의 저장 범위를 넘는 비트는 제거되고 00000000이 남게 된다.

이번에는 부호 없는 정수의 Negative 방향으로의 오버플로우 발생에 대한 예제를 알아보자.

var anotherUnsignedOverflow = UInt8.min
printToBinary(number: anotherUnsignedOverflow)
// Binary: 00000000, Decimal: 0

anotherUnsignedOverflow = anotherUnsignedOverflow &- 1
printToBinary(number: anotherUnsignedOverflow)
// Binary: 11111111, Decimal: 255

오버플로우는 Signed Integers 에서도 발생한다. 부호 있는 정수의 모든 덧셈, 뺄셈은 비트 방식으로 수행된다.

var signedOverflow = Int8.min
printToBinary(number: signedOverflow)
// Binary: 10000000, Decimal: -128

signedOverflow = signedOverflow &- 1
printToBinary(number: signedOverflow)
// Binary: 01111111, Decimal: 127

• 변수 signedOverflow 는 Int8의 최솟값 10000000을 초깃값으로 저장한다.
• Overflow Subtraction Operator &-를 사용해 값을 1 감소시킨다.
• 결과값은 부호 비트가 토글되어 양수가 되어 01111111을 저장한다.

Signed Intergers, Unsigned Integers 는 동일하게 최댓값을 넘어서면 최솟값으로, 최솟값을 넘어서면 최댓값으로 순환된다.

---

4. Precedence and Associativity 👩‍💻

연산자 우선순위(precedence)는 다른 연산자보다 높은 우선순위를 갖도록 해 먼저 적용되게 한다. 연산자 연관성(associativity)은 동일한 우선순위를 갖는 연산자들이 왼쪽과 그룹화 될지, 오른쪽과 그룹화 될지를 정의한다.

Swift 는 C 처럼 Multiplication Operator *, Division Operator /, Remainder Operator % 같은 것들은 Addition Operator +, Subtraction Operator - 같은 것들보다 더 높은 우선순위를 갖는다. 동일한 우선순위 사이에서는 왼쪽으로 그룹화 된다. 즉, 수학적 사칙연산 우선순위를 그대로 따른다.

2 + 3 % 4 * 5

따라서 위 연산은 괄호를 사용해 우선순위를 명시적으로 표현하면 다음과 같다.

2 + ((3 % 4) * 5)

(3 % 4)는 3 이므로 다음 연산은 2 + (3 * 5)가 되고, 또 다시 (3 * 5)는 15 이므로 다음 연산은 2 + 15가 되어 연산 결과는 17 이 된다.

Swift 의 Operator Precedences와 Operator Associativity Rules는 C 나 Objective-C 보다 더 간단하고 예측 가능하다. 이것은 C-based 언어와 완전히 일치하지 않음을 의미하므로, 기존 코드를 Swift 로 전환할 때 연산자 상호작용이 의도한대로 작동하는지 확인해야한다. Swift Standard Library 가 제공하는 Operators 는 Operator Declarations 에서 확인할 수 있다.

---

5. Operator Methods 👩‍💻

1. Operator Methods

Classes 와 Structures 는 기존 연산자를 Overloading 시켜 자체 구현을 제공할 수 있다.

Arithmetic Addition Operator 는 두 타겟에 작동하므로 Binary Operator이며, 두 타겟 사이에 위치하므로 Infix Operator다. 아래 예제는 Custom Structure 에서 Overloading 을 통해 Arithmetic Addition Operator +가 어떻게 구현되는지를 보여준다.

struct Vector2D {
    var x = 0.0, y = 0.0
}

extension Vector2D {
    static func + (lhs: Vector2D, rhs: Vector2D) -> Vector2D {
        Vector2D(x: lhs.x + rhs.x, y: lhs.y + rhs.y)
    }
}

Vector2D의 Type Method 로 정의된 연산자 +는 이름이 Arithmetic Addition Operator 와 일치하기 때문에 Overloading 된다. Arithmetic Addition Operator 가 Binary Operator 이며, Infix Operator 이므로 이 연산자 역시 동일한 형태로 작성되었다. 또한 덧셈 연산은 벡터의 필수 동작이 아니므로 Structures 정의 자체에 포함시키지 않고 Extensions 를 이용해 분리시켜 정의했다.

let vector = Vector2D(x: 3.0, y: 1.0)
let anotherVector = Vector2D(x: 2.0, y: 4.0)
let combinedVector = vector + anotherVector
print("Combined Vector is (\(combinedVector.x), \(combinedVector.y)).")
// Combined Vector is (5.0, 5.0).

2. Prefix and Postfix Operators

위 예제는 Binary Infix Operator의 Custom Implementation 을 보여주었다. Classes 와 Structures 는 Standard Unary Operators 와 같은 것들도 구현할 수 있다.

Unary Operators

• Single Target 을 대상으로 작동한다.
• Operator 가 타겟 앞에 위치하는 Prefix Operators, 타겟 뒤에 위치하는 Postfix Operators 2가지로 나뉜다.

Binary Operators

• Two Target 을 대상으로 작동한다.
• Operator 가 두 타겟 사이에 위치한다.

Unary Operators는 func keyword 앞에 prefix 또는 posfix modifier 를 작성해 정의한다. 다음 Operator 는 Unary Minus Operator 로 Prefix Operator 로 정의되었다.

extension Vector2D {
    static prefix func - (vector: Vector2D) -> Vector2D {
        Vector2D(x: -vector.x, y: -vector.y)
    }
}

let positive = Vector2D(x: 3.0, y: 4.0)
let negative = -positive
print("Negative Vector is (\(negative.x), \(negative.y)).")
// Negative Vector is (-3.0, -4.0).
let alsoPosotive = -negative
print("Also Positive Vector is (\(alsoPosotive.x), \(alsoPosotive.y)).")
// Also Positive Vector is (3.0, 4.0).

3. Compound Assignment Operators

Compound Assignment Operators는 연산자와 Combine Assignment =를 결합해 만든다. 예를 들어 Addition Assignment Operator +=는 단일 연산으로 덧셈과 할당을 결합한다.

Compound Assignment Operators의 left input parameter 는 Operator Method 로부터 값이 직접 수정되므로 inout이 되어야 한다.

다음은 Vector2D 의 Addition Assignment Operator 의 구현이다. 여기서 Arithmetic Addition Operator 는 Operator Methods에서 정의된 것을 사용한다.

extension Vector2D {
    static func += (lhs: inout Vector2D, rhs: Vector2D) {
        lhs = lhs + rhs
    }
}

var original = Vector2D(x: 1.0, y: 2.0)
let vectorToAdd = Vector2D(x: 3.0, y: 4.0)
original += vectorToAdd
print("Original Vector is (\(original.x), \(original.y)) now.")
// Original Vector is (4.0, 6.0) now.

4. Equivalence Operators

기본적으로 Custom Classes 와 Structures 는 Equivalence Operators ==와 !=를 구현을 갖지 않는다. 따라서 이를 구현할 때는 일반적으로 == 연산자를 구현하고, !=는 Swift Standard Library 의 기본 구현이 ==의 부정임을 이용한다.

위 Vector2D 에 Custom Equal to Operator ==를 구현하는 방법은 두 가지가 있다.

1 ) Infix Operator 를 직접 구현하기

extension Vector2D: Equatable {
    static func == (lhs: Vector2D, rhs: Vector2D) -> Bool {
        lhs.x == rhs.x && lhs.y == rhs.y
    }
}

2 ) Protocol 채택으로 Swift 가 구현을 자동으로 합성하도록 하기

extension Vector2D: Equatable {}

우리는 Swift Protocols 의 Adopting a Protocol Using a Synthesized Implementation 에서 단순히 Protocol 을 채택하는 것 만으로 Protocols 가 제공하는 Default Implementations 를 Swift 가 자동으로 합성해 구현하도록 할 수 있음을 확인했다.

let alpha = Vector2D(x: 2.0, y: 3.0)
let beta = Vector2D(x: 2.0, y: 3.0)
if alpha == beta {
    print("These two vectors are equivalent.")
}

These two vectors are equivalent.

5. Impossible Operators to Overload

Classes 와 Structures 를 구현할 때 모든 Operators 가 Overloading 가능한 것은 아니다. Default Assignment Operator = 또는 Ternary Conditional Operator a ? b : c와 같이 Overloading 이 허용되지 않는 연산자가 존재한다. Overloading 이 불가능한 모든 연산자 목록은 다음 섹션의 Custom Operators 로 사용할 수 없는 연산자 에서 확인할 수 있다.

---

6. Custom Operators 👩‍💻

1. Custom Operators

Swift 가 제공하는 Standard Operators 외에 Custom Operators 를 선언하고 구현할 수 있다. Custom Operators 는 operator keyword 를 사용하며 prefix, infix, postfix modifiers 를 가지며 Global Level로 정의된다. 다음 예제는 +++라는 새로운 Prefix Operator 를 정의한다.

prefix operator +++

이 +++ 연산자는 Swift 에 존재하는 Operators 가 아니므로 Protocols 를 채택하도록 해 구현을 합성하도록 할 수 없다. 이 새 Operators 를 사용해 정의하려는 작업을 사용자가 직접 구현해야하며, 그 구현은 사용자가 정의한 특정 context 내에 의미가 부여된다.

prefix operator +++

extension Vector2D {
    static prefix func +++ (vector: inout Vector2D) -> Vector2D {
        vector += vector
        return vector
    }
}

이제 Vector2D 는 기존재 존재하지 않는 사용자 정의 연산자 +++를 사용해 값을 2배로 만드는 연산을 수행할 수 있다.

var toBeDoubled = Vector2D(x: 1.0, y: 4.0)
let afterDoubling = +++toBeDoubled
print("After Doubling Vector is (\(afterDoubling.x), \(afterDoubling.y)).")
// After Doubling Vector is (2.0, 8.0).

1 ) Custom Operators 로 사용할 수 있는 연산자

• ASCII 문자 /, =, -, +, !, *, %, <, >, &, |, ^, ?
• 다음 문법과 일치하는 연산자

Grammar of operators

operator → operator-head operator-characters?
operator → dot-operator-head dot-operator-characters
operator-head → / | = | - | + | ! | * | % | < | > | & | | | ^ | ~ | ?
operator-head → U+00A1–U+00A7
operator-head → U+00A9 or U+00AB
operator-head → U+00AC or U+00AE
operator-head → U+00B0–U+00B1
operator-head → U+00B6, U+00BB, U+00BF, U+00D7, or U+00F7
operator-head → U+2016–U+2017
operator-head → U+2020–U+2027
operator-head → U+2030–U+203E
operator-head → U+2041–U+2053
operator-head → U+2055–U+205E
operator-head → U+2190–U+23FF
operator-head → U+2500–U+2775
operator-head → U+2794–U+2BFF
operator-head → U+2E00–U+2E7F
operator-head → U+3001–U+3003
operator-head → U+3008–U+3020
operator-head → U+3030
operator-character → operator-head
operator-character → U+0300–U+036F
operator-character → U+1DC0–U+1DFF
operator-character → U+20D0–U+20FF
operator-character → U+FE00–U+FE0F
operator-character → U+FE20–U+FE2F
operator-character → U+E0100–U+E01EF
operator-characters → operator-character operator-characters?
dot-operator-head → .
dot-operator-character → . | operator-character
dot-operator-characters → dot-operator-character dot-operator-characters?
infix-operator → operator
prefix-operator → operator
postfix-operator → operator

2 ) Custom Operators 로 사용할 수 없는 연산자

다음 연산자들은 예약되어있으며, Overloading 하거나 Custom Operators 로 사용할 수 없다.

• Tokens 로 사용할 수 없는 연산자: =, ->, //, /*, */, .
• Prefix Operators 로 사용할 수 없는 연산자: <, &, ?
• Infix Operators 로 사용할 수 없는 연산자: ?
• Postfix Operators 로 사용할 수 없는 연산자: >, !, ?

2. Precedence for Custom Infix Operators

모든 Custom Infix Operators는 기본 Infix Operators 와 마찬가지로 특정 우선순위 그룹에 속하게 된다. 선언할 때 우선순위 그룹을 명시할 수 있으며, 명시되지 않은 연산자는 Default Precedence Group 에 속하게 되는데 이것은 Ternary Conditional Operator 의 바로 위에 위치하게된다.

다음 예제는 New Custom Infix Operator +-를 선언 및 정의한다. 이 연산자는 산술연산을 하므로 Addition Precednece 그룹에 속하도록 선언되었다.

infix operator +-: AdditionPrecedence

extension Vector2D {
    static func +- (lhs: Vector2D, rhs: Vector2D) -> Vector2D {
        Vector2D(x: lhs.x + rhs.x, y: lhs.y - rhs.y)
    }
}

let firstVector = Vector2D(x: 1.0, y: 2.0)
let secondVector = Vector2D(x: 3.0, y: 4.0)
let plusMinusVector = firstVector +- secondVector
print("Plus Minus Vector is (\(plusMinusVector.x), \(plusMinusVector.y)).")
// Plus Minus Vector is (4.0, -2.0).

Prefix Operators 또는 Postfix Operators를 정의할 때는 우선순위를 지정하지 않는다. 만약 피연산자(operand)에 둘을 모두 적용할 경우 Postfix Operators가 더 높은 우선순위를 가져 먼저 적용된다.

---

7. Result Builders 👩‍💻

1. The Problem That Result Builders Solve

결과 빌더 (result builder) 는 리스트 (list) 나 트리 (tree) 와 같은 중첩된 데이터를 자연스럽고 선언적인 방식으로 생성하기 위한 구문을 추가하는 타입입니다. 결과 빌더를 사용하는 코드는 조건적이거나 반복되는 데이터의 조각을 처리하기 위해 if 와 for 와 같은 Swift 구문을 포함할 수 있습니다. 아래 코드는 별과 텍스트를 사용하여 한줄로 그리기 위해 몇가지 타입을 정의합니다.

Result Builder는 하나의 Type 으로, List 나 Tree 와 같은 Nested Data 를 자연스럽고 선언적으로 생성하기 위한 Syntax 를 정의한다.

다음 에제는 한 줄에 별과 문자를 그리기 위해 몇 가지 Types 를 정의한다.

protocol Drawable {
    func draw() -> String
}

struct Line: Drawable {
    var elements: [Drawable]
    func draw() -> String {
        elements.map { $0.draw() }.joined(separator: "")
    }
}

struct Text: Drawable {
    var content: String
    init(_ content: String) {
        self.content = content
    }
    func draw() -> String {
        content
    }
}

struct Space: Drawable {
    func draw() -> String {
        " "
    }
}

struct Stars: Drawable {
    var length: Int
    func draw() -> String {
        String(repeating: "*", count: length)
    }
}

struct AllCaps: Drawable {
    var content: Drawable
    func draw() -> String {
        content.draw().uppercased()
    }
}

• Drawable protocol 은 draw() 메서드를 구현하도록 강제함으로써 선이나 모양과 같은 그릴 수 있는 항목에 대한 요구사항을 정의한다.
• Line structure 는 다른 Drawable 을 자신의 property 에 배열로 저장함으로써 대부분의 그리는 것에 대해 최상위 컨테이너의 역할을 한다. Line structure 는 줄을 그리기 위해 draw()를 호출하고 이 메서드는 컨테이너 내 다른 Drawable 이 자신의 draw()를 호출해 그림을 그리도록 한 뒤 joined(separator:) 메서드를 이용해 문자열 결과를 단일 String 으로 만든다.
• Text structure 는 문자열을 하나의 그리기로 wrapping 시키고, Space structure 는 하나의 공백을 그리고, Stars structure 는 주어진 개수 만큼 별을 그린다.
• AllCaps structure 는 다른 Drawable 을 대문자로 변경하는 역할을 한다.

이 Structures 를 사용해 다음과 같이 One Line String 을 그릴 수 있다.

let name: String? = "Hogwarts"
let manualDrawing = Line(elements: [
    Stars(length: 3),
    Text("Hello"),
    Space(),
    AllCaps(content: Text("\(name ?? "World")!")),
    Stars(length: 2)
])

print(manualDrawing.draw()) // ***Hello HOGWARTS!**

코드는 잘 작동하지만 AllCaps 안에 또 다른 괄호를 포함하는 인스턴스 생성 구문이 들어가는 것은 코드를 읽기 어렵게 만든다.

2. Define Result Builders

Result Builder는 코드를 좀 더 Swift 스럽고 읽기 쉽게 만들어준다. Result Builder 는 타입 선언에 @resultBuilder Attribute 를 작성해 정의한다. 다음 예제는 Declarative Syntax 를 사용해 drawing 작업을 묘사하는 DrawingBuilder 를 정의한다.

@resultBuilder
struct DrawingBuilder {
    static func buildBlock(_ components: Drawable...) -> Drawable {
        Line(elements: components)
    }
    static func buildEither(first: Drawable) -> Drawable {
        first
    }
    static func buildEither(second: Drawable) -> Drawable {
        second
    }
}

DrawingBuilder structure 는 Result Builder Syntax 의 일부를 구현하는 3개의 메서드를 정의한다.

• buildBlock(_:) 메서드는 코드 블럭에 Line을 그리기 위한 지원을 추가한다.
• buildEither(first:) 메서드와 buildEither(second:) 메서드는 if-else에 대한 지원을 추가한다.

3. Result Builders in Action

위에서 정의한 DrawingBuilder를 사용하기 위해 함수의 Parameter 에 @DrawingBuilder attribute 를 적용할 수 있으며, 이는 함수에 전달된 Closure 를 Result Builder 가 해당 Closure 에서 생성하는 값으로 변환한다.

func draw(@DrawingBuilder content: () -> Drawable) -> Drawable {
    content()
}

func caps(@DrawingBuilder content: () -> Drawable) -> Drawable {
    AllCaps(content: content())
}

func makeGreeting(for name: String? = nil) -> Drawable {
    let greeting = draw(content: {
        Stars(length: 3)
        Text("Hello")
        Space()
        caps(content: {
            Text("\(name ?? "World")!")
        })
        Stars(length: 2)
    })
    return greeting
}

• draw(_:)와 caps(_:) 함수는 둘 다 @DrawingBuilder attribute 가 적용된 Single Closure 를 arguemnt 로 받는다. 이것은 일반 함수에서 Parameter Type 이 Closure 일 때의 사용법과 동일하다. 우리는 이것을 이미 Autoclosure Type Parameters 에서 Autoclosure 를 사용하지 않은 일반 함수의 Parameter 가 Closure 일 때 사용해본 적이 있다.

var customersInLine = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]

func serve(customer customerProvider: () -> String) {
    print("Now serving \(customerProvider())!")
}

// serve(customer: { customersInLine.remove(at: 0) })  // Now serving Chris!

// with trailing closure
serve {
    customersInLine.remove(at: 0)
}

Now serving Chris!

• makeGreeting(for:) 함수는 name 을 parameter 로 받아 개인화 인사말을 그리는 데 사용한다. 앞에서 Result Builders 는 List 나 Tree 와 같은 Nested Data 를 자연스럽고 선언적으로 생성하기 위한 Syntax 를 정의하는 Type 이라고 했다. 즉, 이것은 Swift 가 언어 레벨에서 지원하는 Monad 라 볼 수 있다. 이것은 pipe 와 reduce 의 특성들을 조금씩 섞어 놓은 것처럼 보이기도 한다. 한가지 확실한 것은 Result Builders 는 결국 Monad 로 데이터를 쉽게 다루기 위한 Container 역할을 한다는 것이다.

이제 makeGreeting(for:) 함수를 Trailing Closures 를 사용해 좀 더 간략하게 표현해보자.

func draw(@DrawingBuilder content: () -> Drawable) -> Drawable {
    content()
}

func caps(@DrawingBuilder content: () -> Drawable) -> Drawable {
    AllCaps(content: content())
}

func makeGreeting(for name: String? = nil) -> Drawable {
    draw {
        Stars(length: 3)
        Text("Hello")
        Space()
        caps {
            Text("\(name ?? "World")!")
        }
        Stars(length: 2)
    }
}

기존의

let manualDrawing = Line(elements: [
    Stars(length: 3),
    Text("Hello"),
    Space(),
    AllCaps(content: Text("\(name ?? "World")!")),
    Stars(length: 2)
])

와 비교해보면 훨씬 선언적인 문법이 되었다. 잘 작동하는지 확인해보자.

let genericGreeting = makeGreeting()
print(genericGreeting.draw())   // ***Hello WORLD!**

함수를 사용해 선언적으로 변경했기 때문에 가독성이 좋아졌을 뿐 아니라 재사용성도 좋아졌다.

let personGreeting = makeGreeting(for: "Hogwarts")
print(personGreeting.draw())    // ***Hello Hogwarts!**

@DrawingBuilder를 attribute 로 사용한다는 것은 DrawingBuilder 가 정의한 Syntax 를 사용한다는 것이므로 Closure 에 실행시키길 원하는 코드를 모아 하나의 코드 블럭으로 Wrapping 시키고, 이것을 do 명령으로 evalution 하는 것과 같다고 볼 수 있다. 따라서 draw(content:) 함수에 Trailing Closures 를 사용해 여러 코드를 하나의 블럭으로 묶은 것 처럼 caps(content:) 함수 역시 동일하게 여러 코드를 하나의 블럭으로 묶을 수 있다.

let name: String? = "Hogwarts"
let capsDrawing = caps {
    let partialDrawing: Drawable
    if let name = name {
        partialDrawing = DrawingBuilder.buildEither(first: Text("\(name)!"))
    } else {
        partialDrawing = DrawingBuilder.buildEither(second: Text("World!"))
    }
    return partialDrawing
}
print(capsDrawing)          // AllCaps(content: __lldb_expr_156.Text(content: "Hogwarts!"))
print(capsDrawing.draw())   // HOGWARTS!

여기서 caps(content:)가 실행하고자 하는 코드 블럭을 보자. if-else 구문을 buildEither(first:)와 buildEither(second:) 메서드에 대한 호출로 변환한다. 즉, Monad 의 일종이므로 모든 데이터를 Drawable로 다루게 하는 것이다. 현재 코드에서 buildEither(first:)와 buildEither(second:)가 하는 일이 동일하기 때문에 위에서 Ternary Operator 를 사용해 처리했지만 서로 다른 로직을 추가해 고유의 동작을 하도록 선언할 수 있음을 의미한다.

이번에는 DrawingBuilder 에 buildArray(_:) 메서드를 추가해보자.

extension DrawingBuilder {
    static func buildArray(_ components: [Drawable]) -> Drawable {
        Line(elements: components)
    }
}

이 메서드는 Drawable 데이터를 Collection 으로 만들어 for-loop를 사용 가능하게 만들어준다.

let manyStars = draw {
    Text("Stars:")
    for length in 1...3 {
        Space()
        Stars(length: length)
    }
}
print(manyStars.draw()) // Stars: * ** ***

현재 Result Builders를 통해 정의할 수 있는 메서드는 buildBlock(_:)과 buildEither(first:), buildEither(second:)를 포함해 10개가 존재한다.

@resultBuilder
struct ArrayBuilder {
    typealias Component = [Int]
    typealias Expression = Int
    static func buildExpression(_ element: Expression) -> Component {
        return [element]
    }
    static func buildOptional(_ component: Component?) -> Component {
        guard let component = component else { return [] }
        return component
    }
    static func buildEither(first component: Component) -> Component {
        return component
    }
    static func buildEither(second component: Component) -> Component {
        return component
    }
    static func buildArray(_ components: [Component]) -> Component {
        return Array(components.joined())
    }
    static func buildBlock(_ components: Component...) -> Component {
        return Array(components.joined())
    }
    // ...
}

Result Builders 문법의 전체 레퍼런스는 Swift Docs Language Reference - Attributes/Result Builder 를 참고한다.

---

Reference

1. “Advanced Operators.” The Swift Programming Language Swift 5.9. accessed Oct. 14, 2023, Swift Docs Chapter 27 - Advanced Operators.
2. “Operator Declarations.” Apple Developer Documentation. accessed Oct. 17, 2023, Apple Developer Documentation - Swift/Swift Standard Library/Operator Declarations.
3. “Lexical Structure.” The Swift Programming Language Swift 5.9. accessed Oct. 23, 2023, Swift Lexical Structure.
4. “Attributes.” The Swift Programming Language Swift 5.9. accessed Oct. 24, 2023, Swift Docs Language Reference - Attributes/Result Builder.