Scala underscore notation for map and filter

Question

Say I have the following code:

val a: List[(Int, String)] = List((1,"A"),(2,"B"),(3,"C"))
val b: List[String] = List("A","C","E")

I can do:

a.map{case (fst,snd) => (fst,snd + "a")}
a.filter{case (_,snd) => b.contains(snd)}

But why can't I do:

a.map((_._1,_._2 + "a"))
a.filter(b.contains(_._2))

Is there a way to accomplish this using underscore notation, or am I forced here?

Answer 1

For the example:

a.map((_._1,_._2 + "a"))

Each placeholder (i.e. each underscore/_) introduces a new parameter in the argument expression.

To cite the Scala spec

An expression (of syntactic category Expr) may contain embedded underscore symbols _ at places where identifiers are legal. Such an expression represents an anonymous function where subsequent occurrences of underscores denote successive parameters.

[...]

The anonymous functions in the left column use placeholder syntax. Each of these is equivalent to the anonymous function on its right.

|---------------------------|----------------------------|
|`_ + 1`                    | `x => x + 1`               |
|`_ * _`                    | `(x1, x2) => x1 * x2`      |
|`(_: Int) * 2`             | `(x: Int) => (x: Int) * 2` |
|`if (_) x else y`          | `z => if (z) x else y`     |
|`_.map(f)`                 | `x => x.map(f)`            |
|`_.map(_ + 1)`             | `x => x.map(y => y + 1)`   |

You'll have to use the expanded forms when you need to use a given parameter more than once. So your example has to be rewritten as:

a.map(x => (x._1, x._2 + "a"))

---

For the example

a.filter(b.contains(_._2))

The problem is that you are effectively passing in an anonymous function to contains rather than filter, so you won't be able to use underscore notation here either. Instead you'll have to write

a.filter(x => b.contains(x._2))