Protocols and Generics

protocol Greetable {
    var name: String { get }   // required read-only property
    func greet() -> String
}

// Protocol extension: default implementation
extension Greetable {
    func greet() -> String {
        return "Hello, I'm \(name)!"
    }
}

struct Person: Greetable {
    let name: String
    // greet() provided by default — no need to implement
}

struct Robot: Greetable {
    let name: String
    func greet() -> String {   // override the default
        return "GREETINGS. I AM \(name.uppercased())."
    }
}

// Protocol composition: &
func introduce(_ thing: Greetable & CustomStringConvertible) {
    print(thing.greet())
    print(thing.description)
}

let p = Person(name: "Ana")
print(p.greet())   // Hello, I'm Ana!
let r = Robot(name: "R2D2")
print(r.greet())   // GREETINGS. I AM R2D2.

// Generic function: T is constrained to Comparable
func maximum<T: Comparable>(_ a: T, _ b: T) -> T {
    return a > b ? a : b
}

print(maximum(3, 7))           // 7
print(maximum("apple", "banana"))  // banana

// Generic struct
struct Stack<Element> {
    private var items: [Element] = []
    mutating func push(_ item: Element) { items.append(item) }
    mutating func pop() -> Element? { items.popLast() }
    var top: Element? { items.last }
    var isEmpty: Bool { items.isEmpty }
}

var stack = Stack<Int>()
stack.push(1); stack.push(2); stack.push(3)
print(stack.pop()!)   // 3

// where clause: multiple constraints
func merge<T, U: Sequence>(_ dict: [T: [U.Element]], _ seq: U) -> [T: [U.Element]]
    where U.Element: Hashable {
    return dict   // simplified — just shows constraint syntax
}

import Foundation

// Codable = Encodable & Decodable — synthesised automatically for simple structs
struct User: Codable {
    let id: Int
    let name: String
    let email: String
    let isAdmin: Bool

    // Custom JSON keys via CodingKeys enum
    enum CodingKeys: String, CodingKey {
        case id, name, email
        case isAdmin = "is_admin"   // snake_case JSON -> camelCase Swift
    }
}

// Encoding: Swift -> JSON
let user = User(id: 1, name: "Alice", email: "alice@example.com", isAdmin: false)
let encoder = JSONEncoder()
encoder.outputFormatting = .prettyPrinted
let jsonData = try! encoder.encode(user)
print(String(data: jsonData, encoding: .utf8)!)

// Decoding: JSON -> Swift
let json = """{"id":2,"name":"Bob","email":"bob@example.com","is_admin":true}"""
let decoder = JSONDecoder()
let decoded = try! decoder.decode(User.self, from: json.data(using: .utf8)!)
print(decoded.name)   // Bob
print(decoded.isAdmin)   // true