Partial function application

PartialApplication.swift

/// Partial application of a function with 2 arguments
/// - Returns: Partially applied function (A) -> R
public func partial<A, B, R>(_ f: @escaping (A, B) -> R, _ a: Deferred, _ b: B) -> (A) -> R {
    { a in f(a, b) }
}

/// Partial application of a function with 2 arguments
/// - Returns: Partially applied function (B) -> R
public func partial<A, B, R>(_ f: @escaping (A, B) -> R, _ a: A, _ b: Deferred) -> (B) -> R {
    { b in f(a, b) }
}

/// Partial application of a function with 3 arguments
/// - Returns: Partially applied function (A) -> R
public func partial<A, B, C, R>(_ f: @escaping (A, B, C) -> R, _ a: Deferred, _ b: B, _ c: C) -> (A) -> R {
    { a in f(a, b, c) }
}

/// Partial application of a function with 3 arguments
/// - Returns: Partially applied function (B) -> R
public func partial<A, B, C, R>(_ f: @escaping (A, B, C) -> R, _ a: A, _ b: Deferred, _ c: C) -> (B) -> R {
    { b in f(a, b, c) }
}

/// Partial application of a function with 3 arguments
/// - Returns: Partially applied function (C) -> R
public func partial<A, B, C, R>(_ f: @escaping (A, B, C) -> R, _ a: A, _ b: B, _ c: Deferred) -> (C) -> R {
    { c in f(a, b, c) }
}

/// Partial application of a function with 3 arguments
/// - Returns: Partially applied function (A, B) -> R
public func partial<A, B, C, R>(_ f: @escaping (A, B, C) -> R, _ a: Deferred, _ b: Deferred, _ c: C) -> (A, B) -> R {
    { a, b in f(a, b, c) }
}

/// Partial application of a function with 3 arguments
/// - Returns: Partially applied function (A, C) -> R
public func partial<A, B, C, R>(_ f: @escaping (A, B, C) -> R, _ a: Deferred, _ b: B, _ c: Deferred) -> (A, C) -> R {
    { a, c in f(a, b, c) }
}

/// Partial application of a function with 3 arguments
/// - Returns: Partially applied function (B, C) -> R
public func partial<A, B, C, R>(_ f: @escaping (A, B, C) -> R, _ a: A, _ b: Deferred, _ c: Deferred) -> (B, C) -> R {
    { b, c in f(a, b, c) }
}

/// Partial application of a function with 4 arguments
/// - Returns: Partially applied function (A) -> R
public func partial<A, B, C, D, R>(_ f: @escaping (A, B, C, D) -> R, _ a: Deferred, _ b: B, _ c: C, d: D) -> (A) -> R {
    { a in f(a, b, c, d) }
}

/// Partial application of a function with 4 arguments
/// - Returns: Partially applied function (B) -> R
public func partial<A, B, C, D, R>(_ f: @escaping (A, B, C, D) -> R, _ a: A, _ b: Deferred, _ c: C, d: D) -> (B) -> R {
    { b in f(a, b, c, d) }
}

/// Partial application of a function with 4 arguments
/// - Returns: Partially applied function (C) -> R
public func partial<A, B, C, D, R>(_ f: @escaping (A, B, C, D) -> R, _ a: A, _ b: B, _ c: Deferred, d: D) -> (C) -> R {
    { c in f(a, b, c, d) }
}

/// Partial application of a function with 4 arguments
/// - Returns: Partially applied function (D) -> R
public func partial<A, B, C, D, R>(_ f: @escaping (A, B, C, D) -> R, _ a: A, _ b: B, _ c: C, d: Deferred) -> (D) -> R {
    { d in f(a, b, c, d) }
}

/// Partial application of a function with 4 arguments
/// - Returns: Partially applied function (C, D) -> R
public func partial<A, B, C, D, R>(_ f: @escaping (A, B, C, D) -> R, _ a: A, _ b: B, _ c: Deferred, d: Deferred) -> (C, D) -> R {
    { c, d in f(a, b, c, d) }
}

/// Partial application of a function with 4 arguments
/// - Returns: Partially applied function (B, D) -> R
public func partial<A, B, C, D, R>(_ f: @escaping (A, B, C, D) -> R, _ a: A, _ b: Deferred, _ c: C, d: Deferred) -> (B, D) -> R {
    { b, d in f(a, b, c, d) }
}

/// Partial application of a function with 4 arguments
/// - Returns: Partially applied function (A, D) -> R
public func partial<A, B, C, D, R>(_ f: @escaping (A, B, C, D) -> R, _ a: Deferred, _ b: B, _ c: C, d: Deferred) -> (A, D) -> R {
    { a, d in f(a, b, c, d) }
}

/// Partial application of a function with 4 arguments
/// - Returns: Partially applied function (A, C) -> R
public func partial<A, B, C, D, R>(_ f: @escaping (A, B, C, D) -> R, _ a: Deferred, _ b: B, _ c: Deferred, d: D) -> (A, C) -> R {
    { a, c in f(a, b, c, d) }
}

/// Partial application of a function with 4 arguments
/// - Returns: Partially applied function (A, B) -> R
public func partial<A, B, C, D, R>(_ f: @escaping (A, B, C, D) -> R, _ a: Deferred, _ b: Deferred, _ c: C, d: D) -> (A, B) -> R {
    { a, b in f(a, b, c, d) }
}

/// Partial application of a function with 4 arguments
/// - Returns: Partially applied function (B, C) -> R
public func partial<A, B, C, D, R>(_ f: @escaping (A, B, C, D) -> R, _ a: A, _ b: Deferred, _ c: Deferred, d: D) -> (B, C) -> R {
    { b, c in f(a, b, c, d) }
}

/// Partial application of a function with 4 arguments
/// - Returns: Partially applied function (A, B, C) -> R
public func partial<A, B, C, D, R>(_ f: @escaping (A, B, C, D) -> R, _ a: Deferred, _ b: Deferred, _ c: Deferred, d: D) -> (A, B, C) -> R {
    { a, b, c in f(a, b, c, d) }
}

/// Partial application of a function with 4 arguments
/// - Returns: Partially applied function (A, B, D) -> R
public func partial<A, B, C, D, R>(_ f: @escaping (A, B, C, D) -> R, _ a: Deferred, _ b: Deferred, _ c: C, d: Deferred) -> (A, B, D) -> R {
    { a, b, d in f(a, b, c, d) }
}

/// Partial application of a function with 4 arguments
/// - Returns: Partially applied function (A, C, D) -> R
public func partial<A, B, C, D, R>(_ f: @escaping (A, B, C, D) -> R, _ a: Deferred, _ b: B, _ c: Deferred, d: Deferred) -> (A, C, D) -> R {
    { a, c, d in f(a, b, c, d) }
}

/// Partial application of a function with 4 arguments
/// - Returns: Partially applied function (B, C, D) -> R
public func partial<A, B, C, D, R>(_ f: @escaping (A, B, C, D) -> R, _ a: A, _ b: Deferred, _ c: Deferred, d: Deferred) -> (B, C, D) -> R {
    { b, c, d in f(a, b, c, d) }
}

public enum Deferred {
    case deferred
}