Applying an argument list to curried function using foldLeft in Scala

by

This turns out to be quite a bit simpler than I initially expected.

First we need to define a simple HList,

sealed trait HList

final case class HCons[H, T <: HList](head : H, tail : T) extends HList {
  def ::[H1](h : H1) = HCons(h, this)
  override def toString = head+" :: "+tail.toString
}

trait HNil extends HList {
  def ::[H1](h : H1) = HCons(h, this)
  override def toString = "HNil"
}

case object HNil extends HNil
type ::[H, T <: HList] = HCons[H, T]

Then we can define our fold-like function inductively with the aid of a type class,

trait FoldCurry[L <: HList, F, Out] {
  def apply(l : L, f : F) : Out
}

// Base case for HLists of length one
implicit def foldCurry1[H, Out] = new FoldCurry[H :: HNil, H => Out, Out] {
  def apply(l : H :: HNil, f : H => Out) = f(l.head)
}

// Case for HLists of length n+1
implicit def foldCurry2[H, T <: HList, FT, Out]
  (implicit fct : FoldCurry[T, FT, Out]) = new FoldCurry[H :: T, H => FT, Out] {
    def apply(l : H :: T, f : H => FT) = fct(l.tail, f(l.head))
}

// Public interface ... implemented in terms of type class and instances above
def foldCurry[L <: HList, F, Out](l : L, f : F)
  (implicit fc : FoldCurry[L, F, Out]) : Out = fc(l, f)

We can use it like this, first for your original example,

val f1 = (i : Int, j : Int, k : Int, l : Int) => i+j+k+l
val f1c = f1.curried

val l1 = 1 :: 2 :: 3 :: 4 :: HNil

// In the REPL ... note the inferred result type
scala> foldCurry(l1, f1c)
res0: Int = 10

And we can also use the same unmodified foldCurry for functions with different arity’s and non-uniform argument types,

val f2 = (i : Int, s : String, d : Double) => (i+1, s.length, d*2)
val f2c = f2.curried

val l2 = 23 :: "foo" :: 2.0 :: HNil

// In the REPL ... again, note the inferred result type
scala> foldCurry(l2, f2c)
res1: (Int, Int, Double) = (24,3,4.0)

More Related Contents:

  1. What’s the difference between multiple parameters lists and multiple parameters per list in Scala?
  2. Scala currying vs partially applied functions
  3. Two ways of currying in Scala; what’s the use-case for each?
  4. Usefulness (as in practical applications) of Currying v.s. Partial Application in Scala
  5. Why does Scala provide both multiple parameters lists and multiple parameters per list? [duplicate]
  6. Are HLists nothing more than a convoluted way of writing tuples?
  7. What is a higher kinded type in Scala?
  8. How to define partitioning of DataFrame?
  9. Case class equality in Apache Spark
  10. What is the difference between Scala’s case class and class?
  11. Confused with the for-comprehension to flatMap/Map transformation
  12. Dropping a nested column from Spark DataFrame
  13. sbt-assembly: deduplication found error
  14. What does param: _* mean in Scala?
  15. Syntax sugar: _* for treating Seq as method parameters
  16. How to create a TypeTag manually?
  17. Weird behavior trying to convert case classes to heterogeneous lists recursively with Shapeless
  18. java.lang.NoClassDefFoundError: org/apache/spark/streaming/twitter/TwitterUtils$ while running TwitterPopularTags
  19. How to use COGROUP for large datasets
  20. Forward References – why does this code compile?
  21. Spark: Add column to dataframe conditionally
  22. How to clone a case class instance and change just one field in Scala?
  23. How to use third party libraries with Scala REPL?
  24. How do I pattern match arrays in Scala?
  25. Turning A => M[B] into M[A => B]
  26. How to print the contents of RDD?
  27. Can I import from multiple packages all at once in Scala?
  28. Scala-Spark Dynamically call groupby and agg with parameter values
  29. Joining two dataframes without a common column
  30. Scala best way of turning a Collection into a Map-by-key?

Leave a Comment