Parameter types are indicated by 'Type(paramName)' in the function signature.

You define parameter types with 'Type: paramName' in the function header.

You declare parameter types using 'Type = paramName' in the function body.

You specify parameter types by using the syntax 'paramName: Type' in the function definition.

Is it to define the function's parameters like a secret code? 🤔

Or is it to send data back to the caller, like a friendly message from Irfan? 📬

Could it be to handle errors during execution, like a superhero saving the day? 🦸‍♂️

Maybe it's to document the function's purpose, just like Suci writes in her diary? 📖

Yes, by using global variables instead of return values.

Yes, but only if they are using classes.

Yes, a Swift function can have multiple return values using tuples.

No, Swift functions can only return a single value.

A closure in Swift is a predefined method that automatically executes when a program starts.

A closure in Swift is a function that only works with integers and cannot accept parameters.

A closure in Swift is a type of variable that holds a single value and cannot change.

A closure in Swift is a self-contained block of functionality that can capture and store references to variables and constants from its surrounding context, often used as callback handlers in functions.

A closure is a self-contained block of functionality that can capture and store references to variables and constants from its surrounding context.

A closure is a method that only works with classes and not structs.

A closure is a function that cannot access any external variables.

A closure is a type of variable that can only hold integer values.

A closure is always named and does not capture context, while a function can capture context.

A closure is a type of function that cannot capture variables, while a function can.

A closure can capture context and is unnamed, while a function is named and does not capture context.

A closure is a named block of code that captures context, while a function is unnamed and does not.

Higher-order functions cannot take parameters.

Higher-order functions are only used for sorting arrays.

Higher-order functions are limited to mathematical operations.

Higher-order functions are functions that can accept other functions as parameters or return them.

An example of a higher-order function in Swift is the 'filter' function.

An example of a higher-order function in Swift is the 'map' function.

An example of a higher-order function in Swift is the 'forEach' function.

An example of a higher-order function in Swift is the 'reduce' function.

By using a protocol to define the function parameter type.

By defining the parameter as a function type, e.g., (Int) -> Int.

By declaring the parameter as a closure type, e.g., (Int) -> Void.

By passing the function as a string to the other function.

The 'in' keyword is a marker for closure's access control.

The 'in' keyword is used to separate the parameters and return type from the body of a closure.

The 'in' keyword indicates the start of a closure's parameters.

The 'in' keyword is used to define the return type of a closure.

func generateMultiplier(factor: Int) -> (Int) -> Int { return { num in num / factor } }

func createAdder(value: Int) -> (Int) -> Int { return { num in num - value } }

func makeDecrementer(decrementAmount: Int) -> (Int) -> Int { return { number in number * decrementAmount } }

func makeIncrementer(incrementAmount: Int) -> (Int) -> Int { return { number in number + incrementAmount } }

Trailing closures are closures that must be placed inside parentheses.

Trailing closures are closures written outside the parentheses of a function call when they are the last argument.

Trailing closures are closures that cannot be used as function arguments.

Trailing closures are used to define functions within a class.

You use default parameter values in Swift functions by specifying them in the function signature, like this: `func example(param: Type = defaultValue) {}`.

You define default values outside the function declaration.

Default parameters are set using a separate function call.

You cannot use default values in Swift functions at all.

The main difference is that 'let' is block-scoped, while 'var' is function-scoped.

Both 'let' and 'var' are block-scoped in functions.

'let' allows redeclaration, while 'var' does not.

'let' is function-scoped, while 'var' is block-scoped.