클로저(Closure)

아래의 글은 The swift programming language과 bbiguduk님, jusung님의 번역본을 보며 공부한 내용입니다.

✔️ 정의

• 자족 가능한 함수 블럭

📚 특징

• 전달되는 것도 가능, 코드 내부에서 실행되는 것도 가능
• 상수와 변수에 대해 참조를 캡쳐하고 저장할 수 있음(closing over)
• 맥락 상 파라미터와 반환값 타입 유추
• 단일 표현식 클로저의 암시적 반환(return 키워드의 생략)
• 약식 인자 이름($0)
• 후행 클로저 구문

❓종류

• Global Function(전역함수): 이름 O, 어떠한 값도 캡쳐하지 않는 클로저
• Nested Function(중첩함수): 이름 O, 값을 캡처하는 클로저
• Closure Expressions(클로저 표현식), Unnamed Closures: 이름 X, 값을 캡처하는 클로저

Clsoure Expressions

• 짧고 명료하게 inline closure를 작성하는 방법

Ex. sorted(by:)

• sorted(by:) 메서드는 인자로 클로저를 허용하고 있음
• 이때 클로저의 타입은 배열과 동일한 타입의 인자 두 개를 받고 오름차순인지 내림차순인지 판단할 수 있는 Bool값을 리턴하고 있음

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

// 이런 경우에 정렬 클로저는 (String, String) -> Bool 타입

1. 필요한 타입의 일반 함수를 작성하고 sorted(by:) 메서드에 인자로 전달하기

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

1. inline closure 방식으로 작성하기

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

// in 키워드로 클로저의 파라미터, 리턴 타입 정의가 끝났고 이 뒤부터 body가 시작됨을 알려줌

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

1. 맥락 상 타입 유추

• 함수, 메서드에 클로저를 inline closure 표현식으로 전달하면 항상 파라미터 타입과 반환 타입을 유추할 수 있음
• 클로저가 함수 인자로 사용될 때 완전한 형태로 작성할 필요가 없다는 뜻!!

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

1. 단일 표현 클로저의 암시적 반환(Implicit Returns from Single-Expression Closures)

• 클로저가 한 줄로 표현돼있는 경우 return 키워드 생략이 가능

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

1. 짧은 인자 이름 (Shorthand Argument Names)

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

1. 연산자 메서드 (Operator Methods)

reversedNames = names.sorted(by: >)

⛏ 후행 클로저(Trailing Closure)

• 함수의 마지막 인자로 함수에 클로저를 전달해야하거나, 클로저 표현식이 긴 경우 주로 사용함
• 함수의 인자이지만 함수 호출의 소괄호 이후에 작성함

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

// Here's how you call this function without using a trailing closure:

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

// Here's how you call this function with a trailing closure instead:

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

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

• 만약에 클로저가 유일한 인자의 경우, 함수 호출시 소괄호도 생략가능함

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

• 클로저가 길어서 한줄로 인라인이 불가능 할 때 후행 클로저를 유용하게 사용할 수 있음

// Int -> String으로 반환하기 위해 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]

// 배열의 값에서 타입을 유추할 수 있기 때문에 number 타입 언급필요x
let strings = numbers.map { (number) -> String in
		// 해당 number는 수정 가능(파라미터는 늘 상수)
    var number = number
    var output = ""
    repeat {
        output = digitNames[number % 10]! + output
        number /= 10
    } while number > 0
    return output
}
// strings is inferred to be of type [String]
// its value is ["OneSix", "FiveEight", "FiveOneZero"]

• 함수가 여러 개의 클로저를 가지고 있다면 첫번째 후행 클로저의 argument label은 생략, 남은 후행 클로저만 표기

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

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

💡 캡처값(Capturing Values)

• 클로저는 선언된 함수 내부에서 상수, 변수를 캡처할 수 있음
• 이를 통해 상수, 변수가 정의된 범위가 더이상 존재하지 않더라도 body 내부에서 해당 상수, 변수의 값을 참조하고 수정할 수 있음
• 대표적인 예시: 다른 함수의 body 내부에 작성하는 중첩 함수
  • 중첩함수는 바깥 함수의 인자, 바깥 함수 내에 정의된 상수, 변수도 캡처할 수 있음

func makeIncrementer(forIncrement amount: Int) -> () -> Int {
    var runningTotal = 0
		// incrementer()는 runningTotal, amount 캡처함
    func incrementer() -> Int {
        runningTotal += amount
        return runningTotal
    }
    return incrementer
}

• makeIncrementer의 반환타입은 () → Int, 함수를 반환하고 있음

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

• 이렇게 단독으로 보면 비정상적인 함수처럼 보일 수 있음
• incrementer() 함수는 파라미터가 없기 때문에...하지만 runningTotal, amount를 캡처하고 있음
• 참조를 캡처한다 = makeIncrementer 함수 호출이 종료될 때 runningTotal, amount가 사라지지않고 다음 Incrementer 함수가 호출될 때 runningTotal을 사용할 수 있음

let incrementByTen = makeIncrementer(forIncrement: 10)

incrementByTen()
// returns a value of 10
incrementByTen()
// returns a value of 20
incrementByTen()
// returns a value of 30

• 새로 생성된 makeIncrementer 함수는 새로 분리된 runningTotal 변수에 참조 저장됨

let incrementBySeven = makeIncrementer(forIncrement: 7)
incrementBySeven()
// returns a value of 7

incrementByTen()
// returns a value of 40
// 기존 변수에 영향을 주지 않음

📂 참조타입

• 위에서 incrementBySeven, incrementByTen은 let으로 선언된 상수이지만 함수를 실행할 때 마다 return 값이 변하고 있음
• 이는 클로저가 참조 타입이기 때문에 가능함

let alsoIncrementByTen = incrementByTen
alsoIncrementByTen()
// returns a value of 50

incrementByTen()
// returns a value of 60

Escaping Closure(탈출 클로저)

• 함수가 반환된 후, 호출이 종료된 후에 호출되는 클로저
• 키워드 @escaping

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

• 이때 esacping closure 중 self가 클래스의 인스턴스를 참조하는 경우에는 주의해야함 → 강한 참조 사이클 생길 수 있기 때문에

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

class SomeClass {
    var x = 10
    func doSomething() {
				// escaping 클로저의 경우, 함수가 호출된 후에 실행되기 때문에 함수의 프로퍼티인 x임을 나타내기 위해서 self가 필요함
        someFunctionWithEscapingClosure { self.x = 100 }
        someFunctionWithNonescapingClosure { x = 200 }
    }
}

let instance = SomeClass()
instance.doSomething()
print(instance.x)
// Prints "200"

completionHandlers.first?()
print(instance.x)
// Prints "100"

• self를 캡처하고 암시적으로 참조하는 것도 가능

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

• 만약에 self가 struct, enumeration의 인스턴스면 항상 암시적으로 self 참조가 가능함(값타입)
• 하지만 escaping closure는 값타입인 self를 변경 가능한 참조(mutating)로 캡처할 수 없음

struct SomeStruct {
    var x = 10
    mutating func doSomething() {
        someFunctionWithNonescapingClosure { x = 200 }  // Ok
        someFunctionWithEscapingClosure { x = 100 }     // Error
    }
}

Autoclosure

• 함수에 인자로 전달되는 표현식을 래핑하기 위해 자동으로 생성되는 클로저
• 인자를 가지지 않으며 호출될 때 내부에 래핑된 표현식의 값을 반환
• 함수를 선언한 후 호출하기 전까지는 실행되지 않음(지연효과)

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

// () -> String 타입을 가짐
let customerProvider = { customersInLine.remove(at: 0) }
print(customersInLine.count)
// Prints "5"

// 할당 후 실행시켜야함
print("Now serving \(customerProvider())!")
// Prints "Now serving Chris!"
print(customersInLine.count)
// Prints "4"

• 함수의 인자로 클로저를 전달해도 같은 효과를 볼 수 있음

// customersInLine is ["Alex", "Ewa", "Barry", "Daniella"]
func serve(customer customerProvider: () -> String) {
    print("Now serving \(customerProvider())!")
}
serve(customer: { customersInLine.remove(at: 0) } )
// Prints "Now serving Alex!"

• 파라미터에 @autoclosure를 작성하면 클로저 대신 string을 받는 것 처럼 작성할 수 있음

// customersInLine is ["Ewa", "Barry", "Daniella"]
func serve(customer customerProvider: @autoclosure () -> String) {
    print("Now serving \(customerProvider())!")
}
serve(customer: customersInLine.remove(at: 0))
// Prints "Now serving Ewa!"

• 자동 클로저와 이스케이핑은 동시에 사용할 수 있음

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