[Too Swift] 시즌1 1화. 클로저가 누군데 ? (who's mr. closure?)

Collection Iteration with Closure : Mr. closure와 함께하는, 컬렉션 이터레이션 

일련의 프로시져를 재사용하는, func이외의 또 다른 방법이 되는 ...
특히, 컬렉션들을 다룰 때 특히 유용한 ...
변수에 할당해, 다른 value들 처럼 "주고 받을 수 있는" ...
그 분 ...

이름 없는 함수 ...
Mr. closure를 소개합니다.

참고 : Raywenderlich 
"Swift Apprentice" 
https://store.raywenderlich.com/products/swift-apprentice

 

 

 

Closure Basics 클로저 쌩기초 + training

클로져는 둘러싼 환경의 변수나 상수를 자신의 scope으로 "close over"할 수 있어서, 클로저라는 이름이 만들어졌습니다. 이 close over vars. and consts. 는 capture한다고도 하는 데 추후에 자세히 설명해드리겠습니다. 지금은 걍 잊으세요 ^^ 영어로만 써서 죄송해요. 지대로 설명하는 부분에는 순우리말로 지대로 쓰겠습니다.

 

 

----> 1). 어떻게 만드나요?

var multiplyClosure: (Int, Int) -> Int

우선, 클로저를 담을 변수는, 다음과 같이 타잎을 명시할 수 있습니다. 함수를 주고 받을 때와 동일하죠.

 

 

----> 2). 값은 어떻게 assign 하는 데요?

---- ----> 1. 표준형

// 타잎 명시 없을 때,타잎 추론 하는 것도 잘 보세요 ^^
var multiplyClosure = { (a: Int, b: Int) -> Int in
	return a*b
}

// 사용
let result = multiplyClosure(4, 2)

  함수 선언할 때랑, 좀 다른 점이라면 입력에 대해 명시할 때, _ a: Int, by b: Int 와 같이 함수의 입력에  external argument label 외부에서 인자를 지칭하는 외부 라벨 따위는 없습니다. 클로저 자체가 간편한 함수 전달이 목적이니 최대한 가볍게 해야쥬. 그건 스위프트 언어 디자이너 맴입니다. 저희는 그저 따를뿐.

 

  이용 방법은 그냥 함수와 동일합니다. 클로져명(입력1, 입력2, ... 필요한 맨큼)

 

 

----> 3). Shorthand syntax 축약된 클로저 문법들

  애플 문서볼 때 아시겠지만,  다른 언어를 쓰다 스위프트 도큐먼트를 보면, 애플 텐션으로 바꾸고 줄여놓은 신택스에 뭔가 심오해보이는 좌절감을 받곤합니다. 그렇기에, syntax가 뭐가 중요해? 걍 알고리즘이 중요하지 --> 미래의 내 눈과 뇌를 위해 신택스 지식을 선물할게 라는 마인드로 공부해보는 게 나쁘지 않아보입니다.    AI AI AI !! 아니고  syntax, syntax, syntax !! 

아래와 같이 신택스를 만든 데는 별다른 이유가 없습니다 -> 애플스럽게, 같은 명령을 어떻게 하면 최대한 적게 타이핑하면서도 명료하게 만들 까하다가 만들어진 것일 것입니다.

 

1).  파라미터 리스트: 유지, 리턴 타잎: 유지, in키워드: 유지, return키워드: 생략 : 리턴할 항목을 한 줄 이내에 전달할 수 있다면, 그것만 써도 컴파일러가 알아서 컴파일 해줍니다.

multiplyClosure = { (a: Int, b: Int) -> Int in
	a * b
}

 

2).  파라미터 리스트: 인터널 라벨만 유지, 리턴 타잎: 생략, in키워드: 유지, return키워드: 생략 

/ * 이미 타잎 외적으로 명시한 경우가 있을 경우
var multiplyClosure = { (a: Int, b: Int) -> Int in
	return a*b
}
*/

// 간략하게 재지정 해주기 (이름1, 이름2) in 이름1 * 이름2
multiplyClosure = { (a, b) in
	a * b
}

 

3). 파라미터 리스트: 생략, 리턴 타잎: 생략, in키워드: 생략, return키워드: 생략  : + 입력 인자를 $0, $1로 지칭

이 신택스도 자주 쓰이니 !! 신택스 ! 신택스! 신택스! 한 번 타이핑 해보시면서 익히시면 좋을 것 같습니다.

// pass function as a parametre
func operateOnNumbers(_ a: Int, _ b: Int, operation: (Int, Int) -> Int ) -> Int {
    
    let result = operation(a, b)
    print(result)
    return result
    
}

// 클로져를 인자로 전달
operateOnNumbers(4, 2, operation: { $0 + $1 })

위의 함수는 operation 인자로 (Int, Int) -> Int 라는 함수 또는 클로저(이름 없는 함수)를 받습니다. 이러한 상황에, 클로저를 전달해주시면 됩니다. 위에서도 첫 번째 인자와, 두 번째 인자를 더한 값을 리턴한다는 클로져를 인자로 전달하였고, 저희가 이미 위에서 함수를 정의할 때, 타잎에 대해서는 이런 이런 인풋이 들어올 것이다라는 것을 명시해 두었기 때문에, operation인자로,

타잎이 명시되지 않은

params list, in keyword, return 등이 생략된

클로저를 전달해도, 컴파일러가 함수를 추론해낼 수 있습니다.

Trailing Closure Syntax

스위프트를 보면, 매우 이상한 형식의 함수 호출을 볼 수 있는데,

여기서 "trailing closure syntax"에 대해서 이야기 해보려 한다. 

 

위에서는 " operation: 이라는 인자에 { $0 + $1 } 라는 클로져를 전달"하는 방식으로 클로져를 호출했는데,

스위프트는 만약, 인자 중 마지막이 함수를 받는 경우에는, 더 더 더 간단한 신택스를 써서, 같은 방식으로 함수를 호출할 수 있게 해준다.

operateOnNumbers(4,2){
	$0 + $1
}

* 만약, 어떤 함수의 마지막 인자가 함수라면, 1). 인자 라벨을 생략하고, 다음과 같이 아예 2). (   ) 밖에 클로져를 후행하는trailing 방식으로 전달할 수 있습니다. 매우 작은 (  ) parenthesis 안에 전달하는 것보다, 아예 길어질 수 있는 클로져가 들어가는 경우는 ( )에 trailing(후행하는) 전달 방식을 사용할 수 있게 해주는 것으로 보입니다.  

empty params list and empty return 

let voidClosure2: () -> Void = {
	print("Swift is so awesome")
}

// also possible
let voidClosure3: () -> () = {
	print("Swift is so awsome")
}

만약, 스위프트가 매개변수가 필요 없거나, 아무 것도 리턴하지 않는다면 위와 같은 두 가지 옵션이 있습니다. 함수식 표현을

타잎에 명시해주어야하는데, ( ) -> Void 또는 -> ( )와 같이 명시해주면 됩니다.

 

 

----> 4). Closure Capture : < capture variables from enclosing scope >

  클로저는 그것을 둘러싼 환경에 있는 entities(변수, 상수)를 캡쳐해서, 수정할 수 있습니다. 즉, 클로저가 정의된 것을 둘러쌓은 외부 환경의 변수나 상수의 scope은 클로저 내부도 포함된다는 것입니다.

func countingClosure() -> () -> Int {
    
    // 로컬 변수
    var counter = 0
    
    // 함수의 로컬 변수를 캡쳐하는 클로져, 그 것에 +1을 하고 리턴 한다
    let incrementCounter: ( ) -> Int = {
        counter += 1
        return counter // 위의 프로시져를 진행하고 counter를 리턴한다.
    }
    
    // 그렇게 캡쳐해서, +1을하고 리턴해준다는 인크리먼트 카운터 "클로져를 리턴"
    return incrementCounter
}

// 
counter1 = countingClosure()
counter2 = countingClosure()
counter1( ) // 1
counter1( ) // 2
counter2( ) // 1
counter2( ) // 2

 surrounding environment's entities를 capture한다는 것은 무슨 뜻일까요? 캡쳐라는 게 어떤 것을 포착해서 가지고 있는 다는 뜻이죠? 저희도 유투브 동영상의 한 순간을 캡쳐해서 가지고 있게됩니다. 클로져의 캡쳐도 비슷한 개념으로 작동합니다.

 

 위에서 보면, countingClosure함수를 호출하면, 로컬 변수인 counter가 생성되고, incrementCounter라는 클로져는 그 때 생성된 로컬 변수를 캡쳐해놓습니다. 이때 이 클로져는 이 로컬 변수를 "레퍼런스" 변수 화 합니다. 그 값을 힙 메모리로 옮겨, 그것에 대한 레퍼런스를 가지고 있으며, 그것을 counter라고 부르게 됩니다. 그렇게 counter라는 힙 메모리 상 데이터에 대한 레퍼런스를 캡쳐해낸 클로져가 리턴되는 데, 이때 만약 counter가 함수의 로컬 변수였으면, save되지 않아 유지될 수 없습니다. 하지만, 클로져는 그것을 힙에 저장해 counter라는 이름으로 가지고 있으면, 클로져가 해당 데이터에 대한 레퍼런스를 유지하기 때문에 지워지지 않습니다.

 

  첫 번째 카운팅클로져( )를 호출하면, 그때 카운터 변수를 캡쳐하여 레퍼런스를 가지고 있는 클로져인 counter1 이 생깁니다. 그리고 두번째 호출할 때는 또 그때 생성되어 힙에 저장된 레퍼런스 counter가 생깁니다. 각 클로저 내에서는 힙 메모리 상의 다른 위치에 대해 같은 이름의 레퍼런스 변수를 가지게 됩니다. 

 

 각각 서로 다른 위치의 힙 메모리상 데이터, 동명의 다른 데이터를 각각 +1 +1 하면서 리턴해주고 있습니다. 

캡쳐라는 것의 개념이 와닿지 않아 좋은 블로그 글을 참고하여 이해하게되어, 이 글을 공유합니다. 감사합니다. 출처 :

https://velog.io/@kimdo2297/%ED%81%B4%EB%A1%9C%EC%A0%B8-%EC%BA%A1%EC%B3%90%EC%97%90-%EB%8C%80%ED%95%B4%EC%84%9C-about-closure-capture 

클로저 캡쳐에 대해서 (about closure capture)

>>> Human is pattern making pro !!

>>> 연습해 봅시다 : 이번에는 클로저가, 자신이 정의되고 있는 함수 프로시저 내에서,

- 파라미터

- 지역변수

모두를 캡쳐해서 유지합니다.

func makeIncrementer(forIncrement amount: Int) -> () -> Int {
    
    var runningTotal = 0 // local 변수를 매김 => 캡쳐해서 => 힙으로 옮겨서 해당 지칭을 유지하는 클로저
    
    let incrementer = { ( ) -> Int in
        runningTotal += amount // 파라미터인 amount 캡쳐해서 레퍼런스 유지, runningTotal도 찰칵!!
        return runningTotal
    }
    
    return incrementer
}

let incrementer5 = makeIncrementer(forIncrement: 5)
let incrementer10 = makeIncrementer(forIncrement: 10)

incrementer5( ) // 5
incrementer10( ) // 10

incrementer5( ) // 10
incrementer10( ) // 20

incrementer5( ) // 15
incrementer10( ) // 30

 

 

----> 5). Easy collections control using: Closure

이제, 클로저를 배운 것을 누려봅시다. 가장 유용한 방향은 바로, 컬렉션을 간결하게 가지고 놀기. Too Swift !!

 

  클로져의 신택스를 알면, 스위프트의 컬렉션 타잎들을 매우 간단한 형태로 통제할 수 있는, 컬렉션 라이브러리가 갖추어져 있습니다. "함수형 프로그래밍"을 지향하는 스위프트에서는, 컬렉션 오퍼레이션에 인자로서 "클로져"를 전달하는 방식으로 작동하는 경우가 많고, 이때 closure trailing syntax를 사용하면, 이러한 것들이 신택스적으로 매우 간단하게 해결 가능한 경우가 많습니다. 

1). 정렬 문제 해결

let names = [ "zebra", "boeing", "ace", "create", "eastern"]

// 첫 번째 아규먼트가 더 커야해
1).
names.sorted{
    $0.count > $1.count 
} 

// 첫 번째 아규먼트가 더 작아야해
2).
names.sorted{
    $0.count < $1.count
}

// 도큐먼트 참고
// 인자 설명
// areInIncreasingOrder : 	
// A predicate that returns true if its first argument 
// should be ordered before its second argument; otherwise, false.

1 번째 아웃풋

 

2번 째 아웃풋

전제 조건 : 함수나 클로저를 전달해라. 만약 참일 경우, 첫번째 인자가 두번째 인자의 앞으로 가야하는 함수. 즉 정렬의 조건인 ( 정, 정 ) -> 불 클로저

 

2). Iterative operation : 컬렉션의 각 요소를 이터레이션하면서, 클로저에 제시한 프로시져를 실행

 

      1). 이터레이션 하며 각 요소에 대해 프로시져 수행 : forEach

let values = [1, 2, 3, 4, 5, 6, 8, 9]
values.forEach{
    print("\($0): \($0*$0)")
}

// 컬렉션의 각 요소를 이터레이션 하며, 각 요소에 대해 다음을 실행

 

      2). 필터링 : 각 요소에 불린 테스트 하여 필터링하여 true인 것만 리턴

var prices = [ 1.5, 10, 4.99, 2.30, 8.19 ]
let largePrices = prices.filter{
    $0 > 5
}

// original : 메소드가 적용되는 어레이의 값들의 타잎 Double, -> [Double]
func filter( _ isIncluded: (Element) -> Bool ) -> [ Element ]

let sucky = ["hi", "hilary", "dylan", "friendly", "dude"]

sucky.filter{
    $0.count > 4
}

.filter( ) 함수는 도큐먼트 상

컬렉션 데이터 타잎의 데이터를 받아 -> 불리언 값을 계산하는 클로져나 함수를 받아, 컬렉션 데이터 타잎에 해당하는 값을 내어놓는, 

클로져의 리턴값이 트루인 요소들만 걸러내는 함수입니다.

 

    3). 필터링 : 오직 첫번째 요소

print( prices.first{
    $0 > 5
} ?? 0 )



let sucky = ["hi", "hilary", "dylan", "friendly", "dude"]
sucky.filter{
    $0.count > 12
}
var result: String
let over10 = sucky.first(where: {$0.count > 10}) ?? "no such member"
over10

.first의 경우 빈어레이를 리턴하는 것이 아니라, 요소를 리턴하는 것인데, 값이 존재하지 않을 수 있으므로, 옵셔널로 리턴한다.

 위의 함수를 보면, predicate라는 패러미터를 where라는 아규먼트 라벨로 받고있는데, 패러미터는 클로져로 받는 것을 알 수 있습니다. 더블을 받아 불리언 값을 던져주는 함수 또는 클로저내요. 그리고 이 함수는 전체적으로는 -> < nil이나 Double >을 리턴합니다. 옵셔널 바인딩이나 닐 코얼리싱을 이용하여 받으면 되겠죠.

 

    4). 컬렉션.map : 컬렉션의 값들을 일괄적으로 특정 연산을 적용하거나, 형을 변환할 때 ( .compacetMap 유용 ) 

 

          1). 컬렉션에 일괄적용 map{ $0 * 0.9 }

          2). 컬렉션 일괄적 타입 컨버젼 ex). map{ Int($0) ?? 0 } : but, have to deal with nil

          3). nil없이 깔끔하게 컨버젼 .compactMap

//
let salesPrices = prices.map{
    $0*0.9
}

//
let userInput = ["0", "11", "haha", "42"]
let number1 = userInput.map{
    Int($0) ?? 0 // 파싱이 안될 수 있으므로, 닐 코얼리싱
}

number1

//
userInput.compactMap{
    Int( $0 )
}
// [0, 11, 42]

 

    5). 컬렉션.reduce : input으로 starting value, closure를 받는다. :

 

         1. $1은 이터레이션 하며 각 요소가 들어가고,

         2. $0은 current state : 즉 컬렉션을 요약한 현재 상태가 되며, 첫 인자가 처음에 그 값으로 초기화 됩니다.

         3. 계속 해서 클로져의 결과가 다시 $0으로 다시 들어가고, 다음 요소와 클로저 안의 연산이 진행됩니다.

let sum = prices.reduce( 0 ){
	$0 + $1
}

// 0과 클로져를 받았네요.
// 특징은 : 첫 번째 입력으로 들어간 0이 초기 $0 : current value의 값이 되고
// $1 : 컬렉션 각 요소와 +가 적용되게 됩니다.

" 클로져와 컬렉션 메소드를 이용해서, 몇 안되는 줄로, 컬렉션으로 부터 꽤 복잡한 의미있는 값을 계산할 수 있습니다.

let stock = [1.5: 5, 10: 2, 4.99: 20, 2.30 : 5, 8.19: 30]
let stockSum = stock.reduce(0){
    $0 + $1.key * Double($1.value)
}

//384.5

// 컬렉션인 사전에 적용하는 리듀스는,
// 0과 클로져를 입력으로 받고있고
// 그 클로져는, 더블값 하나와 튜플을 인풋으로 받습니다.
// 받은 튜플에서 key라는 값과 value라는 값을 더블로 변환할 걸 곱하고
// 더하여 "현재 상태값"을 만들며
// 이것은 다음 이터레이션 시에 다시 $0 값으로 집어 넣습니다.

 

         7). 사전자료구조.reduce( into: , _: closure )

 

예를 들어, 사전을 [String] array로 요약해버릴 것이라면, Result는 [String]이 될 것 입니다.

사전, 클로져 -> 컬렉션을 간편하게 주무르기

 

용도 : 1). 어레이 투 딕셔너리 프리퀀시 카운터, 2). 프리퀀시 투 어레이 늘어놓기 3). 사전의 값들 요약값 내어놓기

 

          연습 1).  컬렉션.reduce(into : ){  }  < String(시퀀스) -> 사전 >

익숙해지려면, 그냥 무한 연습. 무한으로 제대로 연습하면, 뇌에서 자동으로 패턴을 만든다고 하네요. ^^

이번엔 한 스트링이라는 시퀀스를 사전으로 reduce해보겠습니다. into에 집어넣은 [ : ] 빈 사전이 inout으로 레퍼런스 변수처럼 counts로 들어가고, 이터레이션할 때마다,  각 요소가 letters에 지정됩니다. 마지막으로 레퍼런스 변수인 사전 count의 값이 리턴됩니다. 

let letters = "abracadabra"
let letterCount = letters.reduce(into: [:]) {
    counts, letters in // 사전이랑은 다르게 counts <- [ : ] 가 들어가고, letters는 스트링
    counts[letters, default: 0] += 1
}

// dictionary default 값추가
var letterCount2 : [String: Int] = [ : ]
letterCount2["A", default: 1] += 1
letterCount2

 

          연습 2).  컬렉션.reduce(into : ){  }  < 사전 -> 어레이 >

let farmAnimals = ["🐎": 5, "🐕‍🦺": 4, "🐅": 6]
// dict into array of unicode animals by iterating

let animalArray = farmAnimals.reduce(into: []){
    
    (result, this: (key: String, value: Int)) in
    for _ in 0 ..< this.value {
        result.append(this.key)
    }
}

//-> ["🐅", "🐅", "🐅", "🐅", "🐅", "🐅", 
//"🐎", "🐎", "🐎", "🐎", "🐎", "🐕‍🦺", "🐕‍🦺", "🐕‍🦺", "🐕‍🦺"]

 

 

* 참고

기타 컬렉션 관련 유용한 메소드들입니다. ex). 처음 및 마지막 떨군 형태, 첫2개 마지막 2개를 슬라이싱한 리스트, 쿼리하여 true를 리턴하는 것들만 제거하는 메소드(mutating function)

// get the form that has dropped first and last.
// let removeFirst = prices.dropFirst()
// let removeFirstTwo = prices.dropFirst(2)
// let removeLast = prices.dropLast()
// let removeLastTwo = prices.dropLast(2)

// select first few, last few
// let firstTwo = prices.prefix(2)
// let lastTwo = prices.suffix(2)

// closure를 입력으로 받는 뮤테이팅 프로시져
prices.removeAll() { $0 > 15 }
// prices

//
// prices.removeAll()
// prices

 

----> 6). Lazy Collections 

     어떤 조건에 해당하는, 무한한 set의 컬렉션을 어떻게 다룰 수 있을까. ( 이것도 기억하세요 !!  functional programming을 이용하면 생산성에 좋다 )

 

우선 문제를 드릴게요 !! : 소수(prime number)를 첫 10개만 프린트하는 알고리즘을 짜보세요. 클래시컬하게, 굳이 함수형 플그래밍으로 하지 않는다고 한다면, 다음과 같이 짤 수도 있을 거에요.

1). 어떤 자연수를 넣으면 소수인지 아닌지 불리언을 리턴하는 함수를 만든다.

2). 소수들을 모을 어레이를 만든다. 그리고, 소수의 개수를 샐 카운트 변수를 만든다.

3). 카운트가 10보다 작을 동안, 소수 어레이에, 위 함수에서 트루를 리턴하는 값을 추가한다.

4). 소수들을 10개 모은 어레이에 .forEach{ print( $0 ) }를 적용한다.

// 1).
func isPrime( _ number : Int ) -> Bool {
    
    // 2,3 이면 바로 true
    if number == 1 {return false}
    if number == 2 || number == 3 {return true}
    
    // 아니라면, 그 숫자에 루트를 씌운 값을 내림한 값이 나누어 떨어진다면 false
    for i in 2...Int( Double(number).squareRoot() ){
        if number % i == 0 {return false}
    }
    
    // 그게 아니라면, true
    return true
}

// 2).
var primes: [Int] = []
var i = 1
while primes.count < 10 {    
    if isPrime(i) {
        primes.append(i)
    }
    i += 1
}


// 3).
primes.forEach{
    print($0)
}

 

이렇게 할 수도 있겠지만, 매우 단계가 복잡하고, 스위프트의 함수형 프로그래밍의 강점을 살리지 못하네요.

이럴 때는, 

1). 무한 레인지

그리고 ...

2). 컬렉션.lazy선언을 이용하면 좋을 거 같네요.

let primes2 = (1...).lazy  // hey swift !! it's lazy collection
//    A sequence containing the same elements as this sequence, but on which some operations, such as map and filter, are implemented lazily.
    .filter{isPrime($0)} // not mutating
    .prefix(10) // return an array of query
    // 이때까지 시퀀스가 생성되지도 않는다 !!
    
primes2.forEach{ print($0) }
// 이때 부터, 시퀀스가 필터링을 거치고, 첫 10개가 추려진다.

// 분석 !! 
(1...).lazy
    .filter{isPrime($0)}// 자연수를 가지는 부분적 레인지 객체
    .prefix(10)

이렇게 몇 줄 안에 끝낼 수 있습니다.

부분적으로만 레인지가 한정된 객체 - 정수로 이루어짐.

( 1... ) 

자연수로 1<= 인 컬렉션은 => .lazy한 컬렉션입니다. 사용될 때만 이 컬렉션에 가해지는 .filer, .prefix 등의 메소드가 적용됩니다. 지금은 그저 양수쪽으로 무한한 자연수 컬렉션이죠.

 

어디서 

primes2.forEach{ print( $0 ) }가 쓰였네요. 그럼, 이제 메소드들을 적용해야겠네요. 이게 => 필터링을 거치 어레이 => 여기에 10개만 남긴 어레이가 리턴되어 primes가 됩니다. 그러한 것에 대해 각 요소를 프린트 했습니다.

 

 

내용을 정리해보겠습니다. 영어로 정리하겠습니다 ^^

* 레이지 컬렉션은 엄밀하게, 필요한 경우에만 해당 요소에 메소드 오퍼레이션을 적용하므로, 매우 무한하거나 매우 큰 컬렉션을 다루는 데 효율적입니다.

 

 

 

읽어주셔서 감사합니다.

클로저예제는 많이 연습해보세요 ~

이렇게 헷갈리거나, 디테일이 복잡한 개념의 경우에는 좋은 예제를 수없이 풀어보면서

고뇌하고, 경험하는 수 밖에 없는 것 같습니다.

만약 클로저 예제가 필요하시면 7616tjrgml@naver.com으로 메일 주시면 좋은 예제들 보내드리겠습니다.