scala中curry函数的第n个参数的运算

/** Represents a partially applied,curried function `F` which is of the form `... X => A`,* where X is the type of the first argument after (partial) application.
  * Provides methods for manipulating functions `F` around this argument.
  * @tparam F type of the manipulated function in a curried form (non-empty sequence of single argument lists)
  * @tparam C[G] result of mapping partial result `(X=>A)` of function `F` to `G`.
  * @tparam X type of the argument represented by this instance
  * @tparam A result type of function F partially applied up to and including argument X
  */
abstract class Curry[F,C[G],X,A](private[funny] val f :F) { prev =>
    /** Result of partial application of this function F up to and including parameter `X`. */
    type Applied = A
    /** Replace X=>A with G as the result type of F. */
    type Composed[G] = C[G]
    /** A function which takes argument `W` instead of `X` at this position. */
    type Mapped[W] = Composed[W=>A]


    /** Provide a fixed value for this argument,removing it from the argument list.
      * For example,the result of `Curry{a :Any => b :Byte => c :Char => s"$a$b$c" }().set(1.toByte)`
      * (after inlining) would be a function `{a :Any => c :Char => s"$a${1.toByte}$c" }`.
      */
    def set(x :X) :Composed[A] = applied[A](_(x))

    /** Change the type of this argument by mapping intended argument type `W` to `X` before applying `f`.
      * For example,given a function `f :F <:< D=>O=>X=>A` and `x :W=>X`,the result is `{d :D => o :O => w :W => f(d)(o)(x(w)) }`.
      */
    def map[W](x :W=>X) :Composed[W=>A] = applied[W=>A]{ r :(X=>A) => (w :W) => r(x(w)) }

    /** Map the result of partial application of this function up to argument `X` (not including).
      * For example,if `F =:= K=>L=>X=>A`,the result is a function `{k :K => l :L => map(f(k)(l)) }`.
      * @param map function taking the result of applying F up until argument `X`.
      * @return resul
      */
    def applied[G](map :((X => A) => G)) :Composed[G]

    /** If the result of this partial application is a function `A <:< Y=>Z`,swap the order of arguments
      * in function `F` from `=>X=>Y=>` to `=>Y=>X=>`.
      */
    def transpose[Y,Z](implicit ev :A<:<(Y=>Z)) :Composed[Y=>X=>Z] = applied[Y=>X=>Z] {
        r :(X=>A) => y :Y => x :X => ev(r(x))(y)
    }


    /** Skip to the next argument,i.e return an instance operating on the result of applying this function to argument `X`. */
    def apply[Y,Z]()(implicit ev :this.type<:<Curry[F,C,Y=>Z])  = new NextArg[F,Z](ev(this))

    /** Skip to the next argument,i.e return an instance operating on the result of applying this function to argument `X`.
      * Same as `apply()`,but forces an implicit conversion from function types which `apply` wouldn't.
      */
    def __[Y,Z](implicit ev :this.type<:<Curry[F,Z](ev(this))
}


/** Operations on curried functions. */
object Curry {
    type Self[G] = G
    type Compose[C[G],X] = { type L[G] = C[X=>G] }

    /** Extension methods for modifying curried functions at their first argument (and a source for advancing to subsequent arguments. */
    @inline def apply[A,B](f :A=>B) :Arg0[A,B] = new Arg0(f)

    /** Implicit conversion providing extension methods on curried function types. Same as `apply`,but doesn't pollute namespace as much. */
    @inline implicit def ImplicitCurry[A,B] = new Arg0(f)

    /** Operations on the first argument of this function. */
    class Arg0[X,Y](x :X=>Y) extends Curry[X=>Y,Self,Y](x) {

        def applied[G](map: (X=>Y) => G) :G = map(f)
    }

    class NextArg[F,A](val prev :Curry[F,Y=>A]) extends Curry[F,(C Compose X)#L,A](prev.f) {

        override def applied[G](map: (Y => A) => G): prev.Composed[X => G] =
            prev.applied[X=>G] { g :(X=>Y=>A) => x :X => map(g(x)) }
    }
}


def f :Byte=>Short=>Int=>Long=>String = ???

import Curry.ImplicitCurry

f.set(1.toByte) :(Short=>Int=>Long=>String)
f.map((_:String).toByte) :(String=>Short=>Int=>Long=>String)
f.__.set(1.toShort) :(Byte=>Int=>Long=>String)
Curry(f)().map((_:String).toShort) : (Byte=>String=>Int=>Long=>String)