Scala: Why foreach with a single argument function does not work with a zipped result

Question

I have the following Scala program:

object Test extends App {
  val zip = (List(1, 3, 5), List(2, 4, 6)).zipped

  val f: Tuple2[Int, Int] => Unit = x => println(x._1 + x._2)

  zip.foreach(f)
}

Why I get the following compiler error:

Error:(6, 15) type mismatch;
 found   : ((Int, Int)) => Unit
 required: (Int, Int) => ?
 zip.foreach(f)

when there is an implicit conversion from Tuple2Zipped to Traversable where foreach[U](f: ((El1, El2)) => U): Unit is defined.

NOTE: I edited my question to clarify.

I know that the foreach defined in Tuple2Zipped has the following signature:

def foreach[U](f: (El1, El2) => U): Unit

and that my function f does not fit as the argument.

But in Tuple2Zipped.scala is defined the trait ZippedTraversable2 and his companion object this way:

trait ZippedTraversable2[+El1, +El2] extends Any {
  def foreach[U](f: (El1, El2) => U): Unit
}
object ZippedTraversable2 {
  implicit def zippedTraversable2ToTraversable[El1, El2](zz: ZippedTraversable2[El1, El2]): Traversable[(El1, El2)] = {
    new scala.collection.AbstractTraversable[(El1, El2)] {
      def foreach[U](f: ((El1, El2)) => U): Unit = zz foreach Function.untupled(f)
    }
  }
}

so as my function f does match the argument of the foreach defined in the Traversable returned by zippedTraversable2ToTraversable and the companion object defines an implicit conversion from ZippedTraversable2 to this Traversable and Tuple2Zipped is a ZippedTraversable2, i think that this conversion has to be tried and my function be accepted.

The Intellij Idea editor accepts my construct without reporting any error but the compiler fails with the shown error.

Answer 1

Here is yet another, and slightly more esoteric, way to fix your code.

zip.foreach(Function.untupled(f))

Function.untupled() will take a ((Int, Int)) => Unit, which is what you've got in f, and return a (Int, Int) => Unit, which is what you need to process the zip elements.

Answer 2

Your function f is wrong ( it's also explicitly stated in the error )

zip.foreach expectes Function2 that takes type T1, type T2 and returns R, but you are passing a Function1 that takes Tuple2[Int,Int] as type T1

Here's an explaination regarding your compilation error :

found : ((Int, Int)) => Unit EQUALS Function1[Tuple2[Int,Int]] => Unit

Whereas

required: (Int, Int) => Unit EQUALS Function2[Int,Int,Unit]

(Keep in mind that () is syntactic sugar for Tuple* , that's why your are seeing the double parenthesis)

Here's an example that compiles :

val zip = (List(1, 3, 5), List(2, 4, 6)).zipped
val f:Function2[Int,Int,Unit]  = (x,y) => println(x + y)
zip.foreach[Unit](f)

Answer 3

Your object is a runtime.Tuple2Zipped, if you look at the signature

def foreach[U](f: (El1, El2) => U): Unit

It takes a function f: (El1, E1l2) => U, but your function is f: ((El1, El2)) => U, hence the error.

I found it confusing too, as Tuple2Zipped almost looks like a List[(A,B)], in fact the toList method would produce just that:

val zip = (List(1, 3, 5), List(2, 4, 6)).zipped.toList
val f: Tuple2[Int, Int] => Unit = x => println(x._1 + x._2)
zip.foreach(f)

Edit

I think you are looking for an implicit conversion from ((A, B)) => U to (A, B) => U which is not what zippedTraversable2ToTraversable does. You can define something like this that would work:

implicit def tupconv[A,B] (f: (((A,B)) => Unit)): (A, B) => Unit = Function.untupled(f)

Edit V2

For the code above you'd need an implicit variable in scope that would map from ((A,B)) => Unit to (A, B) => Unit as that's where the mismatch is. Whereas the one you quoted does ZippedTraversable2[El1, El2] to Traversable[(El1, El2)]. If you'd like to make use of that implicit conversion, you could do this:

val zip = (List(1, 3, 5), List(2, 4, 6)).zipped
val f: Tuple2[Int, Int] => Unit = x => println(x._1 + x._2)
def thisUsesTheImplicitYouWant(t: Traversable[(Int,Int)]) = t.foreach(f)
thisUsesTheImplicitYouWant(zip)

Answer 4

Thanks to Jasper-M I have known that a Scala bug has been reported on this issue: https://github.com/scala/bug/issues/9523. This bug was reported by Michael Pollmeier that asked this question one and a half years ago: Why does Scala implicit resolution fail for overloaded method with type parameter?

jamborta posted a question with a more generic example on this same issue here.