scala map / type instantiation

Question

can someone explain the best way to get around the following, rather curious type error. Suppose I create a list of tuples like so:

scala> val ys = List((1,2), (3,4), (5,6))
ys: List[(Int, Int)] = List((1,2), (3,4), (5,6))

Now, if I want to map this to a List(Int)

scala> ys.map((a: Int, b: Int) => a + b)
<console>:9: error: type mismatch;
found   : (Int, Int) => Int
required: ((Int, Int)) => ?
   ys.map((a: Int, b: Int) => a + b)
                           ^

Any clues? I know I can use the for comprehension

scala> for ((a, b) <- ys) yield a + b
res1: List[Int] = List(3, 7, 11)

But it feels wrong to bust out a comprehension in this setting. Thanks!

dhg · Accepted Answer · 2012-04-10 15:09:23Z

7

try:

ys.map { case (a: Int, b: Int) => a + b }

or:

ys.map(p: (Int, Int) => p._1 + p._2)

What's happening is that ys is a List of (Int,Int), so map expects a function from a single argument, which happens to be a tuple (Int,Int), to something else (technically, map expects an argument of Function1[(Int,Int),Int]. The function (a: Int, b: Int) => a+b is not actually a function from a single argument (Int, Int) to Int; instead it's a function of two arguments, both Ints, to an Int (a Function2[Int,Int,Int]). The difference is subtle, but important since Scala makes a distinction:

val f: Function1[(Int,Int),Int] = (p: (Int,Int)) => p._1 + p._2
ys.map(f) // fine

val g: Function1[(Int,Int),Int] = { case (a: Int, b: Int) => a + b }
ys.map(g) // fine, technically a PartialFunction[(Int,Int),Int]

val h: Function2[Int,Int,Int] = (a: Int, b: Int) => a + b
ys.map(h) // ERROR!

To explain my suggestions at the top of the answer: In the first example, we have changed the definition of the function given to map to use case, which tells Scala to unpack the single (Int,Int) argument into its two parts. (Note also the use of curly braces instead of parentheses.) In the second example, we have a function of a single tuple argument, p, and we manually extract each part of the tuple.

Finally, note that you don't need the type annotations either. These work just as well:

ys.map { case (a,b) => a + b }

ys.map(p => p._1 + p._2)

edited Apr 10, 2012 at 15:09

answered Apr 10, 2012 at 2:46

dhg

52.8k8 gold badges125 silver badges144 bronze badges

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

2 Comments

jwinder Over a year ago

It is worth noting that the solution using the "case" statement is supplying a partial function as an argument to map, which is why it is able to unapply the pair right away. And the reason a partial function can be provided instead of a regular function is that partial function extends function.

Ranjit Jhala Over a year ago

Sweet, thanks! This makes perfect sense. I got bitten by my ML background ... ;-)

Keith Pinson · Accepted Answer · 2012-04-10 12:30:34Z

0

try:

val ys = List((1,2),(3,4),(5,6))
ys map (t => t._1 + t._2)

answered Apr 10, 2012 at 12:30

Keith Pinson

1,7251 gold badge14 silver badges17 bronze badges

Collectives™ on Stack Overflow

scala map / type instantiation

2 Answers 2

2 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

2 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related