Swift Tutorial

Swift Data Types

Swift Control Flow

Swift Functions

Swift Collections

Swift OOPs

Swift Additional Topics

Calling Functions in Swift

In Swift, a function is a reusable piece of code that performs a specific task. You can define and call functions to execute these tasks.

Here's a basic introduction to defining and calling functions in Swift:

1. Defining a Simple Function:

Here's a simple function that prints a greeting:

func greet() {
    print("Hello, World!")
}

2. Calling the Function:

Once a function is defined, you can call it using its name followed by parentheses:

greet()  // Outputs: Hello, World!

3. Functions with Parameters:

Functions can take parameters to make them more versatile:

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

4. Calling a Function with Parameters:

greet(person: "Alice")  // Outputs: Hello, Alice!

5. Functions with Multiple Parameters:

func greet(person: String, day: String) {
    print("Hello, \(person)! Today is \(day).")
}

6. Calling a Function with Multiple Parameters:

greet(person: "Bob", day: "Tuesday")  // Outputs: Hello, Bob! Today is Tuesday.

7. Functions with Return Values:

Functions can return values using the -> syntax followed by the return type:

func add(a: Int, b: Int) -> Int {
    return a + b
}

8. Calling a Function with Return Values:

let sum = add(a: 5, b: 3)
print(sum)  // Outputs: 8

9. Omitting Parameter Labels:

Swift allows you to omit parameter labels using an underscore (_):

func multiply(_ a: Int, _ b: Int) -> Int {
    return a * b
}

let result = multiply(4, 5)
print(result)  // Outputs: 20

10. Default Parameter Values:

You can provide default values for parameters:

func greetWithDefault(person: String, day: String = "Sunday") {
    print("Hello, \(person)! Today is \(day).")
}

greetWithDefault(person: "Charlie")  // Outputs: Hello, Charlie! Today is Sunday.

11. Variadic Parameters:

Swift allows you to create functions that accept a variable number of arguments using the ... syntax:

func sum(numbers: Int...) -> Int {
    var total = 0
    for number in numbers {
        total += number
    }
    return total
}

let total = sum(numbers: 1, 2, 3, 4, 5)
print(total)  // Outputs: 15

Remember, functions are a fundamental aspect of any programming language, and Swift is no exception. Getting familiar with the syntax and conventions of Swift functions will help you write more efficient and readable code.

How to call functions in Swift:
- To call a function in Swift, use the function name followed by parentheses.
- Example:
```
func greet(name: String) {
    print("Hello, \(name)!")
}

greet(name: "John")
```
Swift function parameters and arguments:
- Parameters are placeholders in the function definition, and arguments are actual values passed during the function call.
- Example:
```
func addNumbers(a: Int, b: Int) -> Int {
    return a + b
}

let result = addNumbers(a: 5, b: 3)
```

Swift function return types:

Functions can specify a return type using ->.

Example:

func multiply(a: Int, b: Int) -> Int {
    return a * b
}

let product = multiply(a: 4, b: 2)

Calling methods in Swift:

Methods are functions associated with a particular type (class, struct, enum).

Example:

struct Math {
    func square(number: Int) -> Int {
        return number * number
    }
}

let math = Math()
let squaredValue = math.square(number: 3)

Swift function overloading examples:
- Functions with the same name but different parameters or return types.
- Example:
```
func process(value: Int) {
    // Implementation
}

func process(value: String) {
    // Implementation
}
```

Swift function with default parameters:

Default parameter values allow calling a function without providing values for certain parameters.

Example:

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

greet() // Prints "Hello, Guest!"
greet(name: "John") // Prints "Hello, John!"

Swift function with inout parameters:

inout parameters allow modifying the original value.

Example:

func increment(number: inout Int) {
    number += 1
}

var count = 5
increment(number: &count)

Swift function closures and calling:

Closures are self-contained blocks of functionality.

Example:

let multiplyClosure: (Int, Int) -> Int = { a, b in
    return a * b
}

let result = multiplyClosure(3, 4)

Swift function naming conventions:
- Follow Swift's naming conventions, like using camelCase for function names.
- Example:
```
func calculateTotalAmount(itemPrice: Double, quantity: Int) -> Double {
    // Implementation
}
```

Swift function error handling:

Use throws for functions that can throw errors and do-catch for handling errors.

Example:

enum MathError: Error {
    case divisionByZero
}

func divide(a: Double, b: Double) throws -> Double {
    guard b != 0 else {
        throw MathError.divisionByZero
    }
    return a / b
}

do {
    let result = try divide(a: 10, b: 0)
} catch {
    print("Error: \(error)")
}

Advanced function calling techniques in Swift:
- Techniques include higher-order functions, function composition, and using advanced Swift features.
- Example (higher-order function):
```
let numbers = [1, 2, 3, 4, 5]
let sum = numbers.reduce(0, +)
```