Functions

함수(Functions)는 특정 작업을 수행하기 위한 코드 덩어리 입니다. 함수에는 어떤 동작을 하는지 구분하기 위한 이름을 부여할 수 있고 함수를 호출할때 이름이 사용됩니다.

파라미터는 함수 호출은 심플하게 하기 위해 기본 값을 가지고 전달할 수도 있고, 함수가 실행은 완료하면 전달된 변수를 수정하는 in-out 파라미터도 전달할 수 있습니다.

Swift의 모든 함수는 파라미터 타입과 리턴 타입으로 구성된 타입을 가지고 있습니다.

Swift의 다른 타입과 같이 사용할 수 있어서 다른 함수로 파라미터를 전달하고 함수에서 함수를 반환하기 쉽습니다. 함수는 특정 기능을 캡슐화 해서 사용하기 위해 다른 함수 내에서 중첩해서 작성할 수도 있습니다.

 

Defining and Calling Functions

함수를 정의할때 파라미터라고 하는 하나 이상의 타입으로 된 값을 함수에 옵셔널하게 입력할 수 있습니다.

또 리턴타입을 정의해서 함수가 완료된 이후에 반환하는 값의 타입의 옵셔널하게 정의할 수 있습니다.

모든 함수는 동작을 설명하기위해 함수명을 가지고 있습니다. 함수를 사용할때 함수명을 호출하면서 함께 값(Arguments)을 전달합니다. Arguments는 Parameters와 타입이 일치해야 하고 순서도 동일해야 합니다.

 

Note
Parameters vs Arguments Parameter는 함수를 선언할때 쓰는 변수, Argument는 함수로 전달되는 실제 값 쉽게 Parameter는 placeholder이고 Argument는 실제 값 함수 선언 시 func sum(param1, param2) { } → param1, param2 는 Parameters 함수 호출 시 sum(5, 6) → 5, 6은 Arguments

다음 예제의 greet 함수는 person 이라는 String 타입의 파라미터 값을 입력받아 String 타입의 인사말을 반환하는 함수입니다.

func greet(person: String) -> String {
    let greeting = "Hello, " + person + "!"
    return greeting
}

함수의 모든 정보는 prefix에 func 키워드를 붙여서 정의합니다. 반환 타입은 → 뒤에 타입을 작성하여 나타냅니다.

함수 정의는 함수가 뭘 하고, 어떤걸 받을지 완료할때는 어떤걸 반환할지 등을 설명합니다.

정의를 통해 코드의 다른 곳에서 함수를 명확하게 호출하게 합니다.

 

print(greet(person: "Anna"))
// Prints "Hello, Anna!"
print(greet(person: "Brian"))
// Prints "Hello, Brian!"

greet(person:) 을 호출하면서 greet(person: “Anna”)와 같이 person argument 뒤에 String 값을 전달합니다. 함수는 String 값을 반환하기 때문에 print(_: separator:terminator:) 함수를 통해 반환 값을 확인할 수 있습니다.

 

Note
print(_: separator:terminator:) 함수는 첫번쨰 argument가 label이 없습니다. 함수의 argument를 변형해서 사용할 수도 있는데 이 부분은 아래에서 다시 설명

 

greet(person:) 함수의 본문을 간단하게 설명하면 greeting이라는 상수를 선언해서 인사말을 정의합니다.

그리고 return 이라는 키워드를 이용해서 함수를 바깥으로 전달합니다. greet(person:) 함수에서는 return greeting 코드를 통해 바깥으로 전달.

여러가지 다른 입력 값으로 greet(person:) 함수를 여러번 호출할 수 있습니다. 그런 경우 입력받은 값에 의해 다른 반환 값을 가지게 됩니다. 함수 본문을 더 짧게 한줄로 결합할 수도 있습니다.

 

func greetAgain(person: String) -> String {
    return "Hello again, " + person + "!"
}
print(greetAgain(person: "Anna"))
// Prints "Hello again, Anna!"

 

Function Parameters and Return Values

Swift에서 함수 파라미터와 반환값은 매우 유연합니다. 이름 없는 하나의 파라미터를 가진 간단한 유틸리티 함수에서 부터 파라미터 이름과 다른 파라미터 옵션이 있는 복잡한 함수까지 정의할 수 있습니다.

 

Functions Without Parameters

함수를 파라미터 입력을 필수로 정의할 필요가 없습니다. 파라미터 입력은 없지만 항상 같은 String 메시지를 반환하는 함수.

func sayHelloWorld() -> String {
    return "hello, world"
}
print(sayHelloWorld())
// Prints "hello, world"

함수 정의는 파라미터가 없어도 이름 뒤에 소괄호가 필요하기 때문에 함수명 뒤에 빈 소괄호를 붙여서 파라미터가 없는 함수를 나타냅니다.

 

Functions With Multiple Parameters

함수는 여러개의 파라미터를 입력받을 수도 있습니다. 함수명 뒤의 소괄호 안에 콤마(,)로 구분해서 작성합니다.

func greet(person: String, alreadyGreeted: Bool) -> String {
    if alreadyGreeted {
        return greetAgain(person: person)
    } else {
        return greet(person: person)
    }
}
print(greet(person: "Tim", alreadyGreeted: true))
// Prints "Hello again, Tim!"

greet(person:alreadyGreeted:) 함수 호출에 person 이라는 String argument와 alreadyGreeted라는 Bool 타입 argument를 소괄호 안에 콤마(,)로 구분해서 전달합니다.

이전에 정의했던 greet(person:) 함수와 지금 greet(person:alreadyGreeted:) 함수는 이름이 greet로 같지만 다른 함수입니다.

 

Functions WIthout Return Values

함수를 정의할때 반환값은 필수가 아닙니다.

func greet(person: String) {
    print("Hello, \\(person)!")
}
greet(person: "Dave")
// Prints "Hello, Dave!"

 

 

반환 값이 없는 함수는 정의할때 → 나 반환 타입을 포함하지 않습니다.

Note
정확히 얘기하면 greet(person:) 함수는 반환 값을 정의하지 않았지만 반환 값이 존재합니다. 함수가 반환 타입을 정의하지 않으면 Void 타입의 특별한 값을 반환합니다. ()로 작성된 빈 튜플입니다.

 

반환된 함수의 값을 무시할 수 있습니다.

func printAndCount(string: String) -> Int {
    print(string)
    return string.count
}
func printWithoutCounting(string: String) {
    let _ = printAndCount(string: string)
}
printAndCount(string: "hello, world")
// prints "hello, world" and returns a value of 12
printWithoutCounting(string: "hello, world")
// prints "hello, world" but does not return a value

첫번째 함수 printAndCount(string:)은 String을 출력하고 String의 문자 갯수를 Int 형으로 반환 합니다. 두번째 함수

printWIthoutCounting(string:)은 첫번째 함수를 호출하지만 반환 값은 무시합니다. 두번째 함수를 호출하면 첫번째 함수 호출로 인해 String 값이 출력되지만 반환 값은 사용되지 않습니다.

Note
반환 값을 무시할 수 있지만 함수는 항상 값을 반환합니다. 반환 값이 정의된 함수에서 값을 반환하지 않으면 컴파일시 에러가 발생합니다.

 

Functions with Multiple Return Values

반환 타입을 튜플 타입을 사용해서 여러개의 값을 반환할 수 있습니다.

func minMax(array: [Int]) -> (min: Int, max: Int) {
    var currentMin = array[0]
    var currentMax = array[0]
    for value in array[1..<array.count] {
        if value < currentMin {
            currentMin = value
        } else if value > currentMax {
            currentMax = value
        }
    }
    return (currentMin, currentMax)
}

minMax(array:) 함수는 두개의 Int 값이 포함된 튜플 타입을 반환합니다. 함수의 반환 값을 사용할때 이름으로 액세스 할 수 있도록 max, max 라고 라벨되어있습니다.

minMax(array:) 함수는 currentMin, currentMax 라는 array의 첫번째 integer를 값으로 가지는 두개의 변수를 선언합니다. for loop를 돌려서 배열안의 값들과 비교해서 작은 값은 currentMin에 큰 값은 currentMax에 담아서 최소, 최대 값을 구한다음 2개의 Int 튜플로 반환합니다.

튜플의 멤버 값은 함수의 반환 타입이고 이름을 가지기 때문에 dot 구문으로 액세스하고 값을 찾을 수 있습니다.

let bounds = minMax(array: [8, -6, 2, 109, 3, 71])
print("min is \\(bounds.min) and max is \\(bounds.max)")
// Prints "min is -6 and max is 109"

Note
튜플의 멤버 이름은 함수의 반환 유형의 일부로 이미 지정되어 있어서 튜플이 함수로부터 반환되는 지점에 이름을 지정할 필요가 없습니다.

 

Optional Tuple Return Types

만약에 함수에서 반환되는 전체 튜플 타입이 값이 없을 수도 있는 경우에 optional 튜플 타입을 이용해서 전체 튜플이 nil 일수도 있다는 사실을 반영할 수 있습니다.

옵셔널 튜플을 반환 타입은 (Int, Int)?나 (String, Int, Bool)? 처럼 소괄호 뒤에 물음표(?)를 붙여서 작성합니다.

Note
(Int, Int)?와 같은 옵셔널 튜플 타입은 (Int?, Int?)과 같이 옵셔널 타입을 포함한 튜플과 다릅니다. 옵셔널 튜플 타입은 튜플 안의 값이 옵셔널 하다는게 아니라 전체 튜플 타입이 옵셔널 하다는 의미입니다.

 

위의 두개의 Int 값을 포함한 튜플을 반환하는 minMax(array:) 함수는 배열을 전달할때 안정성을 체크하지 않습니다. array argument가 빈 배열인 경우에 array[0]에 액세스를 시도할때 런타임 에러가 발생하게 됩니다.

빈 배열을 한전하게 핸들링하기 위해서 옵셔널 튜플의 반환 타입으로 minMax(array:) 함수를 작성하고 배열이 비어있는 경우 nil을 리턴하도록 합니다.

func minMax(array: [Int]) -> (min: Int, max: Int)? {
    if array.isEmpty { return nil }
    var currentMin = array[0]
    var currentMax = array[0]
    for value in array[1..<array.count] {
        if value < currentMin {
            currentMin = value
        } else if value > currentMax {
            currentMax = value
        }
    }
    return (currentMin, currentMax)
}

 

옵셔널 바인딩을 통해서 minMax(array:) 함수가실제 튜플 값을 반환하는지 nil을 반환하는지 체크합니다.

if let bounds = minMax(array: [8, -6, 2, 109, 3, 71]) {
    print("min is \\(bounds.min) and max is \\(bounds.max)")
}
// Prints "min is -6 and max is 109"

 

Functions With an Implicit Return

함수의 전체 본문이 단일 표현이라면 함수는 암시적으로 표현식을 반환합니다.

아래 두 함수는 같은 동작을 합니다.

func greeting(for person: String) -> String {
    "Hello, " + person + "!"
}
print(greeting(for: "Dave"))
// Prints "Hello, Dave!"

func anotherGreeting(for person: String) -> String {
    return "Hello, " + person + "!"
}
print(anotherGreeting(for: "Dave"))
// Prints "Hello, Dave!"

 

Note 암시적 반환 값으로 작성하는 코드는 일부 값을 반환해야 합니다. 예를들어 암시적 반환 값으로 print(13)을 사용할 수는 없습니다. 그러나 fatalError(”Oh no!”)처럼 Swift 가 암시적 반환이 일어나지 않는 것을 아는 경우는 사용 가능합니다.

func implicitReturn() -> String {
    print(13)
}
// Cannot convert return expression of type '()' to return type 'String' 에러 발생

func implicitReturn() -> String {
    fatalError("Oh no!")
}
// 사용 가능

 

Function Argument Labels and Parameter Names

각 함수 파라미터는 argument label과 parameter name을 가지고 있습니다. argument label은 함수를 호출할때 사용하고 parameter name은 함수를 구현할때 사용합니다.

기본적으로 parameters는 argument label을 parameter name으로 사용합니다.

func someFunction(firstParameterName: Int, secondParameterName: Int) {
    // In the function body, firstParameterName and secondParameterName
    // refer to the argument values for the first and second parameters.
}
someFunction(firstParameterName: 1, secondParameterName: 2)

모든 파라미터는 유니크한 이름을 가져야 합니다. 또 여러개의 파라미터가 같은 argument label로 가질 수 있지만 유니크한 argument label은 코드를 더 읽기 쉽게 만들어줍니다.

 

Specifying Argument Labels

공백을 구분해서 parameter name 앞에 argument label을 작성합니다.

func someFunction(argumentLabel parameterName: Int) {
    // In the function body, parameterName refers to the argument value
    // for that parameter.
}

Note
위에 someFunction(firstPrameterName:,secondParameterName:) 함수는 parameter name을 따로 지정하지 않아서 argument label을 parameter name으로 사용한 함수 아래 someFunction(argumentLabel parameterName:) 은 argument label, parameter name을 각각 작성한 함수

 

func greet(person: String, from hometown: String) -> String {
    return "Hello \\(person)!  Glad you could visit from \\(hometown)."
}
print(greet(person: "Bill", from: "Cupertino"))
// Prints "Hello Bill!  Glad you could visit from Cupertino."

 

argument label을 사용하면 함수를 문장과 같은 표현방식으로 함수를 호출하는 동시에 읽기 쉽고 의도적으로 명확한 함수를 제공합니다.

 

Omitting Argument Labels

parameter를 위한 argument label을 원하지 않는 경우 언더바(_)를 argument label 대신에 작성해서 사용할 수 있습니다.

func someFunction(_ firstParameterName: Int, secondParameterName: Int) {
    // In the function body, firstParameterName and secondParameterName
    // refer to the argument values for the first and second parameters.
}
someFunction(1, secondParameterName: 2)

parameter가 argument label을 가지고있다면 함수를 호출할때 argument는 반드시 label을 지정해야 합니다.

 

Default Parameter Values

파라미터의 타입 뒤에 파라미터 값을 할당해서 기본 값을 정의할 수 있습니다. 기본 값이 정의되어 있으면 함수를 호출할때 파라미터를 생략할 수 있습니다.

func someFunction(parameterWithoutDefault: Int, parameterWithDefault: Int = 12) {
    // If you omit the second argument when calling this function, then
    // the value of parameterWithDefault is 12 inside the function body.
}
someFunction(parameterWithoutDefault: 3, parameterWithDefault: 6) // parameterWithDefault is 6
someFunction(parameterWithoutDefault: 4) // parameterWithDefault is 12

기본 값이 없는 파라미터는 함수의 파라미터 리스트의 시작부분에 위치하고 기본 값이 있는 파라미터 전에 위치합니다. 일반적으로 기본 값이 없는 파라미터가 기본 값이 있는 파라미터보다 중요한 의미를 가집니다. 기본 값이 없는 파라미터를 먼저 작성하게 되면 기본 값에 따라 파라미터가 생략되었는지 여부와 상관없이 동일한 함수가 호출되고 있는지 쉽게 알 수 있습니다.

 

Variadic Parameters

가변 파라미터(variadic parameter)는 0개 이상의 특정 타입의 값을 허용합니다. 함수가 호출될때 여러개의 입력 값이 전달될 수 있는 특정 파라미터는 가변 파라미터를 사용합니다. 파라미터 타입 명 뒤에 세개의 점(…)을 입력해서 가변 파라미터를 사용합니다.

가변 파라미터로 전달된 값은 함수 내에서 적절한 타입의 배열로 사용할 수 있습니다. 예를 들어서 numbers 라는 이름과 Double…의 타입을 가진 가변 파라미터는 함수 내에서 [Double] 타입의 numbers 라고 불리는 상수 배열로 사용할 수 있습니다.

func arithmeticMean(_ numbers: Double...) -> Double {
    var total: Double = 0
    for number in numbers {
        total += number
    }
    return total / Double(numbers.count)
}
arithmeticMean(1, 2, 3, 4, 5)
// returns 3.0, which is the arithmetic mean of these five numbers
arithmeticMean(3, 8.25, 18.75)
// returns 10.0, which is the arithmetic mean of these three numbers

 

In-Out Parameters

함수 파라미터는 기본 적으로 상수입니다. 해당 함수의 본문에서 파라미터 값을 변경하려고 하면 컴파일 에러가 발생합니다. 이것은 실수로 인해 파라미터의 값이 변경될 수 없다는 의미입니다. 만약 파라미터의 값을 수정하고 함수 호출이 끝난 이후에도 수정된 값을 유지하고 싶다면 파라미터를 in-out 파라미터로 대신 정의하면 됩니다.

in-out 파라미터는 파라미터 타입 전에 inout 키워드를 작성합니다. in-out 파라미터는 함수로 전달하는 값을 가지고 함수에서 이 값을 수정하고 원래 값을 대체하기 위해 다시 밖으로 보냅니다.

in-out 파라미터의 argument로는 변수만 전달할 수 있습니다. 상수와 literal value는 수정할 수 없기 때문에 전달할 수 없습니다. 변수를 in-out 파라미터에 대한 argument로 전달할때 변수 이름 앞에 (&)를 추가하여 함수에 의해 수정될 수 있음을 나타냅니다.

Note in-out 파라미터는 기본 값을 가질 수 없습니다. 가변 파라미터는 inout으로 표시될 수 없습니다.

 

a와 b라는 두개의 in-out integer 파라미터를 가진 함수를 호출하는 예제입니다.

func swapTwoInts(_ a: inout Int, _ b: inout Int) {
    let temporaryA = a
    a = b
    b = temporaryA
}

 

wapTwoInts(_: _:) 함수는 간단하게 a와 b의 값을 바꿉니다. a의 값을 temporaryA에 저장하고 b를 a에 할당하고 temporaryA를 b에 할당합니다.

값을 바꿀 두개의 Int형 변수와 swapTwoInts(_: :)함수를 호출할 수 있습니다. swapTwoInts(: _:) 함수에 someInt와 anotherInt를 전달할때 이름 앞에 &를 붙여야 합니다.

var someInt = 3
var anotherInt = 107
swapTwoInts(&someInt, &anotherInt)
print("someInt is now \\(someInt), and anotherInt is now \\(anotherInt)")
// Prints "someInt is now 107, and anotherInt is now 3"

 

위 예제를 보면 someInt와 anotherInt의 원본 값이 원래 함수 밖에서 정의되었지만 swapTwoInts함수로 인해 수정되었습니다.

Note in-out 파라미터는 함수에서 값을 반환하는 것과 다릅니다. swapTwoInts는 반환 타입이나 반환 값이 정의되어 있지 않지만 someInt 와 anotherInt를 수정합니다. in-out 파라미터는 함수 본문에서 벗어나서 함수 밖에서 영향을 미치는 다른 방법입니다.

 

Function Types

모든 함수는 파라미터 타입과 반환 타입으로 만들어진 특정 함수 타입이 있습니다.

예를들어

func addTwoInts(_ a: Int, _ b: Int) -> Int {
    return a + b
}
func multiplyTwoInts(_ a: Int, _ b: Int) -> Int {
    return a * b
}

예제에서 addTowInts와 multiplyTwoInts라는 두개의 간단한 수학 함수가 정의되어 있습니다.

두 함수는 각각 두개의 Int 값을 취하고 수학적 계산을 한 결과 Int 값을 반환합니다.

두 함수의 타입은 (Int, Int) → Int 입니다. 이것은 이렇게 읽을 수 있습니다. “함수는 두개의 Int 타입 파라미터를 가지고 Int 형 값을 반환한다.”

다음 예제는 파라미터와 반환 값이 없는 함수입니다.

func printHelloWorld() {
    print("hello, world")
}

이 함수의 타입은 () → Void 또는 “이 함수는 파라미터가 없고 Void를 반환합니다”

 

Using Function Types

함수의 타입은 Swift의 다른 타입 처럼 사용합니다. 예를 들어 함수 타입에 대해 상수나 변수로 정의할 수 있고 변수에 적절한 함수 타입을 할당할 수도 있습니다.

var mathFunction: (Int, Int) -> Int = addTwoInts

이렇게 읽을 수 있습니다.

“두개의 Int 값을 받아서 하나의 Int 값을 반환하는 함수 타입 의 mathFunction 변수를 정의합니다.”

이 새로운 변수는 addTowInts 함수를 참조하도록 설정합니다.

addTwoInts(_: _:) 함수는 mathFunction 변수와 같은 타입을 가지므로 Swift의 타입 체커는 할당을 허용합니다.

mathFunction 이라는 이름으로 할당된 함수를 호출할 수 있습니다.

print("Result: \\(mathFunction(2, 3))")
// Prints "Result: 5"

함수가 아닌 타입과 같은 방법으로 같은 타입으로 일치하는 다른 함수를 같은 변수에 할당할 수 있습니다.

mathFunction = multiplyTwoInts
print("Result: \\(mathFunction(2, 3))")
// Prints "Result: 6"

다른 타입과 마찬가지로 상수 또는 변수에 함수를 할당할 때 함수 타입을 추론하기 위해 Swift에 맡길 수 있습니다.

let anotherMathFunction = addTwoInts
// anotherMathFunction is inferred to be of type (Int, Int) -> Int

 

Function Types as Parameter Types

(Int, Int) → Int 와 같은 함수 타입을 다른 함수의 파라미터 타입으로 사용 가능합니다. 이렇게 사용하면 함수 호출자가 함수가 호출될 때 제공할 함수 구현의 일부를 넘길 수 있습니다.

func printMathResult(_ mathFunction: (Int, Int) -> Int, _ a: Int, _ b: Int) {
    print("Result: \\(mathFunction(a, b))")
}
printMathResult(addTwoInts, 3, 5)
// Prints "Result: 8"

이 예제에서 printMathResult(_: _: _:)라는 3개의 파라미터를 가지는 함수를 정의합니다.

첫번째 함수는 mathFunction이라는 (Int, Int) → Int 타입 입니다. 이 첫번째 파라미터의 인수로 해당 타입의 함수를 전달 할 수 있습니다. 두번째 세번째 파라미터는 a, b라고 하고 둘 다 Int 타입입니다. 수학 계산을 하기 위핸 두개의 입력 값으로 제공됩니다.

printMathResult(_: _: :)가 호출될때 addTowInts(: _: _:) 함수와 정수 값 3, 5가 전달됩니다. 함수에 3과 5 값을 제공하고 결과로 8을 출력합니다.

printMathResult(_: _: :)의 역할은 적절한 타입의 함수를 호출하고 결과를 출력합니다. 이것은 함수의 구현이 실제로 어떻게 동작하는지 상관없이 함수가 올바른 타입인지만 중요합니다. 이렇게 하면 printMathResult(: _: _:)가 해당 기능의 일부를 타입이 안전한 방식으로 함수 호출자에게 전달할 수 있습니다.

 

Function Types as Return Types

다른 함수의 반환 타입으로 함수 타입을 사용할 수 있습니다. 반환하는 함수의 return arrow (→) 바로 뒤에 반환할 함수 타입을 작성하여 동작합니다.

다음 예제에서 stepForward(:)와 stepBackward(:)라는 두개의 간단한 함수를 정의합니다.

stepForward(:) 함수는 입력 값에 1을 더해서 반환하고, stepBackward(:)는 입력 값에 하나를 빼서 반환합니다. 두 함수 모두 (Int) → Int 타입입니다.

func stepForward(_ input: Int) -> Int {
    return input + 1
}
func stepBackward(_ input: Int) -> Int {
    return input - 1
}

 

다음은 반환 타입이 (Int) → Int인 chooseStepFunction(backward:) 함수 입니다. chooseStepFunction(backward:)함수는 backword라는 Boolean 파라미터를 가지고 stepForward(:)함수나 stepBackward(:) 함수를 반환합니다.

func chooseStepFunction(backward: Bool) -> (Int) -> Int {
    return backward ? stepBackward : stepForward
}

 

이제 chooseStepFunction(backward:)를 사용하여 한방향이나 다른 방향으로 이동할 함수를 얻을 수 있습니다.

var currentValue = 3
let moveNearerToZero = chooseStepFunction(backward: currentValue > 0)
// moveNearerToZero now refers to the stepBackward() function

 

위 예제에서 currentValue 라는 변수를 점차적으로 0에 가깝게 이동하기 위해 빼기나 더하기가 필요한지 여부를 결정합니다.

currentValue의 초기 값은 3이고, currentValue > 0 은 true의 반환을 의미하고, chooseStepFunction(backward:)는 stepBackward(_:)를 반환하게 합니다. 반환된 함수의 참조는moveNearerToZero 상수에 저장됩니다.

이제 moveNearerTozero가 올바른 함수를 참조하므로 0까지 count하는데 사용할 수 있습니다.

print("Counting to zero:")
// Counting to zero:
while currentValue != 0 {
    print("\\(currentValue)... ")
    currentValue = moveNearerToZero(currentValue)
}
print("zero!")
// 3...
// 2...
// 1...
// zero!

 

Nested Functions

이 챕터에서 모든 함수는 전역 범위에서 정의된 전역 함수의 예입니다. 중첩함수(nested function)라고 하는 다른 함수 내에 함수를 정의할수도 있습니다.

중첩함수는 기본적으로 함수 바깥에서 보이지 않지만 둘러싼 함수 내부에서 여전히 호출됩니다. 중첩 함수를 둘러싼 함수는 중첩 함수 중 하나를 반환하여 중첩 함수를 다른 범위에서 사용할 수도 있습니다.

위의 예제 chooseStepFunction(Backward:) 를 중첩함수를 사용하도록 다시 작성하게 되면

func chooseStepFunction(backward: Bool) -> (Int) -> Int {
    func stepForward(input: Int) -> Int { return input + 1 }
    func stepBackward(input: Int) -> Int { return input - 1 }
    return backward ? stepBackward : stepForward
}
var currentValue = -4
let moveNearerToZero = chooseStepFunction(backward: currentValue > 0)
// moveNearerToZero now refers to the nested stepForward() function
while currentValue != 0 {
    print("\\(currentValue)... ")
    currentValue = moveNearerToZero(currentValue)
}
print("zero!")
// -4...
// -3...
// -2...
// -1...
// zero!

stepForward(input:), stepBackward(input:)을 중첩함수로 chooseStepFunction(backward:) 함수 안에 작성하고 함수 내부에서 호출하게 됩니다.