Scala function combination with generics

Question

I want to combine 2 Scala functions into a 3rd with andThen but am running into problems with the type system.

Here is the code:

object Test{

  def process1[T](in : List[T]) : List[T] = in

  def process2[T](in : List[T]) : List[T] = in

  //this works fine but you have to read it inside out
  def combined2[T](in : List[T]) : List[T] = process2(process1(in))

  //this also works but at the cost of creating a new function every time
  def combined3[T](in : List[T]) : List[T] = {
    (process1[T] _ andThen process2[T] _)(in)
  }

  //this doesn't work. it is a function List[Nothing] => List[Nothing]
  val combined = process1 _ andThen process2 _

  def main(s : Array[String]) {
    val input : List[Int] = List(1,2,3)
    val out1 : List[Int] = process1(input)

    val combinedOut2 : List[Int] = combined2(input)

    val combinedOut3 : List[Int] = combined3(input)

    //this will not compile as combined is [List[Nothing] => List[Nothing]
    //val combinedOut : List[Int] = combined(input)
  }
}

Is there a nice way to get the value of combined to be a function from List[T] to List[T] or is this a fundamental problem with type erasure?

It's fundamental problem of scala type system. I suggest you to start with chuusai.com/2012/04/27/shapeless-polymorphic-function-values-1 and read part 2 & 3. Shapeless polymorphic functions can be a solution — Eugene Zhulenev
– Eugene Zhulenev, Commented Nov 6, 2014 at 6:03

serega · Accepted Answer · 2014-11-06 12:51:49Z

1

Not sure if it's nice, but combined3 can be shortened to:

def combined3[T] = process1[T] _ andThen process2[T] _

Creation of function instances every time may be optimized for each case:

val combinedInt = combined3[Int]

combinedInt(input)

answered Nov 6, 2014 at 12:51

serega

5741 gold badge5 silver badges14 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Milind · Accepted Answer · 2016-04-16 06:22:09Z

0

You can combine functions this way, it's more cleaner

implicit class FunctionCombiner[T, U](fn: T => U) {
    def &&&(f: T => U): T => U = {
        (t: T) => {
            fn(t); f(t)
        }
    }
}

After this you can run statements like:

val f1 = (i: Int) => println((1*i).toString)
val f2 = (i: Int) => println((2*i).toString)
val f3 = (i: Int) => println((3*i).toString)

val f = f1 &&& f2 &&& f3

f(5)

This produces result:

5
10
15

answered Apr 16, 2016 at 6:22

Milind

12 bronze badges

Collectives™ on Stack Overflow

Scala function combination with generics

2 Answers 2

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related