Variables and Data Types 📦

// A variable is a named box that stores a value. Swift gives you two kinds.

// 'var' makes a MUTABLE box — you can change what's inside later.
var score = 10
score = 25            // ✅ fine: score is a var
print("score = \(score)")   // score = 25

// 'let' makes a CONSTANT — it's set once and can NEVER change.
let pi = 3.14159
print("pi = \(pi)")         // pi = 3.14159
// pi = 3.2            // ❌ compile error if you uncomment this

// Rule of thumb: reach for 'let' first. Only switch to 'var' when you
// actually need the value to change. Swift even warns you if a 'var'
// is never mutated — a nudge to use 'let'.
let appName = "Weatherly"
var loginCount = 0
loginCount = loginCount + 1   // this one really does change
print("\(appName) opened \(loginCount) time(s)")

score = 25
pi = 3.14159
Weatherly opened 1 time(s)

// TYPE INFERENCE: Swift reads the value and figures out the type for you.
let age = 25          // inferred as Int    (whole number)
let height = 1.75     // inferred as Double (decimal number)
let name = "Alice"    // inferred as String (text, in "double quotes")
let isOnline = true   // inferred as Bool   (true or false)

// EXPLICIT ANNOTATION: you write ": Type" yourself. Useful when there is
// no starting value yet, or when you want a specific type.
let count: Int = 0
let ratio: Double = 2        // store 2 as a Double, not an Int
var nickname: String = "Al"
var isReady: Bool = false

print("\(name) is \(age), height \(height)m, online: \(isOnline)")
print("count=\(count) ratio=\(ratio) nickname=\(nickname) ready=\(isReady)")

// Int holds whole numbers; Double holds decimals. They are different types,
// so Swift will NOT mix them automatically — you must convert on purpose.
let apples = 3        // Int
let pricePer = 0.5    // Double
let total = Double(apples) * pricePer   // convert Int -> Double, then multiply
print("total = \(total)")              // total = 1.5

Alice is 25, height 1.75m, online: true
count=0 ratio=2.0 nickname=Al ready=false
total = 1.5

// 🎯 YOUR TURN — replace each ___ then run it in SwiftFiddle.

// 1) Make a constant 'city' set to a city name (text in "double quotes")
let city = ___          // 👉 e.g. "London"

// 2) Make a constant 'year' set to a whole number
let year = ___          // 👉 e.g. 2026 (an Int — no decimal point)

// 3) Make a constant 'temperature' set to a decimal number
let temperature = ___   // 👉 e.g. 18.5 (a Double)

// This line already works once your three constants exist:
print("In \(city) in \(year) it was \(temperature)°C")

// ✅ Expected output (example):
//    In London in 2026 it was 18.5°C

// String interpolation drops a value straight into text using \(...).
let userName = "Sam"
let messages = 5

// Everything inside \(...) is replaced with the value.
print("Hi \(userName), you have \(messages) new messages.")

// You can run real code inside the parentheses, not just a name:
let price = 4.0
let qty = 3
print("\(qty) coffees cost £\(price * Double(qty))")   // 3 coffees cost £12.0

// Build up longer strings the same way — it reads far better than gluing
// pieces together with '+'.
let first = "Ada"
let last = "Lovelace"
print("Full name: \(first) \(last)")   // Full name: Ada Lovelace

Hi Sam, you have 5 new messages.
3 coffees cost £12.0
Full name: Ada Lovelace

// An OPTIONAL means "a value, OR nothing (nil)". You write it with a ? .
// nil is Swift's word for "no value here yet".
var middleName: String? = nil      // might hold a String, currently holds nothing
middleName = "Quinn"               // now it has a value

// Optionals appear naturally: Int("...") may fail, so it returns Int?.
let good = Int("42")     // Optional(42)  — the conversion worked
let bad = Int("hello")   // nil           — "hello" is not a number

// You can't use an optional directly — you must UNWRAP it first.

// Safest unwrap: optional binding with 'if let'. It runs the block ONLY
// when a value is present, giving you a plain (non-optional) constant.
if let number = good {
    print("Parsed a number: \(number)")   // runs: Parsed a number: 42
} else {
    print("That wasn't a number")
}

if let number = bad {
    print("Parsed a number: \(number)")
} else {
    print("That wasn't a number")          // runs: That wasn't a number
}

// Nil-coalescing '??' supplies a default when the optional is nil.
let typed: String? = nil
let display = typed ?? "Guest"             // use "Guest" because typed is nil
print("Welcome, \(display)!")             // Welcome, Guest!

// Force-unwrap with '!' grabs the value WITHOUT checking. If it's nil your
// program CRASHES. Only use it when you are 100% certain a value exists.
let definitely = Int("7")!                 // safe here — "7" is clearly a number
print("Force-unwrapped: \(definitely)")   // Force-unwrapped: 7

Parsed a number: 42
That wasn't a number
Welcome, Guest!
Force-unwrapped: 7

// 🎯 YOUR TURN — handle a value that might be missing.

// favouriteColour is an optional String that is currently nil.
let favouriteColour: String? = nil

// 1) Use nil-coalescing to fall back to "unknown" when it's nil.
let shown = favouriteColour ___ "unknown"   // 👉 replace ___ with the ?? operator
print("Favourite colour: \(shown)")

// 2) Int("twelve") can't be parsed, so it is nil. Safely unwrap it with
//    optional binding, printing the number OR a friendly message.
let parsed = Int("twelve")
if ___ value = parsed {                     // 👉 replace ___ with the keyword 'let'
    print("Got the number \(value)")
} else {
    print("Not a valid number")
}

// ✅ Expected output:
//    Favourite colour: unknown
//    Not a valid number