[Swift] 공식 문서 정리 (7) - Closures (클로저)

안녕하세요, 감자입니다. 오늘은 클로저에 대해서 공식문서를 정리해봤어요. 정리해도 정말 모르는것 투성이네요.. 클로저는 중요한 부분인 만큼 추후에 각각 개별 포스팅을 통해 다시 공부해보도록 하고, 오늘은 일단 정리하고 모든 개념에 눈을 떴다~ 지시긍ㄹ +1 만큼 얻었다 하고 넘어가보죠. 추후에 escape 클로저, 후행클로저, autoclosure 에 대해서 또다른 포스팅을 할 예정입니다. 학습은 즐겁군!

Swift Document chap.07 Closures 바로가기

Closures — The Swift Programming Language (Swift 5.6)

 

---

Closures

클로저는 코드에서 사용하고 전달할 수 있는 독립된 기능 블럭이다. 타 언어들에서는 lambda식 과 비슷한 기능을 가진다.

클로저는 자신을 정의한 곳의 어떤 상수와 변수에 대한 참조든 capture하고 저장할 수 있다. 해당 변수와 상수를 잠근다 (closing over) 라고 이야기한다. 스위프트는 이렇게 ‘capturing’에 대한 모든 메모리 관리를 직접 처리한다.

• note) capturing 에 대한 개념은 아래 capturing Values 에서 자세하게 설명할 예정이다.

전역함수와 중첩함수는 Funtions(함수) 단원에서 소개한 것처럼, 특수한 경우의 클로저이다. 클로저는 아래 세가지 형식 중에 하나를 취한다.

1. 전역함수는 ‘이름은 있지만 어떠한 값도 붙잡지 않는 클로저' 이다.
2. 중첩함수는 ‘이름이 있으며 자신을 둘러싼 함수의 값을 붙잡을 수 있는 클로저'이다.
3. 클로저표현식은 ‘자기 주위의 값을 붙잡을 수 있는 가벼운 구문으로 작성한 이름 없는 클로저' 이다.

스위프트의 클로저 표현식은 깔끔하고, 명확한 스타일을 가지고, 일상적인 상황에서 간결하고, 번잡하지 않은 구문이 되도록 최적화한다.

• 상황으로 매개변수와 반환 값 타입을 추론함
• 단일-표현식 클로저로 암시적으로 반환함
• 짧게 줄인 인자 이름
• 뒤에 딸린 클로저 (trailing closure) 구문

---

Closure Expressions (클로저 표현식)

클로저 표현식은 간결하고 집중된 구문으로 인라인 클로저를 작성하는 방법이다. 클로저 표현식은 의도를 잃지 않고도 클로저를 줄임 형식으로 작성하는 여러가지 구문 최적화를 제공한다.

 

The Sorted Method (정렬 메서드)

스위프트 표준라이브러리는 알려진 타입의 값 배열을 제공한 정렬 클로저 출력을 기초로 정렬하는 sorted(by: ) 라는 메소드를 제공한다. 이 메소드는 올바르게 정렬한 원소를 가진 예전과 똑같은 타입의 크기의 새로운 배열을 반환한다. sorted(by: ) 메소드는 원본배열을 수정하지는 않는다.

정렬 메서드는 값을 한 번 정렬하고 나면 첫번째 값이 두번째 값 앞에 있어야 하는 지 뒤에 있어야 하는지 알려주는 Bool 값을 반환하는 클로저를 받아들인다. 정렬 클로저는 첫 번째 값이 두 번째 값 앞에 있어야하면 true를 반환하고, 그 외 경우이면 false를 반환할 필요가 있다.

아래 예제는 String값 배열을 정렬하므로, 정렬 클로저는 (String, String) -> Bool 타입의 함수일 필요가 있다.

아래 예제는 올바른 타입인 보통의 함수를 작성하고 이를 sorted(by: ) 메서드 인자로 전달했다.

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

func backward(_ s1: String, _ s2: String) -> Bool {
  return s1 > s1
}
var reversedNames = names.sorted(by: backward)
// reversedNames 는 ["Ewa", "Daniella", "Chris", "Barry", "Alex"] 와 같음

이는 본질적으로 단일-표현식 함수 (a > b) 를 작성하기에는 다소 좀 길고 지루한 방식이다. 이 예제의 정렬 클로저를 클로저 표현식 구문 표현을 사용하여 ‘인라인 (inline)’ 으로 작성하면 더 좋을 것 이다.

 

Closure Expression Syntax (클로저 표현식 구문)

클로저 표현식 구문의 일반 형식은 아래와 같다.

클로저 표현식 구문의 매개변수는 입-출력(in-out) 매개변수일 순 있지만, 기본값을 가질 순 없다. 가변 매개변수 이름을 붙이면 가변 매개변수를 사용할 수 있다. 튜플도 매개변수 타입과 반환타입으로 사용할 수 있다.

아래 예제는 위에서 구현했던 backward() 함수의 클로저 표현식 버전이다.

reversedNames = names.sorted(by: { (s1: String, s2: String ) -> Bool in
	return s1 > s2
})

이 인라인 클로저의 매개변수 및 반환 타입 선언은 backward() 함수에 있는 선언과 모든점에서 똑같다는 점을 기억하자. 두 경우 모두 (s1: String, s2: String) -> Bool 로 작성한다. 하지만 인라인클로저 표현식에서는 중괄호 밖이 아니라 안에 매개변수와 반환 타입을 작성했다.

클로저 본문은 in 키워드로 시작한다. 이 키워드는 클로저 매개변수와 반환 타입 정의는 종료했고, 클로저 본문을 시작한다고 지시한다.

클로저 본문은 아주 짧기 때문에 심지어 한줄로도 작성 가능하다. 위의 예제처럼 return 에서 엔터를 치지 않아도 된다.

reversedNames = names.sorted(by: { (s1: String, s2: String) -> Bool in return s1 > s2})

 

Inferring Type from Context (타입 추론하기)

정렬 클로저를 메서드 인자로 전달하기 때문에, 스위프트가 매개 변수 타입과 반환 값 타입을 추론할 수 있다. sorted(by: ) 메서드를 문자열 배열에서 호출하고 있으므로, 인자는 반드시 (String, String) -> Bool 일 수 밖에 없다. 즉, String, Bool 과 같이 타입을 작성할 필요가 없다는 뜻이다. 결론적으로 모든 타입을 추론할 수 있기 때문에 매개변수 이름 주변의 반환 화살표의 괄호도 생략할 수 있다.

reversedNames = names.sorted(by: { s1, s2 in return s1 > s2 } )

• (note)
  원한다면 여전히 타입을 명시할 수 도 있으며, 코드를 읽을 때 모호함을 피할 수 있다면 작성하는게 좋긴 하다. 하지만 sotred 메서드처럼 ‘정렬이 일어난다'라는 목적이 명확하며 문자열 정렬을 거들고 있기 때문에 클로저가 string 이겠거니 하고 가정하고 생략해도 안전하다.

 

Implicit Returns from Single-Expression closures (단일-표현식 클로저의 암시적인 반환)

단일-표현식 클로저는 선언에서 return 키워드를 생략함으로써 단일 표현식을 암시적으로 반환할 수 있으며, 아래의 예제처럼 표현할 수 있다.

reversedNames = names.sorted(by: { s1, s2 in s1 > s2 } )

여기서 sorted(by: ) 메서드 인자의 함수 타입은 클로저가 반드시 Bool 값을 반환함을 명확하게 한다. 클로저 본문이 Bool 타입을 반환하는 단일 표현식 (s1>s2) 를 담고 있기 때문에 헷갈일 일이 없이 return 키워드를 생략 가능하다.

 

Shorthand Argument Names

스위프트는 인라인 클로저의, 인자 값을 $0, $1, $2, 등등의 이름으로 참조할 수 있는, 짧게 줄인 인자 이름을 자동 제공한다.

클로저 표현식 안에서 짧게 줄인 인자 이름을 사용하면, 정의에서 클로저 인자 목록을 생략할 수 있다. 짧게 줄인 인자 이름의 타입은 예상한 함수 타입으로 추론하며, 짧게 줄인 인자로 사용한 가장 높은 수는 클로저가 취한 인자 개수를 결정한다. in 키워드도 생략할 수 있는데, 클로저 표현식 전체가 자신의 본문만으로 이루어지기 때문이다.

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

여기서, $0과 $1 은 클로저의 첫 번째와 두 번째 String 인자를 참조한다.

 

Operator Methods (연산자 메서드)

실제로는 위 클로저 표현식을 더 짧게 표현하는 방식이 있다. String 타입은 문자열에 특화된 자신보다 큰 연산자(>) 구현으로 String 타입의 매개 변수 두 개를 취하고, Bool 타입 값을 반환하는 메서드를 정의한다.

reversedNames = names.sorted(by: >)

---

 

Trailing Closures (후행 클로저)

클로저 표현식을 함수의 최종 인자로 전달할 필요가 있는데, 클로저 표현식이 아주 길다면, 후행 클로저로 대신 작성하는게 유용할 수 있다. 후행 클로저는 함수 호출 괄호 뒤에 작성하는 것일지라도, 여전히 함수 인자이다. 뒤에 후행클로저 구문을 사용할 때는, 함수 호출에서 첫 번째 클로저의 인자 이름표 (argument label) 를 작성하지 않는다. 함수 호출은 후행 클로저를 여러 개 포함할 수 있다. 아래 첫 몇몇 예제는 후행 클로저를 하나만 사용한 예시이다.

func someFunctionThatTakesAClosure(closure: () -> Void) {
  // 함수 본문을 여기에 둠
}

// 다음은 후행 클로저를 사용하지 않고 이 함수를 호출하는 방법입니다:

someFunctionThatTakesAClosure(closure: {
  // 클로저 본문을 여기에 둠
})

// 다음은 후행 클로저를 가지고 이 함수를 호출하는 방법입니다:

someFunctionThatTakesAClosure() {
  // 후행 클로저 본문을 여기에 둠
}

 

• 아까전에 위에서 봤던 closure Expression Syntax 에 있는 문자열 정렬 클로저는 후행 클로저로 sorted(by: ) 메서드 괄호 밖에 작성할 수 있다.

reversedNames = names.sorted() { $0 > $1 }

• 추가로 또 줄일 수 있다. 함수나 메서드에 제공한 유일한 인자가 클로저 표현식인데, 그 표현식 을 후행 클로저로 제공한다면, 함수를 호출할 때 함수나 메서드 이름 뒤에 () 를 작성할 필요가 없다.

reversedNames = names.sorted { $0 > $1 }

 

 

후행 클로저는 한 줄로 작성하는게 불가능할 정도로 클로저가 길 때 유용하게 사용된다.

한 예로, 스위프트 Array 타입에는, 클로저 표현식을 단일 인자로 취하는, map(_:) 메소드가 있따. 배열의 각 항목마다 클로저를 한 번씩 호출하며, 해당 항목의 (다른 타입일 수도 있는) 대체 맵핑 값을 반환한다. map(_:) 에 전달할 클로저에 코드를 작성함으로써 맵핑의 본성과 반환 값 타입을 지정한다.

제공한 클로저를 각각의 배열 원소에 적용한 후, 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]

위 코드에서 정수 숫자와 영어 버전 이름 사이의 매핑에 대한 딕셔너리를 생성했다. 이제 클로저 표현식을 배열의 map(_:) 메서드 후행클로저로 전달함으로써 numbers 배열로 String 값 배열을 생성할 수 있다.

 

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
}
// strings 는 [String] 타입인 것으로 추론함
// 그 값은 ["OneSix", "FiveEight", "FiveOneZero"] 임

• 코드 설명
  1. map 메서드는 배열의 각 항목마다 클로저 표현식을 한 번 씩 호출한다.
  2. number 라는 클로저의 입력 매개변수, 타입은 지정할 필요가 없는데 맵핑할 배열의 값으로 타입을 추론하기 때문이다. (number: Int) 생략
  3. 이 예제에서는 클로저의 number 매개변수 값으로 number 값을 초기화하므로, 클로저 본문에서 값을 수정할 수 있다. (함수와 매개변수는 항상 상수이다.)
  4. 클로저 표현식은 맵핑한 출력 배열이 지정할 타입을 지시하는 String 이라는 반환 타입도 지정한다.
  5. 클로저 표현식을 매번 호출할 때마다 output 이라는 문자열을 제작한다.
  6. 이는 나머지 연산자 (number % 10) 을 써서 number 마지막 숫자를 계산하고, 이 숫자로 digitNames 딕셔너리에서 적절한 문자열을 찾아본다.
  7. 클로저를 사용하면 0보다 큰 어떤 정수의 문자열 표현이든 생성 가능하다.
  8. digitNames 딕셔너리에서 가져온 문자열을 output 앞에 추가하여 사실상 수치 값의 문자열 버전을 역순으로 제작한다. (표현식 nubmer % 10 은 16이면 6, 58이면 8, 510이면 0을 반환)
  9. 그런 다음, number 변수를 10 으로 나눈다. 정수이기 때문에 나눗셈중에 값을 잘라 16이면 1, 510이면 51이 된다.
  10. 이 과정을 반복하다가 number 가 0이 되는 순간에 클로저가 output문자열을 반환하고 map(_:)메서드가 출력 배열에 이를 추가한다.
  • (note)
  • digitNames 딕셔너리의 첨자 연산 호출 뒤에 ! 를 붙였다. 이는 key가 존재하지 않을 경우 딕셔너리 찾아보기가 실패할 수 있다는 것을 지시하고자 딕셔너리 첨자 연산이 옵셔널 값을 반환하기 때문이다. 위 예제에서는 number % 10 가 digitNames 딕셔너리의 유효한 첨자연산 key 라는 것을 항상 보증하므로 느낌표를 사용하여 강제로 wrapping을 풀어주었다.

 

---

 

Capturing Values (캡처값)

클로저는 자신의 주위에 있는 상수와 변수를 캡처할 수 있다. 그러면 상수와 변수를 정의한 영역이 더이상 존재하지 않는 경우에도, 클로저가 해당 변수와 상수를 참조할 수 있다.

스위프트에서 값을 캡처할 수 있는 가장 단순한 형식의 클로저는 중첩함수이다. 중첩함수는 자기 바깥의 함수의 어떤 인자든 캡처할 수 있고, 바깥 함수에서 정의한 어떤 상수나 변수 역시도 캡처 가능하다.

 

• 다음 예제는 incrementer라는 중첩함수를 담고있는 makeIncrementer 함수이다.
• 여기서 incrementer() 함수는 reunningTotal 과 amount 라는 값을 캡처한다.
• 이 값을 캡처하게 되면, 호출될 때마다 makeIncrementer 가 runningTotal 을 amount 만큼 증가시키는 클로저로써 incrementer 를 반환함

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

 

intercrementer 함수만 따로보면, 어떤 매개변수도 가지지 않는다는 것이 특이하다. 이 함수는 runningTotal 과 amount를 참조한다. 참조로 캡처한다는 것은 makeIncrementer 호출이 끝났을 때도 runningTotal, amount 가 사라지지 않도록 보장하고, 다음번 incrementer 함수 호출 시에도 캡처한 두 변수 모두 사용 가능하도록 보장한다.

실제 사용 예시는 다음과 같다.

incrementer 함수를 호출할 때마다 runningTotal의 값이 10 씩 증가하는 것을 볼 수 있다. 즉 값이 사라지지 않고 계속 유지되는 것이다. 클래스의 인스턴스 타입에 클로저를 할당하고 클로저가 클래스의 인스턴스를 참조하면 클로저와 인스턴스 간에 강력한 참조 주기가 생성된다.

let incrementByTen = makeIncrementer(forIncrement: 10)

incrementByTen()
// 10 이라는 값을 반환함
incrementByTen()
// 20 이라는 값을 반환함
incrementByTen()
// 30 이라는 값을 반환함

let incrementBySeven = makeIncrementer(forIncrement: 7)
// 자신만의 runningTotal 변수가 생성되기 때문에 기존 incrementByTen에 영향을주지 않는다.
incrementalBySeven()
// 7 이라는 값을 반환함
incrementByTen()
// 40 이라는 값을 반환함

---

 

Closures are Reference Type (클로저는 참조타입)

위 예제에서 incrementByTen 과 incrementBySeven 은 상수지만 이 상수를 참조하는 클로저는 자신이 캡처한 runningTotal 변수라는 점을 확인했다. 그리고 실행할때마다 여전히 10씩 증가했다. 이는 함수와 클로저가 참조타입이기 때문이다!

함수나 클로저를 상수나 변수에 할당하게 되면 상수나 변수에 복사되는 것이 아닌 메모리 주소만 참조하게 되고 이를 만약 다른 상수나 변수에 incrementByTen을 할당하면 다음과 같은 일이 일어나게 된다.

let alsoIncrementByTen = incrementByTen
alsoIncrementByTen()
// 50 이라는 값을 반환함

incrementByTen()
// 60 이라는 값을 반환함

이렇게 하게 되면 위 코드는 두개의 호출이 똑같다는 것을 보여준다. 이 이유는, 둘 다 동일한 클로저를 참조하기 때문에 둘 다 증가하며 동일한 누적값을 보여준다.

---

 

Escaping Closures

Escaping 클로저는 클로저가 함수의 인자로 전달됐을 때, 함수의 실행이 종료된 후 실행되는 클로저이다.

클로저는 함수에 대한 인수로 클로저가 전달될 때, 함수를 escape 한다고 하지만, 사실은 함수가 반환된 후 호출된다. 클로저를 매개변수 중 하나로 사용하는 함수를 선언하면, 매개변수 타입 앞에 (@escaping) 키워드를 작성해서 클로저가 Escape될 수 있음을 나타낼 수 있다.

클로저가 Escape 할 수 있는 한 가지 방법은 함수 외부에 정의된 변수에 클로저를 저장하고, 이를 매개변수로 사용하는 것이다.

 

예를들어 비동기 작업을 시작하는 많은 함수는 completion handler (완료 핸들러) 로 클로저를 사용한다. 함수는 작업을 시작한 후 반환되지만 작업이 완료될 때까지 클로저가 호출되지 않는다. 클로저는 Escape 해야 나중에 호출 할 수 있는데 예를 들 면 다음과 같다.

var completionHandlers: [() -> Void] = []

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

여기서 클로저가 실행되는 순서를 살펴보자.

1. 클로저가 someFunctionWithEscapingClosure 함수의 completionHandler 인자로 전달됨.
2. 클로저 completionHandler 이 외부에서 선언된 Array에 추가함.
3. someFunctionWithEscapingClosure 함수가 값을 반환하고 종료됨.
4. 클로저 completionHandler는 아직 실행되지 않음.

completionHandler 는 함수의 실행이 종료되기 전에 실행되지 않기 때문에 escaping 클로저, 다시 말해 함수 밖에서 실행되는 클로저 이다. 이때 @escaping 을 사용하지 않으면 컴파일 오류가 발생한다.

 

self 를 참조하는 escaping 클로저는 더 신중하게 사용해야한다. escape 클로저에서 self 를 캡처하면 실수로 강력한 참조를 쉽게 만들 수 있다. 강한 참조를 만들게 되면 swift의 ARC로 인해 메모리 낭비가 발생할 수 있다. 일반적으로 클로저는 본문에서 변수를 사용해서 암시적으로 변수를 캡처하지만, self를 사용하는 경우 명시적으로 캡처를 해야한다. 예시를 살펴보자.

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

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

let instance = SomeClass()
instance.doSomething()
print(instance.x)
// "200" 을 인쇄함

completionHandlers.first?()
print(instance.x)
// "100" 을 인쇄함

위 코드를 보면, someFunctionWithEscapingClosure 함수에 전달된 클로저는 명시적으로 self를 나타냈다. 반대로 someFunctionWithNonescapingClosure 에 전달된 클로저는 Escape 클로저가 아니기 때문에 암시적으로 self 를 참조할 수 있다.

 

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

이 코드는 클로저의 캡처 목록에 포함해서 self를 캡처하고, 암시적으로 self를 참조하는 방법이다. self가 구조체, 열거형의 인스터스인 경우 언제나 self에 참조할 수 있다. 하지만 escape클로저는 이러한 가변적인 것에는 캡처를 할 수가 없다. 구조체와 열거형은 값 타입이기 때문에 이러한 참조가 일어날 수 없는 것이다! (구조체와 열거형은 변경 가능성을 공유하는 것을 허용하지 않는다.)

 

struct SomeStruct {
  var x = 10
  mutating func doSomething() {
    someFunctionWithNonescapingClosure { x = 200 }  // 됨
    someFunctionWithEscapingClosure { x = 100 }     // 에러
  }
}

즉 위와 같이 escape 클로저를 사용하지 않는 클로저만 구조체의 인스턴스를 참조할 수 있다. someFunctionWithEscapingClosure 를 호출하는 것은 self가 변경 가능하기 때문에 에러이다. 이는 escape 클로저는 구조체의 self를 변경 가능한 참조로 캡쳐할 수없다는 규칙을 위반하는 것이다.

추가) escaping closure에 대해서 정리가 잘 된 글

[Swift] Escaping 클로저 (@escaping)

[Swift] Escaping 클로저 (@escaping)

---

Autoclosures

Autoclosure 는 함수에 인수로 전달되는 표현식을 감싸기 위해 자동으로 생성되는 클로저이다. 매개변수를 가지지 않으며 호출될 때 그 안에 있는 표현식의 값을 반환한다. 편의를 위해서 AutoClosure를 사용할 때는 명시적인 클로저 대신 정규 표현식을 작성해서 함수의 매개변수를 감싸는 괄호를 생략할 수 있다.

Autoclosure를 수행하는 함수를 호출하는 것은 일반적이지만 이러한 함수를 구현하는 것은 일반적이진 않다. 예를들어 assert(condition:message:file:line:) 함수는 condition, message 매개변수를 위해 Autoclosure를 사용한다. condition 매개변수는 디버그 빌드에서만 사용되고 message매개변수는 condition이 false일 때 사용된다.

Autoclosure를 사용하면 클로저를 호출할 때까지 내부 코드가 실행되지 않기 때문에 사용이 지연된다. 이렇게 지연되는 것은 계산 비용이 크거나 부작용이 있는 곳에서 유용하게 쓰일 수 있다. 이는 코드 사용 시점을 제어할 수 있기 때문이다. 에시를 살펴보자.

var customersInLine = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
print(customersInLine.count)
// "5" 를 인쇄함

let customerProvider = { customersInLine.remove(at: 0) }
print(customersInLine.count)
// "5" 를 인쇄함

print("Now serving \\(customerProvider())!")
// "Now serving Chris!" 를 인쇄함
Print(customersInLine.count)
// "4" 를 인쇄함

위와 같은 코드에서 customersInLine 배열에 있는 항목들을 customerProvider에서 클로저 내부 코드로 제거하지만, 실제로는 제거가 되지 않는다는 것을 볼 수 있다. 즉 클로저가 실제로 호출되지 않는 이상 수행이 되지 않는 것이다. 실제로 호출을 하게 되면 클로저 내부 코드를 수행해 배열의 항목이 하나 제거 되는 것을 볼 수 있다. 그리고 customerProvider 타입은 string이 아니라 매개변수가 없고 문자열을 반환하는 함수인 () -> String 이라는 점을 기억하자.

 

// customersInLine 은 ["Alex", "Ewa", "Barry", "Daniella"] 임
func serve(customer customerProvider: () -> String) {
  print("Now serving \\(customerProvider())!")
}
serve(customer: { customersInLine.remove(at: 0) })
// "Now serving Alex!" 를 인쇄함

위 코드에서 serve 함수는 매개변수로 명시적으로 클로저를 받고 배열의 항목을 하나 제거하며 제거된 값을 반환받아 print로 출력하는 함수이다.

 

// customersInLine 은 ["Ewa", "Barry", "Daniella"] 임
func serve(customer customerProvider: @autoclosure () -> String) {
  print("Now serving \\(customerProvider())!")
}

serve(customer: customersInLine.remove(at: 0))
// "Now serving Ewa!" 를 인쇄함

위 코드는 이전에 선언한 serve 함수에 @autoclosure 키워드를 사용하여 autoclosure를 사용한 것이다. 이렇게 하면 클로저를 호출할 때 마치 String타입을 사용하는 것처럼 함수를 호출할 수 있다. @autoclosure 를 붙이게 되면 인수가 자동으로 클로저로 변환된다.

 

만약 autoclosure 과 escape 클로저를 둘 다 사용하고 싶다면 그것도 가능하다.

// customersInLine 은 [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.")
// "Collected 2 closures." 를 인쇄함
for customerProvider in customerProviders {
  print("Now serving \\(customerProvider())!")
}
// "Now serving Barry!" 를 인쇄함
// "Now serving Daniella!" 를 인쇄함

위와 같이 collectCustomerProviders의 매개변수 customerProvider로 전달된 클로저를 호출하는 대신 collectCustomerProviders 함수는 클로저를 customerProviders 배열에 추가한다. 배열은 collectCustomerProviders 밖에서 선언되었기 때문에 함수가 반환된 후 배열의 클로저가 실행될 수 있다. 즉 매개변수 customerProvider의 값이 함수의 범위를 벗어날 수 있어야 하는 것이다.

 

추가) Autoclosure의 사용방법과 예시에 대해서 설명이 잘 된 글

[Swift] @autoclosure란?

[Swift] @autoclosure란?

 

 

읽어주셔서 감사합니다. 잘못된 부분이 있으면 언제든지 말씀해주세요. 아직 클로저에 대해서 모든 것을 이해하지 않은 상황이라 틀렸을 수 있습니다 ㅠㅠ 클로저를 정복하는 그날까지 관련 포스팅은 끝까지 계속됩니다 허허