泛型 #

func swapValues<T>(_ a: inout T, _ b: inout T) {
    let temp = a
    a = b
    b = temp
}

var x = 1
var y = 2
swapValues(&x, &y)
print("x: \(x), y: \(y)")

var a = "Hello"
var b = "World"
swapValues(&a, &b)
print("a: \(a), b: \(b)")

func pair<A, B>(_ first: A, _ second: B) -> (A, B) {
    return (first, second)
}

let result = pair(1, "Hello")
print(result)

func makeArray<T>(_ element: T, count: Int) -> [T] {
    return Array(repeating: element, count: count)
}

let strings = makeArray("Hi", count: 3)
let numbers = makeArray(42, count: 5)

print(strings)
print(numbers)

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

var intStack = Stack<Int>()
intStack.push(1)
intStack.push(2)
print(intStack.pop() ?? 0)

var stringStack = Stack<String>()
stringStack.push("Hello")
print(stringStack.pop() ?? "")

class Container<T> {
    private var items: [T] = []
    
    func add(_ item: T) {
        items.append(item)
    }
    
    func get(at index: Int) -> T? {
        guard index >= 0 && index < items.count else { return nil }
        return items[index]
    }
    
    func getAll() -> [T] {
        return items
    }
}

let container = Container<Int>()
container.add(1)
container.add(2)
print(container.getAll())

enum Result<Success, Failure: Error> {
    case success(Success)
    case failure(Failure)
}

let success: Result<Int, Error> = .success(42)
let failure: Result<Int, Error> = .failure(NSError(domain: "", code: -1))

func findIndex<T: Equatable>(of value: T, in array: [T]) -> Int? {
    for (index, item) in array.enumerated() {
        if item == value {
            return index
        }
    }
    return nil
}

let index = findIndex(of: 3, in: [1, 2, 3, 4, 5])
print(index ?? -1)

func process<T: Comparable & Hashable>(_ value: T) {
    print(value)
}

process(42)
process("Hello")

func allEqual<T>(_ array: [T]) -> Bool where T: Equatable {
    guard let first = array.first else { return true }
    return array.allSatisfy { $0 == first }
}

print(allEqual([1, 1, 1]))
print(allEqual([1, 2, 3]))

protocol Container {
    associatedtype Item
    var count: Int { get }
    mutating func append(_ item: Item)
    subscript(i: Int) -> Item { get }
}

struct IntStack: Container {
    typealias Item = Int
    
    private var items: [Int] = []
    
    var count: Int { return items.count }
    
    mutating func append(_ item: Int) {
        items.append(item)
    }
    
    subscript(i: Int) -> Int {
        return items[i]
    }
}

struct GenericStack<Element>: Container {
    private var items: [Element] = []
    
    var count: Int { return items.count }
    
    mutating func append(_ item: Element) {
        items.append(item)
    }
    
    subscript(i: Int) -> Element {
        return items[i]
    }
}

protocol Container {
    associatedtype Item: Equatable
    var count: Int { get }
    mutating func append(_ item: Item)
    subscript(i: Int) -> Item { get }
    
    func indexOf(_ item: Item) -> Int?
}

extension Container {
    func indexOf(_ item: Item) -> Int? {
        for (index, value) in enumerated() {
            if value == item {
                return index
            }
        }
        return nil
    }
}

extension Stack {
    var top: Element? {
        return items.last
    }
    
    func map<U>(_ transform: (Element) -> U) -> Stack<U> {
        var result = Stack<U>()
        for item in items {
            result.push(transform(item))
        }
        return result
    }
}

extension Stack where Element: Equatable {
    func contains(_ item: Element) -> Bool {
        return items.contains(item)
    }
}

extension Stack where Element: Numeric {
    func sum() -> Element {
        return items.reduce(0, +)
    }
}

struct APIResponse<T: Decodable>: Decodable {
    let code: Int
    let message: String
    let data: T?
}

struct User: Decodable {
    let id: Int
    let name: String
}

func fetch<T: Decodable>(url: URL, completion: @escaping (Result<T, Error>) -> Void) {
    URLSession.shared.dataTask(with: url) { data, response, error in
        guard let data = data, error == nil else {
            completion(.failure(error!))
            return
        }
        
        do {
            let decoded = try JSONDecoder().decode(T.self, from: data)
            completion(.success(decoded))
        } catch {
            completion(.failure(error))
        }
    }.resume()
}

class Cache<Key: Hashable, Value> {
    private var storage: [Key: Value] = [:]
    
    func set(_ value: Value, forKey key: Key) {
        storage[key] = value
    }
    
    func get(_ key: Key) -> Value? {
        return storage[key]
    }
    
    func remove(_ key: Key) {
        storage.removeValue(forKey: key)
    }
    
    func clear() {
        storage.removeAll()
    }
}

let cache = Cache<String, Int>()
cache.set(42, forKey: "answer")
print(cache.get("answer") ?? 0)