Swift Functions: Definition and Usage

• Functions are self-contained code blocks performing specific tasks.
• A function is called by its name to execute its task.
• Swift functions have a unified syntax that can range from simple C-style functions to complex Objective-C-style methods.
• Function parameters can have default values.
• Parameters can be modified within a function using in-out parameters, with changes persisting after execution.
• Swift functions have types defined by their parameter types and return type.
• Functions can be passed as parameters to other functions and returned from functions.
• Functions can be written within other functions, creating nested function scopes.

Defining and Calling Functions

• When defining a function, named, typed input values called parameters can be defined.
• A function can also define a return type, specifying the type of value it passes back as output.
• Every function has a name describing its task and is called using its name with input values called arguments.
• Arguments passed when calling a function must match the types and order of the function's parameters.

Function Parameters and Return Values

• Swift provides extreme flexibility in function parameters and return values.
• Functions can range from simple utilities with a single unnamed parameter to complex functions with expressive parameter names and options.

Functions Without Parameters

• Functions do not require input parameters.
• Functions without parameters still need parentheses in their definition and when they are called.

Functions With Multiple Parameters

• Functions can have multiple input parameters separated by commas within the parentheses.
• When calling a function with multiple parameters, arguments must be passed in the same order as the parameters.

Functions Without Return Values

• Functions are not required to define a return type.
• Functions that don't return a value don't include the return arrow (->) or a return type in their definition.
• A functions return value can be ignored when called.

Functions with Multiple Return Values

• A tuple type enables returning multiple values from a function as a single compound return value.
• Tuple members can be named as part of the function’s return type, allowing access with dot syntax.
• Tuple members do not need to be named when the tuple is returned if they are already specified in the return type.

Optional Tuple Return Types

• Optional tuple return types ((Int, Int)?) can be used if the entire tuple might have "no value" (nil).
• Optional binding can be used to check if a function with an optional tuple return type returns a tuple value or nil.

Functions With an Implicit Return

• If a function's body consists of a single expression, that expression is implicitly returned.
• Functions written as a single return line can omit the return keyword.

Function Argument Labels and Parameter Names

• Function parameters have an argument label used when calling the function and a parameter name used in the function's implementation.
• By default, parameters use their parameter name as their argument label.
• All parameters must have unique names.

Specifying Argument Labels

• To specify an argument label, write it before the parameter name, separated by a space.

Omitting Argument Labels

• To omit an argument label, use an underscore (_) instead of an explicit argument label for a parameter.
• If a parameter has an argument label, it must be labeled when the function is called.

Default Parameter Values

• A default value can be defined for a parameter by assigning a value to it after its type.
• If a parameter has a default value, it can be omitted when calling the function.
• Parameters without default values should be placed at the beginning of the parameter list.

Variadic Parameters

• A variadic parameter accepts zero or more values of a specified type.
• Variadic parameters are denoted by inserting three period characters (...) after the parameter's type name.
• Values passed to a variadic parameter are available within the function's body as an array of the appropriate type.
• Functions can have multiple variadic parameters, but the parameter after a variadic one must have an argument label.

In-Out Parameters

• Function parameters are constants by default.
• In-out parameters allow a function to modify a parameter's value, with changes persisting after the function call.
• In-out parameters are defined using the inout keyword before the parameter's type.
• Only variables can be passed as arguments for in-out parameters, not constants or literals.
• An ampersand (&) is placed before a variable's name when passing it to an in-out parameter.

Function Types

• Every function has a specific function type, composed of the parameter types and the return type.
• Example: (Int, Int) -> Int represents a function with two Int parameters that returns an Int value.
• () -> Void represents a function with no parameters that returns Void.

Using Function Types

• Function types can be used like any other type in Swift.
• Constants or variables can be defined as function types and assigned appropriate functions.
• Swift can infer the function type when assigning a function to a constant or variable.

Function Types as Parameter Types

• A function type can be used as a parameter type for another function.
• This allows a function's caller to provide some aspects of the function's implementation.
• The implementation of callback functions does not matter, only that the function is of the correct type.

Function Types as Return Types

• A function type can be used as the return type of another function.
• This is done by writing a complete function type after the return arrow (->).

Nested Functions

• Functions defined at a global scope are called global functions.
• Functions can be defined inside the bodies of other functions, known as nested functions.
• Nested functions are hidden from the outside world by default.
• An enclosing function can return one of its nested functions to allow it to be used in another scope.