Functions and their labels

Give a step a name

A function collects steps under one name so you can run them again with a single call. You write func followed by the name, a pair of parentheses and a block.

Nothing inside the block runs until you call the name. Calling it is the name followed by parentheses, and a function with no result simply does its work and returns.

A function declaration is not a step that runs where it appears. Swift records the name and its shape, and the body waits until a call. That is why a function can be called on a line above its definition: the compiler has already seen the whole file by the time the call is checked.

Handing values in and out

The parentheses list the values the function needs, each with a name and a type, such as width: Int. The arrow and a type say what comes back, written -> Int.

Inside the block, return hands the answer back and ends the function. A function whose work is only to print has no arrow and returns nothing.

A function with no arrow returns Void, which is a real type with exactly one value. You can write -> Void if you like, but leaving the arrow off means the same thing. If a function returns a value and the caller ignores it, Swift warns unless the function is marked @discardableResult, because an ignored answer is often a mistake.

Labels and defaults

In Swift a call reads like a sentence because each argument carries a label. area(width: 3, height: 4) is clearer than three bare numbers, and the labels come from the function itself.

An argument can have a default. exponent: Int = 2 lets callers leave it out, so power(5) uses two and power(2, exponent: 3) asks for three. A leading underscore on a parameter name removes its label when the meaning is already obvious.

The two names in func greet(person name: String) have different jobs. person is what the caller writes, and name is what the body uses. A call reads greet(person: "Ada"); inside the body you write name. When the two would be the same word, one name is enough: func area(width: Int) gives both the label and the internal name width.

The signature is a contract

A function’s signature is its name together with the labels, the argument types and the type it returns. Callers depend on that shape, so the compiler checks every call against it before the program runs.

Inside the body, the parameters behave like constants. A function can read them but cannot assign to one, which keeps a call from changing the caller’s value behind its back. When the answer is known early, return hands it back and skips the rest of the block.

Argument labels are part of that contract: they make a call read like a sentence and can be omitted with _ when the meaning is obvious.

A call, step by step

Take area(width: 3, height: 4). The compiler matches the labels against the definition, checks that both values are Int, and only then runs the body. Inside, width and height are fresh constants holding 3 and 4. The multiplication produces 12, return hands it back, and the call site receives an Int that it can print or store.

power(2, exponent: 3) follows the same path with one difference: the first argument has no label because the definition writes _ base. The second keeps its label, so the call must say exponent:. If you leave it out, the compiler reports a missing argument rather than guessing which value you meant.

A function, a result and a default

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

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

func power(_ base: Int, exponent: Int = 2) -> Int {
    var result = 1
    for _ in 1...exponent {
        result *= base
    }
    return result
}

Try these next

• Write one function with a labelled parameter and one with an unlabelled parameter, then compare the two call sites.
• Add a default to a parameter and call the function with and without that argument.
• Write a function that returns early for an invalid input instead of nesting the rest in an else.