Memoizing example for learners

[tevelee (Laszlo Teveli)]

Here's a variadic generic version of it that takes multiple parameters

@tevelee

func memoize<each In: Hashable, Out>(_ factory: @escaping (repeat each In) -> Out) -> (repeat each In) -> Out {
    var memo: [Container<repeat each In>: Out] = [:]
    return { (pack: repeat each In) -> Out in
        let container = Container(repeat each pack)
        if let result = memo[container] {
            return result
        } else {
            let result = factory(repeat each pack)
            memo[container] = result
            return result
        }
    }
}

private struct Container<each T> {
    let value: (repeat each T)

    init(_ value: repeat each T) {
        self.value = (repeat each value)
    }
}

extension Container: Equatable where repeat each T: Equatable {
    static func == (lhs: Container<repeat each T>, rhs: Container<repeat each T>) -> Bool {
        for (left, right) in repeat (each lhs.value, each rhs.value) {
            guard left == right else { return false }
        }
        return true
    }
}

extension Container: Hashable where repeat each T: Hashable {
    func hash(into hasher: inout Hasher) {
        for element in repeat each value {
            hasher.combine(element)
        }
    }
}