Funkcje jako wartości pierwszej klasy

W języku Swift funkcje są wartościami pierwszej klasy — można przechowywać je w zmiennych, przekazywać jako argumenty, zwracać z innych funkcji oraz zagnieżdżać w innych funkcjach.

Każda funkcja ma typ określony przez typy jej parametrów i zwracanej wartości: ```swift func add(_ a: Int, _ b: Int) -> Int { a + b } let operation: (Int, Int) -> Int = add print(operation(3, 4)) // 7 ``` Typ funkcji `add` to `(Int, Int) -> Int`.

```swift func apply(_ f: (Int) -> Int, to value: Int) -> Int { f(value) } func double(_ n: Int) -> Int { n * 2 } print(apply(double, to: 5)) // 10 ``` To podstawa funkcji wyższego rzędu, takich jak `map` i `filter`.

```swift func multiplier(by factor: Int) -> (Int) -> Int { return { value in value * factor } } let triple = multiplier(by: 3) print(triple(7)) // 21 ``` Zwrócenie funkcji tworzy *domknięcie*, które przechwytuje `factor`.

Funkcje można definiować wewnątrz innych funkcji: ```swift func chooseStep(goForward: Bool) -> (Int) -> Int { func forward(_ n: Int) -> Int { n + 1 } func backward(_ n: Int) -> Int { n - 1 } return goForward ? forward : backward } let step = chooseStep(goForward: true) print(step(3)) // 4 ```

Anonimowe literały domknięć mogą zastępować dowolny typ funkcji: ```swift let square: (Int) -> Int = { $0 * $0 } print(square(6)) // 36 let doubled = [1, 2, 3].map { $0 * 2 } // [2, 4, 6] ``` `$0` oznacza pierwszy argument w skróconej postaci domknięcia.

```swift let operations: [(Int, Int) -> Int] = [ { $0 + $1 }, { $0 - $1 }, { $0 * $1 } ] for op in operations { print(op(10, 3)) } // 13, 7, 30 ```

Gdy ostatnim argumentem jest funkcja, można zapisać ją poza nawiasami: ```swift func withLogging(_ label: String, action: () -> Void) { print("Start: \(label)") action() print("End: \(label)") } withLogging("fetch") { fetchData() } ```

W języku Swift nie można porównywać dwóch wartości funkcyjnych za pomocą `==` — funkcje nie są zgodne z `Equatable`: ```swift // let same = add == add ❌ ``` Jeśli trzeba je porównywać, należy opakować funkcję w strukturę lub klasę zgodną z `Equatable`.

Zasymuluj curryfikację, zwracając funkcje z częściowo zastosowanymi argumentami: ```swift func add(_ a: Int) -> (Int) -> Int { { b in a + b } } let add5 = add(5) print(add5(3)) // 8 print(add5(10)) // 15 ``` Przydatne do tworzenia wyspecjalizowanych funkcji na podstawie funkcji ogólnych.

Najważniejsze informacje: • Funkcje mają typy takie jak `(ParamTypes) -> ReturnType` • Można przechowywać je w zmiennych, przekazywać jako argumenty i zwracać z funkcji • Domknięcia (`{ }`) są anonimowymi wartościami funkcyjnymi • Składnia końcowego domknięcia upraszcza miejsca wywołania • Zwracanie funkcji z funkcji tworzy domknięcia przechwytujące zmienne Następnie: lekcja o łańcuchowaniu opcjonalnym i rozpakowywaniu.