Fλip.scala

object Fλip {
  val tParams = (1 to 23).map { i =>
    (i + 'A' - 1).toChar
  }

  def getParams(arity: Int): IndexedSeq[Char] =
    (0 to arity).map(tParams(_))

  def getTypeSig(seq: IndexedSeq[Char]) =
    s"""(${seq.init.mkString(",")}) => ${seq.last}"""

  def getReverseTypeSig(seq: IndexedSeq[Char]) =
    s"""(${seq.init.reverse.mkString(",")}) => ${seq.last}"""

  def getDefIn(seq: IndexedSeq[Char]) = {
    val in = seq.init
    val args = in.map(_.toLower).mkString(",")
    val argsIn = in.reverse.map(c => s"${c.toLower}").mkString("(", ",", ")")
    s"$argsIn => λ($args)"
  }

  def make(arity: Int) = {
    val p = getParams(arity)
    val tparams = p.mkString(",")
    val sigIn = getTypeSig(p)
    val sigOut = getReverseTypeSig(p)
    val df = getDefIn(p)
    s"def flip[$tparams](λ: $sigIn): $sigOut = $df"
  }
}

/*
def flip[A,B](λ: (A) => B): (A) => B = (a:A) => λ(a)
def flip[A,B,C](λ: (A,B) => C): (B,A) => C = (b:B,a:A) => λ(a,b)
def flip[A,B,C,D](λ: (A,B,C) => D): (C,B,A) => D = (c:C,b:B,a:A) => λ(a,b,c)
def flip[A,B,C,D,E](λ: (A,B,C,D) => E): (D,C,B,A) => E = (d:D,c:C,b:B,a:A) => λ(a,b,c,d)
def flip[A,B,C,D,E,F](λ: (A,B,C,D,E) => F): (E,D,C,B,A) => F = (e:E,d:D,c:C,b:B,a:A) => λ(a,b,c,d,e)
def flip[A,B,C,D,E,F,G](λ: (A,B,C,D,E,F) => G): (F,E,D,C,B,A) => G = (f:F,e:E,d:D,c:C,b:B,a:A) => λ(a,b,c,d,e,f)
def flip[A,B,C,D,E,F,G,H](λ: (A,B,C,D,E,F,G) => H): (G,F,E,D,C,B,A) => H = (g:G,f:F,e:E,d:D,c:C,b:B,a:A) => λ(a,b,c,d,e,f,g)
def flip[A,B,C,D,E,F,G,H,I](λ: (A,B,C,D,E,F,G,H) => I): (H,G,F,E,D,C,B,A) => I = (h:H,g:G,f:F,e:E,d:D,c:C,b:B,a:A) => λ(a,b,c,d,e,f,g,h)
def flip[A,B,C,D,E,F,G,H,I,J](λ: (A,B,C,D,E,F,G,H,I) => J): (I,H,G,F,E,D,C,B,A) => J = (i:I,h:H,g:G,f:F,e:E,d:D,c:C,b:B,a:A) => λ(a,b,c,d,e,f,g,h,i)
def flip[A,B,C,D,E,F,G,H,I,J,K](λ: (A,B,C,D,E,F,G,H,I,J) => K): (J,I,H,G,F,E,D,C,B,A) => K = (j:J,i:I,h:H,g:G,f:F,e:E,d:D,c:C,b:B,a:A) => λ(a,b,c,d,e,f,g,h,i,j)
def flip[A,B,C,D,E,F,G,H,I,J,K,L](λ: (A,B,C,D,E,F,G,H,I,J,K) => L): (K,J,I,H,G,F,E,D,C,B,A) => L = (k:K,j:J,i:I,h:H,g:G,f:F,e:E,d:D,c:C,b:B,a:A) => λ(a,b,c,d,e,f,g,h,i,j,k)
def flip[A,B,C,D,E,F,G,H,I,J,K,L,M](λ: (A,B,C,D,E,F,G,H,I,J,K,L) => M): (L,K,J,I,H,G,F,E,D,C,B,A) => M = (l:L,k:K,j:J,i:I,h:H,g:G,f:F,e:E,d:D,c:C,b:B,a:A) => λ(a,b,c,d,e,f,g,h,i,j,k,l)
def flip[A,B,C,D,E,F,G,H,I,J,K,L,M,N](λ: (A,B,C,D,E,F,G,H,I,J,K,L,M) => N): (M,L,K,J,I,H,G,F,E,D,C,B,A) => N = (m:M,l:L,k:K,j:J,i:I,h:H,g:G,f:F,e:E,d:D,c:C,b:B,a:A) => λ(a,b,c,d,e,f,g,h,i,j,k,l,m)
def flip[A,B,C,D,E,F,G,H,I,J,K,L,M,N,O](λ: (A,B,C,D,E,F,G,H,I,J,K,L,M,N) => O): (N,M,L,K,J,I,H,G,F,E,D,C,B,A) => O = (n:N,m:M,l:L,k:K,j:J,i:I,h:H,g:G,f:F,e:E,d:D,c:C,b:B,a:A) => λ(a,b,c,d,e,f,g,h,i,j,k,l,m,n)
def flip[A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P](λ: (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) => P): (O,N,M,L,K,J,I,H,G,F,E,D,C,B,A) => P = (o:O,n:N,m:M,l:L,k:K,j:J,i:I,h:H,g:G,f:F,e:E,d:D,c:C,b:B,a:A) => λ(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o)
def flip[A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q](λ: (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P) => Q): (P,O,N,M,L,K,J,I,H,G,F,E,D,C,B,A) => Q = (p:P,o:O,n:N,m:M,l:L,k:K,j:J,i:I,h:H,g:G,f:F,e:E,d:D,c:C,b:B,a:A) => λ(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p)
def flip[A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R](λ: (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q) => R): (Q,P,O,N,M,L,K,J,I,H,G,F,E,D,C,B,A) => R = (q:Q,p:P,o:O,n:N,m:M,l:L,k:K,j:J,i:I,h:H,g:G,f:F,e:E,d:D,c:C,b:B,a:A) => λ(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q)
def flip[A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S](λ: (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R) => S): (R,Q,P,O,N,M,L,K,J,I,H,G,F,E,D,C,B,A) => S = (r:R,q:Q,p:P,o:O,n:N,m:M,l:L,k:K,j:J,i:I,h:H,g:G,f:F,e:E,d:D,c:C,b:B,a:A) => λ(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r)
def flip[A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T](λ: (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S) => T): (S,R,Q,P,O,N,M,L,K,J,I,H,G,F,E,D,C,B,A) => T = (s:S,r:R,q:Q,p:P,o:O,n:N,m:M,l:L,k:K,j:J,i:I,h:H,g:G,f:F,e:E,d:D,c:C,b:B,a:A) => λ(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s)
def flip[A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U](λ: (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T) => U): (T,S,R,Q,P,O,N,M,L,K,J,I,H,G,F,E,D,C,B,A) => U = (t:T,s:S,r:R,q:Q,p:P,o:O,n:N,m:M,l:L,k:K,j:J,i:I,h:H,g:G,f:F,e:E,d:D,c:C,b:B,a:A) => λ(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t)
def flip[A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V](λ: (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U) => V): (U,T,S,R,Q,P,O,N,M,L,K,J,I,H,G,F,E,D,C,B,A) => V = (u:U,t:T,s:S,r:R,q:Q,p:P,o:O,n:N,m:M,l:L,k:K,j:J,i:I,h:H,g:G,f:F,e:E,d:D,c:C,b:B,a:A) => λ(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u)
def flip[A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W](λ: (A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V) => W): (V,U,T,S,R,Q,P,O,N,M,L,K,J,I,H,G,F,E,D,C,B,A) => W = (v:V,u:U,t:T,s:S,r:R,q:Q,p:P,o:O,n:N,m:M,l:L,k:K,j:J,i:I,h:H,g:G,f:F,e:E,d:D,c:C,b:B,a:A) => λ(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v)
*/