Examples 19-24

Author: tib

contents/[19]functions/index.md

@@ -4,46 +4,159 @@ description: ""
 order: 19
 ---
 
+Functions are self-contained pieces of code that perform a specific task. You give each function a name that describes what it does, and you use this name to "call" the function whenever you need it to do its job. This makes your code clearer, shorter, and more organized.
 
-foo
+```swift
+func greet() {
+    print("Hello World!")
+}
+
+greet()
+```
+
+Functions can accept parameters, which are values you pass into the function to customize its behavior. By defining parameters, you allow your function to work with different inputs each time it is called:
+
+```swift
+func greet(
+    name: String
+) {
+    print("Hello, \(name)!")
+}
+greet(name: "Tibor") 
+greet(name: "Kitti") 
+```
+
+You can customize how you use functions and make them easier to understand by adding custom **argument labels**. These labels appear before the parameter name and are separated by a space. They help make your function calls more readable and user-friendly:
+
+```swift
+func greet(
+    to name: String
+) {
+    print("Hello, \(name)!")
+}
+
+greet(to: "Tibor")
+```
+
+If you do not want to use a label at all, place an underscore `_` before the parameter name. This allows you to call the function using just the parentheses and the argument, without any label. The function's behavior stays the same, so you can choose to show or hide argument labels based on what makes your code clearer and easier to read:
+
+```swift
+func greet(
+    _ name: String
+) {
+    print("Hello, \(name)!")
+}
+// calling the function
+greet("Tibor")
+```
+
+When using default parameter values, you can omit that argument from the function call. If you do, the function will automatically use the default value you provided:
+
+```swift
+func greet(
+    to name: String = "Guest" 
+) {
+    print("Hello, \(name)!")
+}
+
+greet() 
+greet(to: "Tibi")
+```
+
+Functions can also have more than one parameter:
+
+```swift
+func sumNumbers(
+    _ a: Int, 
+    _ b: Int
+) {
+    let sum = a + b
+    print("Sum: ", sum)
+}
+// function call with two arguments: 42 and 69
+sumNumbers(42, 69)
+```
+
+A variadic parameter in Swift lets a function accept zero or more values of a specific type, so you can pass any number of arguments you need. To define a variadic parameter, add `...` after the parameter's type:
+
+```swift
+func sumNumbers(
+    _ numbers: Int...
+) {
+    var sum = 0
+    for number in numbers {
+        sum += number
+    }
+    print("Sum: ", sum)
+}
+
+sumNumbers()
+sumNumbers(42)
+sumNumbers(42, 69)
+sumNumbers(42, 69, 4, 2, 6, 9)
+```
+
+Parameter overloading allows you to define multiple functions with the same name, as long as they have different parameter types or a different number of parameters. This is also known as function overloading:
 
 ```swift
-let x = 5
-let y = 5
-var z = 0
+// function with Int type parameter
+func displayValue(value: Int) {
+    print("Integer value:", value)
+}
 
-z = x + y // addition
-print(z) // => 10
+// function with String type parameter
+func displayValue(value: String) {
+    print("String value:", value)
+}
 
-z = x - y // subtraction
-print(z) // => 0
+// function call with String type parameter
+displayValue(value: "Swift")
 
-z = x * y // multiplication
-print(z) // => 25
+// function call with Int type parameter
+displayValue(value: 2)
+```
 
-z = x / y // division
-print(z) // => 1
+Swift will automatically choose the correct function to call based on the type and number of arguments you provide. It uses both the number and types of parameters to determine which version of the function to execute.
 
+A function return type specifies the type of value a function gives back after it finishes executing. The return value is the actual result that the function produces:
 
-var x = 10
+```swift
+func square(number: Int) -> Int {
+    let result = number * number
+    return result
+}
 
-x += 2 // addition
-print(x) // => 12
+let result = square(number: 4)
+print(result)
 
-x -= 2 // subtraction
-print(x) // => 10
+let doubled = result * 2
+print(doubled) 
+```
 
-x *= 2 // multiplication
-print(x) // => 20
+For functions that have only a single expression, you can leave out the `return` keyword and simply write the expression itself:
 
-x /= 2 // division
-print(x) // => 10
+```swift
+func square(number: Int) -> Int {
+    number * number
+}
 ```
 
-bar
+A function can also return a tuple, allowing you to return multiple values at once. Tuples group several values into a single compound value, which can be useful when you want to provide more than one result from a function:
 
-```sh
-swift main.swift
+```swift
+func minMax(
+    numbers: [Int]
+) -> (min: Int, max: Int) {
+    let minValue = numbers.min() ?? 0
+    let maxValue = numbers.max() ?? 0
+    return (min: minValue, max: maxValue)
+}
+
+let result = minMax(numbers: [3, 7, 2, 9])
+print(result.min)
+print(result.max)
 ```
 
-baz
+In this example, the `minMax` function returns both the minimum and maximum values from an array as a tuple.
+
+

contents/[20]closures/index.md

@@ -4,46 +4,143 @@ description: ""
 order: 20
 ---
 
+A closure in Swift is a block of code that you can store in a variable, pass around in your program, and run whenever you need. You can think of closures as function-like values — they work very much like functions, but they do not always need a name.
 
-foo
+```swift
+let greet = {
+    print("Hello, world")
+}
+greet()
+```
+
+Closures can also have parameters. You also need to define the type of the parameters, just like you'd do when defining the parameters of a function. The syntax is just slightly different:
+
+```swift
+let greet = { (name: String) in
+    print("Hello, \(name)")
+}
+
+greet("Tibi")
+```
+
+Closures can also return values:
+
+```swift
+let sum = { (num1: Int, num2: Int) -> Int in
+    return num1 + num2
+}
+
+let res = sum(2, 3)
+print(res) // 5
+```
+
+Here is an example of a function and a closure, both performing the same task:
+
+```swift
+func sum(num1: Int, num2: Int) -> Int {
+    number + number
+}
+
+let add = { (num1: Int, num2: Int) -> Int in
+    num1 + num2
+}
+```
+
+It is possible to move out the closure type information from the definition and explicitly tell the type of the `add` constant instead. The following example is the exact same as the previous one, but we've moved the type information to the left:
+
+```swift
+let add: ((Int, Int) -> Int)  = { num1, num2 in
+    num1 + num2
+}
+```
+
+If you have a function with the same signature (exact same parameter types and return types), you can use that function as a closure:
 
 ```swift
-let x = 5
-let y = 5
-var z = 0
+func add(a: Int, b: Int) -> Int {
+    a + b
+}
 
-z = x + y // addition
-print(z) // => 10
+let sum: (Int, Int) -> Int = add
+sum(2, 3) // 5
+```
 
-z = x - y // subtraction
-print(z) // => 0
+By assigning a function to a variable like sum, you _treat behavior_ as _data_. This means you can change what sum actually does at runtime:
 
-z = x * y // multiplication
-print(z) // => 25
+```swift
+func add(a: Int, b: Int) -> Int { a + b }
+func multiply(a: Int, b: Int) -> Int { a * b }
 
-z = x / y // division
-print(z) // => 1
+var operation: (Int, Int) -> Int = add
+print(operation(3, 4))
 
+operation = multiply
+print(operation(3, 4))
+```
 
-var x = 10
+By the way, in Swift, every identifier must be unique within its scope. That means you can't define a variable and a function with the same name in the same place—Swift won't know which one you mean. You get a compiler error.
 
-x += 2 // addition
-print(x) // => 12
 
-x -= 2 // subtraction
-print(x) // => 10
+A function parameter can be a closure, in the example below it takes two integers and returns an integer after performing a specific operation on them:
 
-x *= 2 // multiplication
-print(x) // => 20
+```swift
+func performOperation(
+    _ a: Int,
+    _ b: Int,
+    _ op: ((Int, Int) -> Int)
+) {
+    print(op(a, b))
+}
+
+performOperation(3, 1, { a, b in a + b })
+performOperation(3, 1, { a, b in a - b })
+```
 
-x /= 2 // division
-print(x) // => 10
+Once you feel more comfortable with closures, you can switch to writing shorter, more concise versions that are easier to read and maintain. Here are some examples to show how you can make closures more concise as you get comfortable with the syntax:
+
+```swift
+// longest form, explicit types and return keyword
+performOperation(3, 1, { (a: Int, b: Int) -> Int in return a + b }) 
+// no explicit types
+performOperation(3, 1, { a, b in return a + b }) 
+// no explicit return keyword
+performOperation(3, 1, { a, b in a + b }) 
+// most simple, shorthand argument names called "trailing closure syntax: 
+performOperation(3, 2, { $0 * $1 }) 
 ```
 
-bar
+When a function's last parameter is a closure, you can use trailing closure syntax to make the function call simpler and easier to read:
 
-```sh
-swift main.swift
+```swift
+performOperation(3, 2) { $0 * $1 } // 6
 ```
 
-baz
+You can also use multiple trailing closure syntax when a function has more than one closure parameter:
+
+```swift
+func getPointFromClosures(
+  x: () -> Int,
+  y: () -> Int
+) -> (x: Int, y: Int) {
+  (x(), y())
+}
+
+let point = getPointFromClosures { 42 } y: { 69 }
+
+print(point.x, point.y)
+```
+
+Because operators are also functions in Swift, you can use them as closure parameters just like you would with regular functions:
+
+```swift
+func mul(_ a: Int, b: Int) -> Int {
+    a * b
+}
+performOperation(3, 2, mul)
+
+performOperation(3, 2, +)
+performOperation(3, 2, *)
+```
+
+By using operators as closure parameters, your Swift code can become simpler and easier to follow, especially in cases where you want to perform standard operations in a flexible way.
+