🧑🏻‍💻 함수2❗️❗️❗️(중요)

1. 일급 객체로서의 함수

  스위프트는 객체지향 언어이자 동시에 함수형 언어이다. 함수형 언어를 학습하게 되면 반드시 일급 객체(First-Class Object)라는 용어를 접하게 된다.

1-1 일급 함수의 특성

  객체가 다음 조건을 만족하는 경우 이 객체를 일급 객체로 간주한다.

1. 객체가 런타임에도 생성이 가능해야 한다.
2. 인자값으로 객체를 전달할 수 있어야 한다.
3. 반환값으로 객체를 사용할 수 있어야 한다.
4. 변수나 데이터 구조 안에 저장할 수 있어야 한다.
5. 할당에 사용된 이름과 관계없이 고유한 구별이 가능해야 한다.

  함수가 이런 조건을 만족하면 일급함수(First-Class Function) 이라고 하고 함수형 언어로 분류하고, 함수가 일급 객체로 대우받는다.

  1. 변수나 상수에 함수를 대입할 수 있음

	func foo(base: Int) -> String {
    	return "결과값은 \(base + 1)"
    }
    
    let fn1 = foo(base: 5)
    // 결과값은 6

  위 코드는 단순히 함수의 결과값을 대입하고 있다. 그러나 '변수나 상수에 함수를 대입한다'는 함수 자체를 대입하는 것이다. 함수 자체를 변수에 할당하면 변수도 함수처럼 인자값을 받아 실행이 가능하고, 값을 반환할 수 있다.

    let fn2 = foo
    fn2(5)
    // 결과값은 6

  상수 fn2에 foo 함수 자체를 대입하고 fn2에 함수 호출 연산자인( )와 인자값5를 넣어 호출할 수도 있고 결과값을 받을 수도 있다. fn2는 함수이다.

  또한 함수를 대입하기 위해 타입(Type)에 대해서도 알아야한다. 함수 타입은 함수의 형태에 따라 셀 수 없을 만큼 댜양한 구조를 갖는다. 변수에 정수를 대입하면 Int 타입이, 문자열을 대입하면 String 타입이 되는 것처럼, 변수에 함수를 대입하면 함수 타입이 되는 것이다.

	func boo(age: Int) -> String {
    	return "\(age)"
    } 
    
    //위 함수를 함수 타입으로 표현
    (Int) -> String
    
    
    // 위에 함수를 상수에 할당했을 때 타입 어노테이션을 포함한 할당 구문
    let fn: (Int) -> String = boo
    
    
    // 두 개의 인자값을 받는 함수
    func boo(age: Int, name: String) -> String {
    	return "\(name)"의 나이는 \(age)"
    }
    
    // 위 함수를 함수 타입으로 작성
    (Int, String) -> String
    
    // 정확한 식별자를 사용한 경우
    let s: (Int, String) -> String = boo(age:name:)
    
    
    
    ❗️개 중요❗️
    
    func boo(age: Int) -> String {
    	return "\(age)"
    } 
    
    func boo(age: Int, name: String) -> String {
    	return "\(name)"의 나이는 \(age)"
    }
    
    let t = boo(X) // 오류
    
    
    이런 경우 어느 함수를 가르키는지 정확하게 판단할 수 없으므로 오류가 난다.
    
    // 해결 방법 1) 타입 어노테이션을 통해 입력받을 함수의 타입을 지정
    let t1: (Int, String) -> String = boo
    
    // 해결 방법 2) 함수의 식별값을 통해 입력받을 정확한 함수를 지정
    let t2 = boo(age:name:)

  타입 어노테이션을 사용하는 경우에는 입력받을 값의 타입이 명확하기 때문에, boo 가 가르키는 함수가 다소 불확실하더라도 컴파일러가 찾아서 대입할 수 있다. 식별값을 통해 지정하는 경우에도 정확한 함수를 찾아 대입할 수 있기 때문에 문제가 되지 않는다.

	// 인자값이 없는 함수인 경우
    func foo() -> String {
    	return "Empty Values"
    }
    
    // 인자값이 없는 경우 함수 타입
    () -> String
    
    
    // 반환값이 없는 경우
    func boo(base: Int) {
    	print("param = \(base)")
    }
    
     // 반환값이 없는 경우 함수 타입
    (Int) -> ()
    (Int) -> Void // 이렇게도 가능
    
    
    // 인자값, 반환값이 모두 없는 경우
    func too() {
    	print("empty values")
    }
    
    // 인자값, 반환값이 모두 없는 경우 함수타입
    () -> ()
    () -> Void

  2. 함수의 반환 타입으로 함수를 사용할 수 있음

  일급 함수는 실행 결과로 정수, 실수, 문자열 등의 기본 자료형이나 클래스, 구조체 등의 객체를 반환할 수 있을 뿐 아니라 함수 자체를 반환할 수도 있다.

	func desc() -> String {
    	return "this is desc()"
    }
	
    func pass() -> () -> String {
    	return desc
    }

	let p = pass()
    p() // "this is desc()"

  위 코드에서 desc 라는 문자열을 반환하는 함수가 있고, pass 함수가 desc 함수를 반환하기 때문에 () -> String 으로 함수의 타입 표현을 하고 있다. 이 함수 타입의 표현이 pass 함수의 반환 타입으로 사용되고 있는 것이다.

  이어서 상수 p는 pass 함수의 실행 결과값을 할당받고 있다. pass 함수의 실행 결과는 desc 함수이므로 상수 p에는 desc 함수가 할당된다. 이제 상수 p는 desc 함수나 마찬가지이다. p에 함수 호출 연산자( ) 를 붙여 실행하면 desc 함수가 실행되는 것이다.

	
    // 함수의 반환타입으로 함수를 사용하는 예제

	func plus(a: Int, b: Int) -> Int {
    	return a + b
    }
	
    func plus(a: Int, b: Int) -> Int {
    	return a - b
    }
    
    func plus(a: Int, b: Int) -> Int {
    	return a * b
    }
    
    func plus(a: Int, b: Int) -> Int {
    	guard b !0 = else {
        	return 0
        }
    	return a / b
    }
    
    func calc(_ operand: String) -> (Int, Int) -> Int {
        switch operand {
        case "+" :
            return plus
        case "-" :
            return minus
        case "*" :
            return time
        case "/" :
            return divide
        default :
            return plus
        }
    }

  let res = calc("+")
  res(3,4) // plus(3, 4) = 7

  calc("-")(10, 10) // 0

  이처럼 함수의 실행 결과로 다른 함수를 반환할 수 있는 것이 일급 함수의 특성이다.

  3. 함수의 인자값으로 함수를 사용할 수 있음

  일급 함수는 반환값으로 함수를 사용할 수 있을 뿐 아니라 다른 함수의 인자값으로 함수를 전달할 수 있는 특성도 있다. 자바스크립트와 마찬가지로 스위프트에도 콜벡함수(CallBack Function)가 있는데 콜벡 함수는 특정 구문의 실행이 끝나면 시스템이 호출하도록 처리된 함수로, 콜벡 함수를 등록한다는 것은 실행하고자 하는 구문을 담은 함수를 인자값으로 넣는 것을 의미한다. 이 때 사용되는 개념이 '함수를 인자값으로 사용할 수 있다' 이다.

	//함수를 인자값으로 전달하는 예제
    
	func incr(param: Int) -> Int {
    	return param + 1
    }
    
    
    //매직코드라고도 함
    func broker(base: Int, function fn: (Int) -> Int) -> Int {
        return fn(base)
    }

    broker(base: 3, function: incr) // 4
    

1 - 2 함수의 중첩

  스위프트에서 함수는 중첩하여 작성할 수 있다. 함수 내에 다른 함수를 작성해서 사용할 수 있는 것이다. 중첩함수(Nested Function)은 함수 내에 작성된 함수인 내부 함수(InnerFunction)와 내부 함수를 포함하는 바깥쪽 함수인 외부 함수(Outer Function)으로 구분할 수 있다.

  함수를 중첩해서 정의하면 내부 함수는 외부함수가 실행되는 순간 생성되고, 종료되는 순간 소멸한다. 외부 함수는 프로그램이 실행될 때 생성되고 프로그램이 종료될 때 소멸하지만, 내부 함수는 외부 함수의 실행과 종료 사이에서 생겼다가 사라진다. 이것이 내부 함수의 생명주기(Life Cycle)이다.

  내부 함수는 일반적으로 외부 함수를 거치지 않으면 접근할 수 없다 이 때문에 내부 함수는 외부의 코드로부터 차단되는 결과를 가져오는데 이를 함수의 은닉성이라고 하며 중첩된 함수를 사용하면 함수의 은닉성을 높일 수 있다.

	// 외부 함수
    func outer(base: Int) -> String {
    	// 내부 함수
        func inner(inc: Int) -> String {
        	return "\(int)를 반환"
        }
        let result = inner(inc: base +1)
        return result
    }
	
    outer(base: 3) // 4를 반환

  위 코드에서 inner라는 함수는 외부에서 참조할 수 없으며 오직 outer 함수 내부에서만 참조할 수 있다. inner 함수는 외부로부터 은닉되어 있는 것이다.

  내부함수의 생명 주기에 대해 알아본다면, 일반적으로 함수는 자신을 참조하는 곳이 있으면 생성되었다가 참조하는 곳이 사라지면 제거되는 생명 주기를 갖는다. 함수의 생명주기는 참조 카운트와 관련되어 있다. 참조 카운트가 0에서 1이 되는 순간 생성되어 1 이상인 동안 유지되다가, 0이 되면 소멸하는 과정을 반복하는 것이다.

	중요❗️

	func outer(param: Int) -> (Int) -> String {
    	// 내부 함수
        func inner(inc: Int) -> String {
        	return "\(inc)를 리턴"
        }
    	return inner
    }
    
    let fn1 = outer(param: 3) // outer()가 실행되고, 그 결과로 inner가 대입됨
    let fn2 = fn1(30) // inner(inc: 30)과 동일
    

  위 코드에서 외부함수 outer는 let fn1 = outer(param: 3) 구문의 실행 종료와 함께 제거되지만 내부 함수인 inner가 결과값으로 반환되어 상수 fn1에 참조되었으므로 참조 카운트가 존재하고, 외부함수인 outer가 죽었더라도 내부함수인 inner는 살아있는 것이다.

	중요❗️

	func basic(param: Int) -> (Int) -> Int {
    	
        let value = param + 20
        // 내부 함수
        func append(add: Int)> Int {
        	return value + add
        }
    	return append
    }
    
   	let result = basic(param: 10)
    result(10) // 오류가 안나고 결과: 40 ?
    

  위 코드에서 value에 주목해보자!! 함수 내에서 정의된 값들은 함수가 종료되기 직전까지만 존재하므로 value 상수가 let result = basic(param: 10) 이 구문이 종료되기 직전까지만 존재해야 한다. 따라서 오류가 발생할 것이라고 예상했지만 40이라는 결과가 나왔다. 이는 append 함수가 클로저(Closure)를 갖기 때문이다. 클로저란 내부 함수와 내부 함수에 영향을 미치는 주변 환경(Context)을 모두 포함한 객체이다. 여기서 주변 환경이란 내부 함수에서 참조하는 모든 외부 변수나 상수 값, 그리고 내부 함수에서 참조하는 다른 객체까지를 말한다.

  클로저는 객체자체가 아닌 값을 포함하는 것이다. 따라서 let result = basic(param: 10)이 실행됬을 때 result에 저장되는 클로저는 다음과 같은 형태로 저장되는 것이다.

	func append(add: Int)> Int {
        	return 30 + add
    }

2. 클로저❗️

  위에서 이야기했던 클로저는 소프트웨어 아키텍처적인 개념이었고 실제로 스위프트에서의 클로저는 일회용 함수를 작성할 수 있는 구문이다. 익명함수(Anonymous) 함수라고 부르기도 한다.

  스위프트에서 클로저라고 부르는 객체는 다음 세 가지 경우 중 하나이다.

1. 전역 함수: 이름이 있고. 주변 환경에서 캡처할 어떤 값도 없는 클로저
2. 중첩 함수: 이름이 있고 자신을 둘러싼 함수로부터 값을 캡처할 수 있는 클로저
3. 클로저 표현식 이름이 없고 주변 환경으로부터 값을 캡처할 수 있는 경량 문법으로 작성된 클로저

2 - 1 클로저 표현식

	{ (매개변수) -> 반환 타입 in 
    	실행할 구문
    }
    
    
    { () -> () in
    	print("클로저 실행")
    }
    
    
    // 작성된 클로저 표현식은 그자체로 함수라고 할 수 있음
    let f = { () -> Void in
    	print("클로저 실행")
    }
    f() // 클로저 실행
    
    
    // 클로저 표현식을 할당받을 상수 f마저 생략하고 싶을 때 이렇게 작성해도 됨
    ({ () -> Void in
    	print("클로저 실행")
    })()  // 클로저 실행
    

2 - 2 클로저 표현식과 경량 문법

	var val = [1,9,5,7,3,2]
    
    func order(s1: Int, s2: Int) -> Bool {
    	if s1 > s2 {
        	return true
        } else {
        	return false
        }
    }
    
    val.sort(by: order)
    
    
    // 클로저 표현식으로
    {
    	(s1: Int, s2: Int) -> Bool {
    	if s1 > s2 {
        	return true
        } else {
        	return false
        }
    }

    val.sorted(by: {
        (s1: Int, s2: Int) -> Bool in
        if s1 > s2{
            return true
        }else {
            return false
        }
    })

    //간결화
    val.sort(by: {(s1: Int, s2: Int) -> Bool in return s1 > s2})

    val.sort(by: {(s1:Int, s2: Int) in return s1 > s2})

    val.sort(by: {s1, s2 in return s1 > s2})

    val.sort(by: { $0 > $1})

2 - 3 트레일링 클로저(Trailing Closure)

  트레일링 클로저는 함수의 마지막 인자값이 클로저일 때, 이를 인자값 형식으로 작성하는 대신 함수의 뒤에 꼬리처럼 붙일 수 있는 문법을 의미한다.

	
    //그냥 클로저
    value.sort(by: {(s1, s2) in
    	return s1 > s2
    })
	
    //트레일링 클로저
	value.sort() { (s1, s2) in
    	return s1 > s2
    }

  위에서 그냥 클로저와 트레일링 클로저는 달라 보이는 것이 거의 없다. 그러나 인자값으로 사용되던 클로저가 통째로 바깥으로 빠져나온 다음, sort( ) 메소드의 뒤쪽에 달라 붙은 것을 볼 수 있다.

  이렇게 괄호 하나 차이 이지만 열고 닫는 범위가 넓어지면 헷갈릴수도 있다. 또한 밑에 트레일링 클로저는 우리가 자주 사용하는 if 문과 코드의 괄호 형태가 비슷하기 때문에 훨씬 익숙하다는 장점이 있다.

	value.sort { (s1, s2) in
    	return s1 > s2
    }

  위 코드와 같이 인자값이 하나일 경우 sort 메소드 뒤의 괄호() 또한 생략할 수 있다. 그러나 인자값이 여러개라면 무작정 괄호를 생략해서는 안된다.

2 - 4   @escaping과 @autoescape

  클로저를 함수나 메소드의 인자값으로 사용할 때에는 용도에 따라 @escaping과 @autoclosure 속성을 부여할 수 있다.

@escaping

  @escaping 속성은 인자값으로 전달된 클로저를 저장해 두었다가, 나중에 다른 곳에서도 실행할 수 있도록 허용해주는 속성이다.

	func callback(fn: () -> Void) {
    	fn()
    }
	
    callback {
    	print("Closure 실행")
    }
	
    // Closure 실행

  정의된 함수 callback(fn:)은 매개변수를 통해 전달된 클로저를 함수 내부에서 실행하는 역할을 한다.

	func callback(fn: () -> Void) {
    	let f = fn // 클로저를 상수 f에 대입
        f() // 대입된 클로저를 실행
    }
    
    //오류: Non-escaping parameter 'fn' may only be called

  그러나 다음과 같이 코드를 바꾸면 Non-escaping 파라미터인 'fn'은 오직 직접 호출하는 것만 가능하다고 오류가 난다.
기본적으로 스위프트에서는 함수의 인자값으로 전달된 클로저(익명함수)는 기본적으로 탈출불가(non-escape)의 성격을 가진다. 이는 해당 클로저를 함수내에서, 직접 실행을 위해서만 사용해야 하는 것을 의미하며 함수내부라고 하더라도 변수나 상수에 대입할 수 없다.

  변수나 상수에 대입하는 것을 허용한다면 내부 함수를 통한 캡처(Capture) 기능을 이용하여 클로저가 함수 바깥으로 탈출할 수 있기 때문이다. 여기서 말하는 탈출이란, 함수 내부 범위를 벗어나서 실행되는 것을 의미한다.

  또한 인자값으로 전달된 클로저는 중첩된 내부 함수에서도 사용할 수 없다. 내부 함수에서 사용할 수 있도록 허용할 경우, 이 역시 컨텍스트(Context)의 캡처를 통해 탈출될 수 있기 때문이다.

	func callback(fn: () -> Void) {
    	func innerCallback() {
        	fn()
        }
    }

  따라서 위 코드를 실행하면 오류가 난다.


하지만 코드를 작성하다 보면 클로저를 변수나 상수에 대입하거나 중첩 함수 내부에서 사용해야 할 경우가 있다. 이때 사용하는 것이 @escaping 속성이다.

	func callback(fn: @escaping() -> Void) {
    	let f = fn // 클로저를 상수 f에 대입
        f() // 대입된 클로저를 실행
    }
    	
    callback {
    	print("Closure 실행")
    }
	
    // Closure 실행

  위에서 오류가 났던 함수인데 여기서 매개변수 타입에 앞에 @escaping 속성을 붙여 주니 오류 없이 정상 동작하였다.

  이제 입력된 클로저는 변수나 상수에 정상적으로 할당되고, 중첩된 내부 함수에 사용할 수 있고, 함수 바깥으로도 전달할 수 있다.

  탈출 가능한 클로저가 된것이다.

@autoclosure

  @autoclosure 속성은 인자값으로 전달된 일반 구문이나 함수 등을 클로저로 래핑(Wrapping)하는 역할을 한다. 쉽게 말해 일반 구문을 인자값으로 넣더라도 컴파일러가 알아서 클로저로 만들어서 사용한다는 것이다.

	func condition(stmt: () -> Bool) {
    	if stmt() == true {
        	print("결과는 참입니다.")
        } else {
        	print("결과가 거짓입니다.")
        } 
    }
    
    // 실행 방법 1: 일반 구문
    condition(stmt: {
    	4 > 2
    })
    
    
    //실행 방법 2: 경량화 문법
    
 	// 경량화 되지 않은 클로저 전체 문법
    condition{ () -> Bool in
    	return (4 > 2)
    }
    
    // 클로저 타입 선언 생략
    condition{
    	return (4 > 2)
    }
   
   
    // 클로저 반환구문 생략
    condition {
    	4 > 2
    }

  위코드에서 함수가 있고 그 함수를 호출하는 여러가지 방법을 보았다. 클로저의 경량화 문법을 이용하면서 더 짧고 간결한 코드로 함수를 호출할 수 있었다.

  @autoclosure로 다시 돌아가보면 위에서 함수를 호출할 때 원하는 구문을 '{}'형태로 감싸 클로저 형태로 만든 다음에 인자값으로 만들어 전달해야 한다는 제약이 있다. 하지만 @autoclosure() 속성을 사용한다면

	func condition(stmt: @autoclosure() -> Bool) {
    	if stmt() == true {
        	print("결과는 참입니다.")
        } else {
        	print("결과가 거짓입니다.")
        } 
    }
    
    //함수 실행
    condition(stmt: (4 > 2))

  다음과 같이 인자값을 '{}' 형태가 아닌 '()' 형태로 사용할 수 있도록 해준다. 훨씬 익숙하고 자연스러운 구문으로 만들어주는 셈이다.

  또한 @autoclosure속성을 사용하면 '지연 실행'을 할 수 있다.

	//빈 배열
    var arrs = [String]()
    
    func addVars(fn: @autoclosure () -> Void) {
    	// 배열 요소를 3개까지 추가하여 초기화
        arrs = Array(repeating: "", count: 3)
        // 인자값으로 전달된 클로저 실행
        fn()
    }
    
    // 구문 1: 아래 구문은 오류가 발생한다. 
    arrs.insert("KR", at: 1)
    
    // 구문 2: 오류 발생하지 않음
    addVars(fn: arrs.insert("KR", at: 1))

  빈 배열 arrs를 정의하였고 addVars(fn:) 함수 내부에서는 이 배열의 사이즈를 3으로 확장하고 빈 값들로 초기화했다.

  addVars(fn:) 함수가 실행되기 전까지 이 함수의 인덱스는 0까지 밖에 없어 arrs.insert(at:) 메소드는 오류가 발생한다.

  그러나 동일한 구문을 addVars(fn:) 함수의 인자값으로 넣으면 오류가 발생하지 않는다. 원래 구문은 작성하는 순간에 실행되지만, 함수 내에 작성된 구문은 함수가 실행되기 전까지는 실행되지 않아 이를 지연 실행이라고 한다. @autoclosure 속성이 부여된 인자값은 일반 구문 형태이지만 컴파일러에 의해 클로저, 함수로 감싸지기 때문에 위와 같이 작성해도 addVars(fn:) 함수 실행 전까지는 실행되지 않으며, 해당 구문이 실행될 때에는 이미 배열의 인덱스가 늘어난 후이므로 오류가 발생하지 않는 것이다.