Functions and Closures ⚙️

// A function packages reusable code under a name.
// Shape:  func name(label param: Type) -> ReturnType { ... }
func greet(name: String) -> String {
    // "\(name)" is string interpolation — the value is dropped into the text.
    return "Hello, \(name)!"
}

// Call it by name. The label "name:" is required at the call site.
print(greet(name: "Alice"))   // Hello, Alice!
print(greet(name: "Bob"))     // Hello, Bob!

// -> Int means "this function hands back an Int".
func square(of value: Int) -> Int {
    return value * value
}
let result = square(of: 6)    // result is 9? No — it's 36
print("6 squared is \(result)")   // 6 squared is 36

// No "-> Type" means the function returns nothing (it just does a job).
func logLine(_ text: String) {
    print("LOG: \(text)")
}
logLine("started")           // LOG: started

Hello, Alice!
Hello, Bob!
6 squared is 36
LOG: started

// Swift parameters can have TWO names:
//   external label  -> read at the call site
//   internal name   -> used inside the function body
// Pattern:  func f(externalLabel internalName: Type)
func greet(person name: String, from town: String) -> String {
    // Inside, you use the internal names: name, town.
    return "\(name) is from \(town)"
}
// Outside, you use the external labels: person, from — reads like a sentence.
print(greet(person: "Alice", from: "London"))   // Alice is from London

// Write _ as the external label to REMOVE the label at the call site.
func multiply(_ a: Int, _ b: Int) -> Int {
    return a * b
}
print(multiply(4, 5))        // 20  (no labels needed)

// Mix and match: first label omitted, second kept.
func power(_ base: Int, to exponent: Int) -> Int {
    var total = 1
    for _ in 0..<exponent { total *= base }
    return total
}
print(power(2, to: 10))      // 1024

Alice is from London
20
1024

// 🎯 YOUR TURN — replace each ___ then run the code.
// Goal: a function whose call site reads like English.

// 1) External label "to", internal name "name".
func sayHello(___ name: String) -> String {   // 👉 put the external label before name
    return "Hello, \(name)!"
}

// 2) Call it. The label you chose must appear here.
print(sayHello(___: "Sam"))                    // 👉 use the label, then "Sam"

// ✅ Expected output:
//    Hello, Sam!

Hello, Sam!

// Default parameter values: callers may skip the argument.
func makeTea(_ kind: String = "Black", sugars: Int = 1) -> String {
    return "\(kind) tea with \(sugars) sugar(s)"
}
print(makeTea())                       // Black tea with 1 sugar(s)
print(makeTea("Green"))                // Green tea with 1 sugar(s)
print(makeTea("Mint", sugars: 0))      // Mint tea with 0 sugar(s)

// Variadic parameter (Type...): accept zero, one, or many values.
// Inside the function, "scores" is just an array [Int].
func average(of scores: Int...) -> Double {
    if scores.isEmpty { return 0 }
    let total = scores.reduce(0, +)    // add them all up
    return Double(total) / Double(scores.count)
}
print(average(of: 10, 20, 30))         // 20.0
print(average(of: 7))                  // 7.0
print(average())                       // 0.0  (no values passed)

Black tea with 1 sugar(s)
Green tea with 1 sugar(s)
Mint tea with 0 sugar(s)
20.0
7.0
0.0

// Normally parameters are CONSTANTS — a function can't change the
// caller's variable. "inout" lets a function modify it in place.

// Add & to the argument when you call an inout function.
func double(_ number: inout Int) {
    number *= 2                 // changes the ORIGINAL variable
}
var score = 21
double(&score)                 // pass &score, not score
print(score)                   // 42

// Classic example: swap two values without a temp variable at the call site.
func swapValues(_ a: inout Int, _ b: inout Int) {
    let temp = a
    a = b
    b = temp
}
var x = 1
var y = 9
swapValues(&x, &y)
print("x = \(x), y = \(y)")     // x = 9, y = 1

42
x = 9, y = 1

// A closure is an unnamed function you can store and pass around.
// Full shape:  { (params) -> ReturnType in body }
let add = { (a: Int, b: Int) -> Int in
    return a + b
}
print(add(3, 4))               // 7

// Closures shine as arguments. sorted(by:) takes a closure.
let names = ["Charlie", "Alice", "Bob"]

// Full closure passed as the "by:" argument:
let sortedA = names.sorted(by: { (s1: String, s2: String) -> Bool in
    return s1 < s2
})
print(sortedA)                 // ["Alice", "Bob", "Charlie"]

// TRAILING CLOSURE: when a closure is the LAST argument, move it
// outside the parentheses. $0 and $1 are the first/second arguments.
let sortedB = names.sorted { $0 < $1 }
print(sortedB)                 // ["Alice", "Bob", "Charlie"]

// map: transform every element into a new array.
let numbers = [1, 2, 3, 4, 5]
let doubled = numbers.map { $0 * 2 }
print(doubled)                 // [2, 4, 6, 8, 10]

// filter: keep only the elements that pass a test.
let evens = numbers.filter { $0 % 2 == 0 }
print(evens)                   // [2, 4]

// Chain them: keep evens, then square each one.
let evenSquares = numbers.filter { $0 % 2 == 0 }.map { $0 * $0 }
print(evenSquares)             // [4, 16]

7
["Alice", "Bob", "Charlie"]
["Alice", "Bob", "Charlie"]
[2, 4, 6, 8, 10]
[2, 4]
[4, 16]

// 🎯 YOUR TURN — fill in the blanks, then run.
let prices = [5, 12, 3, 20, 8]

// 1) Use map with a trailing closure to add 2 to every price.
//    $0 stands for the current element.
let plusTwo = prices.map ___       // 👉 { $0 + 2 }

// 2) Use filter to keep only prices greater than 7.
let pricey = prices.filter ___     // 👉 { $0 > 7 }

print(plusTwo)                     // expected below
print(pricey)                      // expected below

// ✅ Expected output:
//    [7, 14, 5, 22, 10]
//    [12, 20, 8]

[7, 14, 5, 22, 10]
[12, 20, 8]