Turin - 2 months ago 14

Scala Question

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

`Apply`

`apply()`

`Apply`

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.

Answer

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"$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, 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)
```