Turin Turin - 29 days ago 10
Scala Question

Operations on n-th argument of curried functions in scala

I'm working with a lot of curried functions, taking similar arguments, but not quite. For this reason I would find very beneficial to have a way to perform transposition, application and composition of n-th argument, as well as the 'final' result. Example:

val f :X=>Y=>W=>Z
def compose1[A](w :A=>Y) :X=>A=>W=>Z
def transpose1 :X=>W=>Y=>Z
def apply1(y :Y) :X=>W=>Z

It can be easily accomplished for a fixed value of n with something like this:

implicit class Apply2[X, Y, Z](private val f :X=>Y=>Z) extends AnyVal {
def transpose :Y=>X=>Z = { y :Y => x :X => f(x)(y) }
def provide(y :Y) :X=>Z ={ x :X => f(x)(y) }
def compose[A](y :A=>Y) : X=>A=>Z = { x :X => a :A => f(x)(y(a)) }
def apply[A, B]()(implicit ev :Z <:< (A=>B)) :Apply3[X, Y, A, B] = new Apply3[X, Y, A, B]((x :X) => (y :Y) => ev(f(x)(y)))

But of course I don't welcome the idea of copy-&-pasting 22 versions of this class. I can also quite easily do it for the last argument with a type class,
but the solution that would be similarily succint to scala's underscore notation for partial application of non-curried function eludes me. I feel it should be possible to achive the following:

val f :A=>B=>C=>D=>E=>F
val c = f()().compose( (x :X) => new C(x)) :A=>B=>X=>D=>E=>F
val t = f()().transpose :A=>B=>D=>C=>E=>F
val s = f()().set(new C()) :A=>B=>D=>E=>F

via an implicit conversion to some
which provides a recursive
method returning a nested

When all types are known, the brute solution of converting to a HList and back works, but shapless' dependency is a bit of a two-edged sword.


Ok, my mind still itches but I finally got it! Most difficult programming task I did in a while, though. If anyone has suggestions for improvement (including naming, notation and generally syntax) I'm all ears.

/** 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"&dollar;a&dollar;b&dollar;c" }().set(1.toByte)`
      * (after inlining) would be a function `{a :Any => c :Char => s"&dollar;a&dollar;{1.toByte}&dollar;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 &lt;:&lt; 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 &lt;:&lt; 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, X, Y=>Z])  = new NextArg[F, C, X, Y, 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, C, X, Y=>Z])  = new NextArg[F, C, X, Y, 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](f :A=>B) :Arg0[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, X, Y](x) {

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

    class NextArg[F, C[G], X, Y, A](val prev :Curry[F, C, X, Y=>A]) extends Curry[F, (C Compose X)#L, Y, 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)