currying.swift

// MARK: - Curry
/// Currying for functions with 2 arguments.
///
/// :param: fn A function with 2 arguments, (A,B)→R
/// :returns: A curried function (A)→(B)→R
public func curry<A,B,R>(fn:(A,B)->R) -> (A)->(B)->R {
  return {a in {b in fn(a,b)}}
}

/// Currying for functions with 3 arguments.
///
/// :param: fn A function with 3 arguments, (A,B,C)→R
/// :returns: A curried function (A)→(B)→(C)→R
public func curry<A,B,C,R>(fn:(A,B,C)->R) -> (A)->(B)->(C)->R {
  return {a in {b in {c in fn(a,b,c)}}}
}

/// Currying for functions with 4 arguments.
///
/// :param: fn A function with 4 arguments, (A,B,C,D)→R
/// :returns: A curried function (A)→(B)→(C)→(D)→R
public func curry<A,B,C,D,R>(fn:(A,B,C,D)->R) -> (A)->(B)->(C)->(D)->R {
  return {a in {b in {c in {d in fn(a,b,c,d)}}}}
}

/// Currying for functions with 5 arguments.
///
/// :param: fn A function with 5 arguments, (A,B,C,D,E)→R
/// :returns: A curried function (A)→(B)→(C)→(D)→(E)→R
public func curry<A,B,C,D,E,R>(fn:(A,B,C,D,E)->R) -> (A)->(B)->(C)->(D)->(E)->R {
  return {a in {b in {c in {d in {e in fn(a,b,c,d,e)}}}}}
}

/// Currying for functions with 6 arguments.
///
/// :param: fn A function with 6 arguments, (A,B,C,D,E,F)→R
/// :returns: A curried function (A)→(B)→(C)→(D)→(E)→(F)→R
public func curry<A,B,C,D,E,F,R>(fn:(A,B,C,D,E,F)->R) -> (A)->(B)->(C)->(D)->(E)->(F)->R {
  return {a in {b in {c in {d in {e in {f in fn(a,b,c,d,e,f)}}}}}}
}

/// Currying for functions with 7 arguments.
///
/// :param: fn A function with 7 arguments, (A,B,C,D,E,F,G)→R
/// :returns: A curried function (A)→(B)→(C)→(D)→(E)→(F)→(G)→R
public func curry<A,B,C,D,E,F,G,R>(fn:(A,B,C,D,E,F,G)->R) -> (A)->(B)->(C)->(D)->(E)->(F)->(G)->R {
  return {a in {b in {c in {d in {e in {f in {g in fn(a,b,c,d,e,f,g)}}}}}}}
}

// MARK: - Uncurry
/// Uncurrying for functions expecting 2 arguments.
///
/// Transforms a curried function into a function taking 2 arguments.
///
/// :param: fn A curried function (A)→(B)→R
/// :returns: A function with 2 arguments, (A,B)→R
public func uncurry<A,B,R>(fn:(A)->(B)->R) -> (A,B)->R {
  return {(a,b) in fn(a)(b)}
}

/// Uncurrying for functions expecting 3 arguments.
///
/// Transforms a curried function into a function taking 3 arguments.
///
/// :param: fn A curried function (A)→(B)→(C)→R
/// :returns: A function with 3 arguments, (A,B,C)→R
public func uncurry<A,B,C,R>(fn:(A)->(B)->(C)->R) -> (A,B,C)->R {
  return {(a,b,c) in fn(a)(b)(c)}
}

/// Uncurrying for functions expecting 4 arguments.
///
/// Transforms a curried function into a function taking 4 arguments.
///
/// :param: fn A curried function (A)→(B)→(C)→(D)→R
/// :returns: A function with 4 arguments, (A,B,C,D)→R
public func uncurry<A,B,C,D,R>(fn:(A)->(B)->(C)->(D)->R) -> (A,B,C,D)->R {
  return {(a,b,c,d) in fn(a)(b)(c)(d)}
}

/// Uncurrying for functions expecting 5 arguments.
///
/// Transforms a curried function into a function taking 5 arguments.
///
/// :param: fn A curried function (A)→(B)→(C)→(D)→(E)→R
/// :returns: A function with 5 arguments, (A,B,C,D,E)→R
public func uncurry<A,B,C,D,E,R>(fn:(A)->(B)->(C)->(D)->(E)->R) -> (A,B,C,D,E)->R {
  return {(a,b,c,d,e) in fn(a)(b)(c)(d)(e)}
}

/// Uncurrying for functions expecting 6 arguments.
///
/// Transforms a curried function into a function taking 6 arguments.
///
/// :param: fn A curried function (A)→(B)→(C)→(D)→(E)→(F)→R
/// :returns: A function with 6 arguments, (A,B,C,D,E,F)→R
public func uncurry<A,B,C,D,E,F,R>(fn:(A)->(B)->(C)->(D)->(E)->(F)->R) -> (A,B,C,D,E,F)->R {
  return {(a,b,c,d,e,f) in fn(a)(b)(c)(d)(e)(f)}
}

/// Uncurrying for functions expecting 7 arguments.
///
/// Transforms a curried function into a function taking 7 arguments.
///
/// :param: fn A curried function (A)→(B)→(C)→(D)→(E)→(F)→(G)→R
/// :returns: A function with 7 arguments, (A,B,C,D,E,F,G)→R
public func uncurry<A,B,C,D,E,F,G,R>(fn:(A)->(B)->(C)->(D)->(E)->(F)->(G)->R) -> (A,B,C,D,E,F,G)->R {
  return {(a,b,c,d,e,f,g) in fn(a)(b)(c)(d)(e)(f)(g)}
}