Swift Closures

1. Closure Expressions 👩‍💻

Swift 의 Closures는 정의된 context(or scope)에 상수나 변수를 캡처하고 저장할 수 있다. 이는 다른 언어의 Lambda expressions와 비슷하다.

1 ) Closures 는 다음 세 가지 형태 중 하나를 갖는다

• Global Functions : 이름이 있고, 어떤 값도 캡처하지 않는 Closures
• Nested Functions : 이름이 있고, 자신이 속한 function context의 값을 캡처할 수 있는 Closures
• Closure Expressions : 이름이 없고, 자신이 속한 context의 값을 캡처할 수 있는 경량화된 Closures

2 ) Swift Closures 최적화가 갖는 특징

• context로부터 parameter 와 return value 를 추론(inferring)한다
• 단일 표현 클로저(single-expression closures)에서 암시적 반환 implicit returns
• 축약된 인자 이름 shorthand argument names
• 후위 클로저 문법 trailing closure syntax

Closure Expressions는 이름이 없으나 경량화된 문법으로 재사용 되지 않는 함수, 주로 Nested Functions를 대체할 수 있다.

1. The Sorted Method

sorted(by:) 메서드는, Comparable 프로토콜을 따르는 타입에 대해 (Type, Type) -> Bool 타입의 Closures 를 arguments 로 받아 정렬을 수행한다. true 면 순서를 바꾸지 않고, false 면 순서를 바꾼다.

let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]

이를 위해 sorted(by:) 메서드에 arguments 로 전달할 Closures 를 만든다.

// ascending order(default)
func forward(_ s1: String, _ s2: String) -> Bool {
    s1 < s2
}

// descending order
func backward(_ s1: String, _ s2: String) -> Bool {
    s1 > s2
}

arguments 로 전달할 Global Functions 형태의 Closures forware(_:_:), backward(_:_:)를 만들었다.

print("origin          : \(names)")
print("default         : \(names.sorted())")
print("ascending order : \(names.sorted(by: forward))")
print("descending order: \(names.sorted(by: backward))")

origin          : ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
default         : ["Alex", "Barry", "Chris", "Daniella", "Ewa"]
ascending order : ["Alex", "Barry", "Chris", "Daniella", "Ewa"]
descending order: ["Ewa", "Daniella", "Chris", "Barry", "Alex"]

2. Closure Expression Syntax

Syntax

{ (parameters) -> return type in
    statements
}

Closure Expressions 는 다음 특징을 갖는다

• Global Functions와 마찬가지로 In-Out Parameters, Variadic Parameters, Tuple Type Parameters, Tuple Type Return이 허용된다.
• 단, Default Parameter Values는 허용되지 않는다.

위 정렬은 Global Functions 형태의 Closures 대신 Closure Expressions 형태의 Closures 를 이용하면 더욱 간결한 표현이 가능하다.

let ascendingOrderNames = names.sorted(by: { (s1: String, s2: String) -> Bool in return s1 < s2 })
let descendingOrderNames = names.sorted(by: { (s1: String, s2: String) -> Bool in return s1 > s2 })

print("ascendingOrderNames : \(ascendingOrderNames)")
print("descendingOrderNames: \(descendingOrderNames)")

ascendingOrderNames : ["Alex", "Barry", "Chris", "Daniella", "Ewa"]
descendingOrderNames: ["Ewa", "Daniella", "Chris", "Barry", "Alex"]

3. Inferring Type From Context

Inline-Closures는 항상 context로부터 parameter types 와 return types 를 추론(infer)할 수 있으므로 type 생략이 가능하다.
(Global Functions 와 달리 -> return types 마저도 생략 가능하다)

// ascending order
names.sorted(by: { s1, s2 in return s1 < s2 })

// descending order
names.sorted(by: { s1, s2 in return s1 > s2 })

4. Implicit Return from Single-Expression Closures

함수와 마찬가지로 Single-Expression Closures는 return 키워드를 생략할 수 있다. 사실 Global Functions 형태의 Closures 가 가능했으니 Closure Expressions 형태의 Closures 역시 가능한 것은 당연하다.

// ascending order
names.sorted(by: { s1, s2 in s1 < s2 })

// descending order
names.sorted(by: { s1, s2 in s1 > s2 })

5. Shorthand Argument Names

Inline-Closures 에 Shorthand Argument Names를 자동으로 제공하므로, arguments 를 생략할 수 있으며, 이는 $0, $1, $2로 표현된다. 또한 arguments 선언 자체를 생략하므로 in 키워드 역시 필요가 없어 함께 생략되어 Closures 는 body만으로 구성된다.

// ascending order
names.sorted(by: { $0 < $1 })

// descending order
names.sorted(by: { $0 > $1 })

6. Operator Methods

String은 greater-than operator(>)를 메서드로 갖는다. 또한 이 메서드는 두 개의 parameters 를 갖고, Bool 을 반환한다. 즉, 위에서 sorted(by:)가 Closures 로 받는 유형과 정확히 일치한다. 따라서 이 경우 Operator만 남긴 채 Shorthand Argument Names 마저도 생략할 수 있다.

// ascending order
names.sorted(by: <)

// descending order
names.sorted(by: >)

---

2. Trailing Closures 👩‍💻

함수를 호출할 때 마지막 parameter가 Closure이고, 전달 되는 argument 가 긴 표현식일 경우 Trailing Closure를 이용해 코드의 가독성을 높일 수 있다. Trailing Closure 는 함수를 호출할 때 괄호(( )) 다음에 작성하지만 여전히 함수의 arguments 다.

함수는 여러 개의 Trailing Closures를 arguments로 입력 받을 수 있으며, 첫 번째 Trailing Closure의 argument labels는 생략될 수 있다 (cf. Multiple Trailing Closures).

1. Trailing Closure Syntax

아래 someFunctionThatTakesAClosure(closure:) 함수는 마지막 arguments 를 Closures 로 갖는 함수다.

func someFunctionThatTakesAClosure(closure: () -> Void) {
    // function body goes here
}

이제 이 함수를 호출해보자.

1 ) Trailing Closures 없이 함수를 호출

함수의 argument로 Closure를 전달한다.

someFunctionThatTakesAClosure(closure: {
    // closure's body goes here
})

2 ) Trailing Closures 로 분리해 함수를 호출

첫 번째 Trailing Closure이므로 argument labels를 생략할 수 있다.

someFunctionThatTakesAClosure() {
    // trailing closure's body goes here
}

위 Trailing Closures의 형태를 보면 Global Functions와 같다는 것을 알 수 있다.
즉, Global Functions가 Closures 의 형태 중 하나라는 것을 확인할 수 있다.

3 ) Trailing Closures 가 함수의 유일한 arguments일 때는 괄호( )를 생략할 수 있다

someFunctionThatTakesAClosure {
    // trailing closure's body goes here
}

2. Trailing Closure Examples

1 ) Examples 1: ‘sorted(by:)’

위 sorted(by:)를 Trailing Closures를 이용해 호출하면 다음과 같다.

let names = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
let descendingNames = names.sorted { $0 > $1 }

print(descendingNames)  // ["Ewa", "Daniella", "Chris", "Barry", "Alex"]

Closures 를 전달해 사용할 때와 Trailing Closures 를 사용할의 차이을 비교해보자.

• Without Trailing Closures

names.sorted(by: { $0 > $1 } )

// Using Operator Methods
names.sorted(by: >)

Closure Expressions 는 Operator Methods 만 남겨 최적화 할 수 있다.

• With Trailing Closures

names.sorted { $0 > $1 }

// Using Operator Methods
print(names.sorted { > })   // error: unary operator cannot be separated from its operand

하지만 Trailing Closure 은 Operator Methods 만 남겨 최적화 할 수 없다.

2 ) Examples 2: ‘map(_:)’

map(_:) 메서드를 이용해 아래 주어진 digitNames, numbers 배열로부터 새 배열 ["OneSix", "FiveEight", "FiveOneZero"]을 반환하도록 Trailing Closures 를 이용해 map(_:) 메서드를 호출해보자.

let digitNames = [
    0: "Zero", 1: "One", 2: "Two",   3: "Three", 4: "Four",
    5: "Five", 6: "Six", 7: "Seven", 8: "Eight", 9: "Nine"
]
let numbers = [16, 58, 510]

let strings = numbers.map { number -> String in
    var number = number
    var output = ""

    repeat {
        output = digitNames[number % 10]! + output
        number /= 10
    } while number > 0

    return output
}

print(strings)  // ["OneSix", "FiveEight", "FiveOneZero"]

위 Trailing Closures 의 Return Types를 생략할 수 있다.

let strings = numbers.map { number in
    var number = number
    var output = ""

    repeat {
        output = digitNames[number % 10]! + output
        number /= 10
    } while number > 0

    return output
}

print(strings)  // ["OneSix", "FiveEight", "FiveOneZero"]

마지막으로, Shorthand Argument Names를 이용해 arguments와 in 키워드 역시 생략해 최적화 할 수 있다.

let strings = numbers.map {
    var number = $0
    var output = ""

    repeat {
        output = digitNames[number % 10]! + output
        number /= 10
    } while number > 0

    return output
}

print(strings)  // ["OneSix", "FiveEight", "FiveOneZero"]

3. A function takes Multiple Trailing Closures

만약 함수가 여러 개의 Trailing Closures 를 가질 경우, 첫 번째 Trailing Closure의 argument labels는 생략될 수 있다. 그 외 나머지 Trailing Closures 는 argument labels 을 지정해야한다.

아래 loadPicture(from:completion:onFailure:) 함수를 보자.

func loadPicture(from server: Server, completion: (Picture) -> Void, onFailure: () -> Void) {
    if let picture = download("photo.jpg", from: server) {
        completion(picture)
    } else {
        onFailure()
    }
}

loadPicture(from:completion:onFailure:)는 3 개의 arguments 를 갖고 있는데, 첫 번째는 Server 객체, 두 번째는 (Picture) -> Void Closure, 세 번재는() -> Void Closure다.

이중 두 번째 arguments 이자 첫 번째 Closure 인 completion: (Picture) -> Void는 completion handler로 다운로드가 성공한 경우 사진을 보여줄 것이고, 세 번째 arguments 이자 두 번째 Closure 인 onFailure: () -> Void는 error handler로 사용자에게 에러가 발생했음을 알려줄 것이다.

위 함수를 이번에는 Trailing Closures 를 이용해 호출해보자.

loadPicture(from: someServer) { picture in
    someView.currentPicture = picture
} onFailure: {
    print("Couldn't download the next picture.")
}

첫 번째 Trailing Closure 인 completion: (Picture) -> Void는 argument labels 를 생략했다.
하지만 두 번째 Trailing Closure 인 onFailure: () -> Void는 argument labels 를 생략할 수 없어 onFailure를 명시했다.

loadPicture(from:completion:onFailure:)와 같이 함수를 작성하면, 하나의 Closure 에 success, error를 처리하는 코드를 혼재하지 않고 case 별로 코드를 명확하게 분리할 수 있다.

위 경우는 2개의 completion handlers 만 존재하지만, 여러 개의 completion handlers 가 중첩되면 코드를 읽기 어려워진다. 이런 경우 Concurrency 에 설명된 것처럼 Asynchronous Functions 를 사용해 이를 대체할 수 있다.

---

3. Capturing Values 👩‍💻

Closures 는 정의될 때 주변 context 의 상수나 변수, 인수를 Capturing해 저장할 수 있다.
Nested Functions는 가장 간단한 형태의 값 캡처로 context 내의 어떠한 constant, variables, arguments 든 캡처할 수 있다.

아래 makeIncrementer(forIncrement:) 함수를 보자.

func makeIncrementer(forIncrement amount: Int) -> () -> Int {
    var runningTotal = 0
    func incrementer() -> Int {
        runningTotal += amount
        return runningTotal
    }
    return incrementer
}

함수의 body 를 살펴보면, 안에 정의된 Nested Function 인 incrementer()는 주변 context 에서 변수 runningTotal과 파라미터 amount를 캡처해 () -> Int 타입의 함수 incrementer()를 만들어 반환한다.

즉, makeIncrementer(forIncrement:) 함수는 Int를 arguments 로 받아 () -> Int 타입의 함수를 반환한다.

반환된 함수는 다음과 같을 것이다.

func incrementer() -> Int {
    runningTotal += amount
    return runningTotal
}

반환된 함수 어디에도 runningTotal과 amount가 정의되어있지 않지만 이 함수는 작동한다.
값을 캡처했기 때문이다.

즉, arguments 를 받아 함수를 만들어내는 함수로 재사용이 가능하다.

let incrementByThree = makeIncrementer(forIncrement: 3)
let incrementByFive = makeIncrementer(forIncrement: 5)

print(incrementByThree())   // 3
print(incrementByThree())   // 6
print(incrementByThree())   // 9

print(incrementByFive())    // 5
print(incrementByFive())    // 10

print(incrementByThree())   // 12

print(incrementByFive())    // 15

incrementByThree()와 incrementByFive()가 서로에게 영향을 주지 않고 각각 작동할 수 있는 이유는 값을 캡처했기 때문이다.

Swift 는 값을 캡처할 때는 물론이고 더 이상 필요하지 않을 경우 제거하는 것과 같은 모든 메모리 관리를 알아서 처리한다.

동일한 로직을 TypeScript 로 구현한 코드가 아래 있다. Swift 와 비교해보자.

const makeIncrementer: (forIncrement: number) => () => number
    = amount => {
    let runningTotal = 0
    const incrementer: () => number
        = () => {
        runningTotal += amount
        return runningTotal
    }
    return incrementer
}

const incrementByThree = makeIncrementer(3)
const incrementByFive = makeIncrementer(5)

console.log(incrementByThree())   // 3
console.log(incrementByThree())   // 6
console.log(incrementByThree())   // 9

console.log(incrementByFive())    // 5
console.log(incrementByFive())    // 10

console.log(incrementByThree())   // 12

console.log(incrementByFive())    // 15

Closure 를 Class instance 의 Property에 할당하고, 그 Closure 가 자신의 instance 또는 instance 의 members를 참조로 캡처하면 Strong Reference Cycle(강한 순환 참조)가 생성된다.

따라서 Swift 는 이 순환을 중단시키기 위해 Capture Lists를 이용한다. 해당 내용은 다음을 참고한다. Strong Reference Cycles for Closures

---

4. Closures Are Reference Types 👩‍💻

func makeIncrementer(forIncrement amount: Int) -> () -> Int {
    var runningTotal = 0
    func incrementer() -> Int {
        runningTotal += amount
        return runningTotal
    }
    return incrementer
}

let incrementByTen = makeIncrementer(forIncrement: 10)
let anotherIncrementByTen = makeIncrementer(forIncrement: 10)
let referToIncrementByTen = incrementByTen

위에서 let 키워드를 이용해 다음과 같이 3개의 상수를 선언했다.

• makeIncrementer(forIncrement:) 함수를 이용해 반환된 함수를 incrementByTen 상수에 할당했다.
• makeIncrementer(forIncrement:) 함수를 이용해 반환된 함수를 anotherIncrementByTen 상수에 할당했다.
• incrementByTen 상수를 referToIncrementByTen 상수에 할당했다.

print(incrementByTen())         // 10
print(incrementByTen())         // 20
print(incrementByTen())         // 30

print(anotherIncrementByTen())  // 10

print(referToIncrementByTen())  // 40
print(incrementByTen())         // 50

모두 let 키워드를 이용해 상수로 선언했지만 캡처한 여전히 runningTotal 변수의 값은 변경되고있다. 왜 그럴까?
incrementByTen()과 referToIncrementByTen()은 왜 값을 공유할까?

Functions 와 Closures 는 Reference Types이다. let keyword 를 사용해 상수로 선언된건 incrementByTen, anotherIncrementByTen, referToIncrementByTen 함수 자체다. 그리고 이 함수는 var keyword 로 선언된 변수를 캡처하고 값을 변경한다. 그렇기 때문에 반환하는 값이 변경될 수 있는 것이다.

---

5. Escaping Closures 👩‍💻

함수에 arguments 로 전달된 Closures 의 호출 시점에 따라 두 가지로 구분할 수 있다.

1. 함수가 종료되기 전에 호출: 함수의 body 내에서 호출된다. 일반적으로 전달된 Closures 가 호출되는 방식이다.
2. 함수가 종료된 후 호출: asynchronous 처리를 시작하는 대부분의 함수는 arguments 로 completion handler를 사용한다. 이것은 함수가 종료된 후 호출되며 Escaping Closures라 한다. 이를 위해 함수를 정의할 때 Parameter Types 앞에 @escaping 키워드를 작성해 전달된 Closures 가 escape 될 수 있음을 명시해야한다. 그렇지 않으면 compile-time error 가 발생한다.

1. Store in a Variable

Closures 를 escape 시키는 방법은 함수 context 외부 변수에 저장하는 것이다.

var completionHandlers: [() -> Void] = []
func someFunctionWithEscapingClosure(completionHandler: () -> Void) {
    completionHandlers.append(completionHandler)    // error: converting non-escaping parameter 'completionHandler' to generic parameter 'Element' may allow it to escape
}

parameter 로 전달된 () -> Void 타입의 completionHandler라는 이름의 Closures 를 함수 context 외부 변수에 저장하려 한다. 즉, 함수의 body 외부로 escape시키려는 행위이므로 Parameter Types 앞에 @escaping 키워드를 반드시 작성해야한다. 위 경우 이를 누락해 error 가 발생했다.

func someFunctionWithEscapingClosure(completionHandler: @escaping () -> Void) {
    completionHandlers.append(completionHandler)
}

@escaping 키워드를 추가하자 정상적으로 작동한다.

2. Escaping Closures in Classes

Escaping Closures 가 Class Instances 의 self를 참조하는 경우 주의해야한다. self 를 캡처할 경우 너무도 쉽게 Strong Reference Cycle(강한 순환 참조)가 생기기 쉽기 때문이다. Reference Cycles에 대해 좀 더 자세한 내용은 Automatic Reference Counting을 참고한다.

따라서 Closures는 implicit(암시적) 으로 Closure 내부 변수를 이용해 외부 변수를 캡처하지만, Escaping Closures는 self 키워드 이용해 explicit(명시적) 으로 코드를 작성 하도록한다. 이는 개발자에게 순환 참조가 없음을 확인하도록 상기시킨다.

func someFunctionWithNonescapingClosure(closure: () -> Void) {
    closure()
}

Non-Escaping Closures 를 하나 더 추가해 이것이 self를 참조하는 것이 어떻게 다른지 살펴보자.

class SomeClass {
    var x = 10
    func doSomething() {
        someFunctionWithEscapingClosure { self.x = 100 }
        someFunctionWithNonescapingClosure { x = 200 }
    }
}

let instance = SomeClass()
instance.doSomething()      // `someFunctionWithNonescapingClosure` is called in `doSomething` function's body
print(instance.x)   // 200

completionHandlers.first?() // `someFunctionWithEscapingClosure ` is not called in `doSomething()` function's body
print(instance.x)   // 100

1. SomeClass 의 instance 를 생성해 instance 이름의 상수에 할당한다.
2.  
   • instance의 doSomething()을 호출한다. 이때 someFunctionWithEscapingClosure(completionHandler:)는 @escaping () -> Void 타입의 completionHandler를 받아 completionHandlers.append(completionHandler)를 수행한다. 즉, 전달된 closure 를 호출하지 않고 외부에 저장한다.

     () -> { self.x = 100 }은 외부 completionHandlers 에 저장된다.

   • 반면 someFunctionWithNonescapingClosure(closure:))는 () -> Void 타입의 closure를 받아 closure()를 수행한다. 즉, 전달된 closure 를 즉시 호출한다.

     () => { x = 200 }은 즉시 호출되어 x에 200을 저장한다.

3. instnace의 x를 출력한다. 200이 출력된다. 이미 위 2번에서 someFunctionWithNonescapingClosure(closure:))가 호출되어 x 에 200 이라는 값을 저장했기 때문이다.
4. completionHandlers.first?()를 호출한다. 아까 someFunctionWithEscapingClosure(completionHandler:)가 호출되며 completionHandlers 에 escaping 되어 저장한 첫 번째 closure 가 호출되며 x 에 100 을 저장한다.
5. instnace의 x를 출력한다. 100이 출력된다. 위 4번에서 x 에 다시 100 을 저장했기 때문이다.

다른 버전의 doSomething() 함수를 보자. 다음은 Escaping Closures에서도 매번 self 키워드를 사용하지 않고 암시적으로 self를 참조할 수 있다.

class SomeClass {
    var x = 10
    func doSomething() {
        someFunctionWithEscapingClosure { [self] in x = 100 }
        someFunctionWithNonescapingClosure { x = 200 }
    }
}

self를 참조할 일이 많다면 [self]를 이용해 implicit 하도록 만들면 편리하겠으나 Swift 의 의도대로 self 키워드를 필요한 곳에 직접 명시해 explicit 하도록 사용하는 것이 더 안전한 것 같다.

3. Escaping Closures in Structures

Structures 나 Enumerations 의 instance 는 항상 self가 암시적implicit이다. 따라서 함수의 parameters가 Structures 내부의 다른 Properties 와 이름이 동일하지 않는 한 self를 명시할 필요가 없다.

struct SomeStruct {
    var x = 10
    mutating func doSomething() {
        someFunctionWithEscapingClosure { self.x = 100 }    // error: escaping closure captures mutating 'self' parameter
        someFunctionWithNonescapingClosure { x = 200 }      // Ok
    }
}

하지만 위와 같은 코드는 compile-time error 가 발생된다. Value Types는 값의 신뢰를 보장하기 위해 기본적으로 immutable 속성을 갖기 때문에 이를 변경하기 위해서는 mutating 키워드를 사용한 context 내부에서 변경이 이루어져야한다. 하지만 Escaping Closures는 이 mutating context가 종료된 후 호출되기 때문에 이를 위반한다.

아래와 같이 mutating 키워드가 필요한 코드를 제외하면 Escaping Closures는 Value Types에서도 사용 가능하다.

struct SomeStruct {
    var x = 10
    mutating func doSomething() {
        someFunctionWithNonescapingClosure { x = 200 }
    }
    func anotherDoSomething() {
        someFunctionWithEscapingClosure { print("It's OK") }
    }
}

var valueTypeInstance = SomeStruct()    // It must be declared with `var` not `let`, due to `doSomething()` use mutating member.

valueTypeInstance.doSomething()
print(valueTypeInstance.x)  // 200

valueTypeInstance.anotherDoSomething()
completionHandlers.first?()  // It's OK

Value Types에서 Escaping Closures는 mutating을 할 수 없다. 이것이 Value Types 에서 Escaping Closures 가 사용 불가능함을 의미하는 것은 아니다. 여전히 mutating 이 필요하지 않은 closures 는 escaping 될 수 있다.

---

6. Autoclosures 👩‍💻

함수의 arguments 로 closures 를 전달할 때 이 closure 가 arguments 를 갖지 않고 expressions 의 결과를 반환하는 경우 { arguments in expressions }에서 arguments 와 in 은 물론이고 { } 마저도 생략하고 expressions만으로 작성하도록 할 수 있다.

이러한 closure 를 Autoclosure라 하며, 함수를 정의할 때 @autoclosure 키워드를 추가함으로써 정의할 수 있다. Swift 는 이렇게 전달된 expressions을 자동으로 Closures 형태로 wrapping 한다.

Autoclosures는 코드가 호출될 때 까지 실행되지 않기 때문에 평가를 지연할 수 있다. 따라서 side effects가 있거나 시간이 오래 걸리는computationally expensive 코드에 유용하다.

1. Closures Evaluated when Called

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

let returned = customersInLine.remove(at: 0)
print(returned) // Chris

Arrays 의 remove(at:) 메서드는 주어진 index 의 배열을 제거 후 그 값을 반환한다.

let customerProvider = { customersInLine.remove(at: 0) }

따라서 위와 같이 정의된 customerProvider는 () -> String 타입이다.

다음은 Closures 가 코드 실행을 어떻게 지연시키는지를 보여준다.

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

let customerProvider = { customersInLine.remove(at: 0) }

print(customersInLine)          // ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
print(customersInLine.count)    // 5

customerProvider()
print(customersInLine)          // ["Alex", "Ewa", "Barry", "Daniella"]
print(customersInLine.count)    // 4

customerProvider()
print(customersInLine)          // ["Ewa", "Barry", "Daniella"]
print(customersInLine.count)    // 3

위 코드 블럭을 보면 let customerProvider = { customersInLine.remove(at: 0) }라인 이후 customersInLine를 출력해보면 그대로인 것을 알 수 있다. 이후 customerProvider()가 호출될 때 제거되고 그 값을 반환한다.

2. Autoclosure Type Parameters

1 ) Parameter Type is a Closure

이러한 코드 지연은 함수의 arguments 로 Closures 를 전달할 때도 동일한 작동을 갖는다.

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!

let customersInLine: string[] = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]

function serve(customerProvider: () => string) {
    console.log(`Now serving ${customerProvider()}!`)
}

serve(() => customersInLine.shift()!)               // Now serving Chris!

Swift 와 달리 arguments 자체를 생략 할 수는 없고 비워서 보내야한다.

2 ) Parameter Type is an Autoclosure

이때 Parameter Types 앞에 @autoclosure 키워드를 붙여주면 arguments 로 전달된 expressions를 컴파일러가 자동으로 Closures 형태로 wrapping 한다.

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

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

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

Autoclosures를 사용해 parameters 로 closures 가 아닌 String 을 받는 것처럼 사용할 수 있다.
TypeScript 에는 이와 유사한 문법이 존재하지 않는다. Swift 언어에만 존재하는 문법이다.

3 ) Parameter Type is a String

위 2번은 parameter 로 String 을 받는 것처럼 보이지만 여전히 closure 를 받고 있다. 다음 코드는 Autoclosures 없이 정말로 String 을 parameter 로 받는 함수다.

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!

let customersInLine: string[] = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]

function serve(customerProvider: string) {
    console.log(`Now serving ${customerProvider}!`)
}

serve(customersInLine.shift()!)

위 1 ~ 3은 모두 동일한 로직을 수행할 수 있다. 단, 이들의 차이점을 잘 이해하고 사용해야한다.

1. parameters 로 Closure 를 받는다.
2. parameters 로 Autoclosures 를 받는다. 겉보기에는 expressions의 결과로 단순 Type을 받는 것처럼 보일 수 있지만 여전히 Closure 를 parameters 로 받는다.
3. parameters 로 expressions을 수행 후 그 결과를 받는다. 위 2번과 달리 정말로 결과의 Type을 parameters 로 받는다.

Autoclosures를 사용함으로써 단순히 그 Types을 parameters 로 받는 것처럼 가독성을 높일 수 있으나 남용할 경우 오히려 코드를 이해하기 어렵게 만든다. 어디까지나 이것은 3번 처럼 결과의 Type 이 아닌 1번 처럼 Closure를 받는 것이기 때문이다. 따라서 Autoclosures를 사용할 때 context 와 함수의 이름은 코드의 실행이 지연됨을 분명히 해야한다.

3. Autoclosures with Escaping Closures

@autoclosure과 @escaping을 함께 사용할 수 있다.

var customersInLine = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
var customerProviders: [() -> String] = []

func collectCustomerProviders(_ customerProvider: @autoclosure @escaping () -> String) {
    customerProviders.append(customerProvider)
}

collectCustomerProviders(customersInLine.remove(at: 0))
collectCustomerProviders(customersInLine.remove(at: 0))

print("Collected \(customerProviders.count) closures.")
print("customerProviders: \(customerProviders)")

for customerProvider in customerProviders {
    print("Now serving \(customerProvider())!")
}

Collected 2 closures.
[(Function), (Function)]
Now serving Chris!
Now serving Alex!

위에서도 설명했지만, Autoclosures의 남용은 코드를 이해하기 어렵게 만든다.

7. Compare with TypeScript 👩‍💻

이 글의 시작 부분에서 Swift 의 Closures 는 다른 언어의 Lambda expressions와 비슷하다고 했다. 다시 한 번 정리하면서 마무리해보자.

1. Function Declarations with function / func keyword

function sum(a: number, b: number): number {
    return a + b
}
console.log(sum(5, 7))  // 12

func sum(_ a: Int, _ b: Int) -> Int {
    a + b
}
print(sum(5, 7))    // 12

2. Function Expressions with Lambda expressions / Closures

• Implicit Type Inference

// Function Expressions with lambda expressions
const product = (a: number, b: number) => a * b
console.log(product(5, 7))  // 35

// Function Expressions with closures
let product = { (a: Int, b: Int) in
    a * b
}
print(product(5, 7))        // 35

Return Type 이 생략되었다.

• Explicit Type Declaration

const product = (a: number, b: number): number => a * b
console.log(product(5, 7))  // 35

let product = { (a: Int, b: Int) -> Int in
    a * b
}
print(product(5, 7))        // 35

또는

const product: (num1: number, num2: number) => number = (a, b) => a * b
console.log(product(5, 7))  // 35

let product: (Int, Int) -> Int = { $0 * $1 }
print(product(5, 7))        // 35

3. Lambda expressions / Closures

// Function Expressions omit { }
const greetingMessage = () => "Hello~ TypeScript"
console.log(greetingMessage())  // Hello~ TypeScript

let greetingMessage = { "Hello~ Swift" }
print(greetingMessage())    // Hello~ Swift

4. Autoclosures

let customersInLine: string[] = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]

function serve(customerProvider: () => string) {
    console.log(`Now serving ${customerProvider()}!`)
}

serve(() => customersInLine.shift()!)               // Now serving Chris!

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

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

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

TypeScript 역시

serve(() => {
    return customersInLine.shift()!                 // Now serving Chris!
})

를

serve(() => customersInLine.shift()!)

로 { }와 return 키워드를 생략할 수 있으나 Swift 와 달리 arguments 자체를 생략할 수는 없어 Autoclosures처럼 완전히 평문을 적듯이 작성하는 것은 불가능하다. 즉 Swift 의 Autoclosures 개념에 완전히 일치하는 문법은 없다.

단, 이 경우는 Closure가 함수의 arguments로 전달될 때 Autoclosures에 의해 { }가 생략되는 것일 뿐이다.
함수의 arguments가 아닌 일반적인 Closures를 선언할 때를 비교해보면

const product = (a: number, b: number) => a * b

let product = { (a: Int, b: Int) in a * b }

TypeScript 는 특정 조건이 만족할 경우 Closures의 Body를 감싸는 { }를 생략할 수 있는 것과 달리 Swift 는 arguments를 생략할 수 있으나 위와 같이 Autoclosures가 아닌 경우는 { }를 생략할 수 없다.

즉, 이것은 어떤 언어가 더 우수하다는 것이 아닌 언어에 따른 특성이니 이를 잘 이해하고 사용하는 것이 필요하다.

5. Capturing Values with Closures

Functions는 Closures의 특별한 형태로 위 1~3번 모두 Closures다. 또한 Swift 의 Closures는 다른 언어의 Lambda expressions와 유사하다. Swift 뿐 아니라 함수를 First-Class Citizens로 취급하는 함수형 프로그래밍 언어는 이와 유사한 특성을 갖는다고 보면 된다.

TypeScript 의 경우 일반적으로 Closures 를 설명할 때 값을 캡처하고, return type이 함수인 경우. 즉, 함수를 이용해 함수를 만들어 반환하는 함수로써 Closures 를 설명하는 경우가 많은데 이것 역시 First-Class Citizens의 특성이므로 두 언어 모두 동일한 로직을 구현할 수 있다.

const makeIncrementer: (forIncrement: number) => () => number
    = amount => {
    let runningTotal = 0
    const incrementer: () => number
        = () => {
        runningTotal += amount
        return runningTotal
    }
    return incrementer
}

const increaseByThree = makeIncrementer(3)

console.log(increaseByThree())   // 3
console.log(increaseByThree())   // 6
console.log(increaseByThree())   // 9

func makeIncrementer(forIncrement amount: Int) -> () -> Int {
    var runningTotal = 0
    func incrementer() -> Int {
        runningTotal += amount
        return runningTotal
    }
    return incrementer
}

let increaseByThree = makeIncrementer(forIncrement: 3)

print(increaseByThree())    // 3
print(increaseByThree())    // 6
print(increaseByThree())    // 9

---

Reference

1. “Closures.” The Swift Programming Language Swift 5.7. accessed Oct. 24, 2022, Swift Docs Chapter 5 - Closures.