Swift cheat sheet

let name = "Alessandro"      // constant
var count = 0                // variable
let price: Double = 3.5      // explicit type
let msg = "Total: \(count)"  // interpolation

var email: String? = nil
if let email { print(email) }
guard let email else { return }
let display = email ?? "No email"
let length = email?.count

var items = ["Flat white", "Croissant"]
items.append("Cold brew")
var stock: [String: Int] = ["FW-01": 12]
stock["CR-02"] = 5
let unique: Set = [1, 2, 2, 3]   // {1, 2, 3}

let totals = [12.5, 40, 8]
totals.map { $0 * 1.2 }
totals.filter { $0 > 10 }
totals.reduce(0, +)
totals.sorted(by: >)
orders.compactMap(\.email)

for (i, item) in items.enumerated() { print(i, item) }
for n in 1...5 { }
while count < 10 { count += 1 }
switch status {
case .paid: print("Paid")
case .refunded, .cancelled: print("Closed")
default: break
}

func total(_ items: [Double], vat: Double = 0.2) -> Double {
    items.reduce(0, +) * (1 + vat)
}
let double: (Int) -> Int = { $0 * 2 }

struct Product {            // value type
    let sku: String
    var price: Decimal
    mutating func discount(_ p: Decimal) { price *= (1 - p) }
}
final class Basket {        // reference type
    var items: [Product] = []
}

enum Status: String, Codable {
    case paid, refunded, cancelled
}
enum PaymentResult {
    case success(Decimal)
    case failure(String)
}

protocol Priced { var price: Decimal { get } }
extension Product: Priced {}
func sum(_ xs: [some Priced]) -> Decimal {
    xs.reduce(0) { $0 + $1.price }
}

enum OrderError: Error { case empty }
func checkout(_ b: Basket) throws -> Decimal {
    guard !b.items.isEmpty else { throw OrderError.empty }
    return b.items.reduce(0) { $0 + $1.price }
}
do { try checkout(basket) } catch { print(error) }

func load() async throws -> [Order] {
    let (data, _) = try await URLSession.shared.data(from: url)
    return try JSONDecoder().decode([Order].self, from: data)
}
async let a = load()
async let b = load()
let (x, y) = try await (a, b)   // run in parallel

struct Order: Codable {
    let orderId: Int
    let total: Decimal
}
let d = JSONDecoder()
d.keyDecodingStrategy = .convertFromSnakeCase
let order = try d.decode(Order.self, from: data)