Swift Functions

func greet(name: String) {
    print("Hello, \(name)!")
}

func area(width: Double, height: Double) -> Double {
    return width * height
}

greet(name: "Ada")
let room = area(width: 4, height: 3.5)

• func declares a function; each parameter has a name and a type.
• -> Double declares the return type, and return sends the result back.
• A function that returns nothing has no arrow (its return type is Void).
• When the body is a single expression, return can be left out: func double(_ n: Int) -> Int { n * 2 }.
• Parameters are constants inside the function; you can't reassign them.

Each parameter can have two names: an argument label used when calling, and a parameter name used inside the function:

func move(from start: String, to end: String) {
    print("Moving from \(start) to \(end)")
}
move(from: "Leeds", to: "York")

Write _ as the label to call without one, which suits functions where the meaning is obvious: func square(_ n: Int) -> Int, called as square(4). Good labels make the call site read naturally: insert(item, at: 0) or remove(at: 2).

• Default values make parameters optional: func order(_ item: String, size: String = "medium") can be called as order("tea") or order("tea", size: "large").
• A variadic parameter accepts any number of values with ...: func average(_ numbers: Double...), called as average(4, 8, 9). Inside, numbers is an array.
• Return a tuple to send back several values: func minMax(_ xs: [Int]) -> (min: Int, max: Int), then let r = minMax(scores); r.max.

Normally a function receives a copy of each argument. An inout parameter lets it change the caller's variable; the caller writes &:

func addBonus(to score: inout Int) { score += 10 }
var points = 50
addBonus(to: &points)       // points is now 60

Functions are also values with types like (Int, Int) -> Int. You can store them in variables and pass them to other functions, which leads directly to the closures lesson.

Two functions can share a name as long as their parameter labels or types differ. This is called overloading, and Swift picks the right one from the call:

func area(side: Double) -> Double { side * side }
func area(width: Double, height: Double) -> Double { width * height }

print(area(side: 3))                 // 9.0
print(area(width: 2, height: 5))     // 10.0

Because labels are part of the identity, Swift documentation writes a function's full name with its labels: area(side:) and area(width:height:). You can use that full name to refer to one function without calling it: let calculate = area(width:height:), then calculate(3, 4) gives 12.0. Notice that a stored function is called without labels.

Some functions can't always produce a result. Rather than inventing a fake value such as -1, return an optional and send back nil when there's nothing to give:

func firstEven(in numbers: [Int]) -> Int? {
    for n in numbers where n % 2 == 0 {
        return n                     // leaves the function straight away
    }
    return nil
}
print(firstEven(in: [1, 3, 4]) ?? 0)   // 4

The Int? return type tells every caller that the answer might be missing, and the compiler makes them deal with it. This is the same pattern the standard library uses for Int("42") and array.first.