PartialApply

Given a function with three parameters.

val f = { (v1: Int, v2: Int, v3: Int) => (v1 + v2) * v3 }

When partially applying the second parameter.

val partiallyApplied = f.partialApply(v2 = 2)

And applying the rest parameters.

val result = partiallyApplied(v3 = 3, v1 = 1)

Then the result should be the same as applying at once.

result should be(f(1, 2, 3))

A function with refined parameters can partially apply.

val f: ((Int, Double, String) => String) { def apply(i: Int, d: Double, s: String): String } = { (i, d, s) =>
  (i * d) + s
}
f.partialApply(s = "seconds").apply(i = 60, d = 1.125) should be(f(s = "seconds", i = 60, d = 1.125))

Partial applying can be chained.

val f = { (v1: Int, v2: Int, v3: Int) => (v1 + v2) * v3 }
f.partialApply(v2 = 2).partialApply(v3 = 3).partialApply(v1 = 1).apply() should be(f(1, 2, 3))

Function objects can partially apply.

object f extends ((Int, Double, String) => String) {
  def apply(i: Int, d: Double, s: String): String = {
    (i * d) + s
  }
}
f.partialApply(s = "seconds").apply(i = 60, d = 1.125) should be(f(s = "seconds", i = 60, d = 1.125))

Case class companion can partially apply.

case class MyCaseClass(i: Int, d: Double, s: String)
MyCaseClass.partialApply(s = "seconds").apply(i = 60, d = 1.125) should be(MyCaseClass(s = "seconds", i = 60, d = 1.125))

Call-by-name functions can partially apply.

def foo(v1: => String, v2: Int) = v1 + v2
val callByNameFunction = foo _
PartialApply.materialize[callByNameFunction.type, "v1"].apply(callByNameFunction, "1").apply(v2 = 2) should be(foo(v1 = "1", v2 = 2))