Unexpected Scala pattern matching syntax

Question

I had a List of Scala tuples like the following:

val l = List((1,2),(2,3),(3,4))

and I wanted to map it in a list of Int where each item is the sum of the Ints in a the corresponding tuple. I also didn't want to use to use the x._1 notation so I solved the problem with a pattern matching like this

def addTuple(t: (Int, Int)) : Int = t match { 
    case (first, second) => first + second 
}
var r = l map addTuple

Doing that I obtained the list r: List[Int] = List(3, 5, 7) as expected. At this point, almost by accident, I discovered that I can achieve the same result with an abbreviated form like the following:

val r = l map {case(first, second) => first + second}

I cannot find any reference to this syntax in the documentation I have. Is that normal? Am I missing something trivial?

This syntax is nice, but for eays things like this I prefer l.map(t => t._1 + t._2). I think there is nothing wrong with the x._1 syntax — Landei
– Landei, Commented Sep 17, 2010 at 8:28

retronym · Accepted Answer · 2010-09-16 21:16:21Z

See Section 8.5 of the language reference, "Pattern Matching Anonymous Functions".

An anonymous function can be defined by a sequence of cases

{case p1 =>b1 ... case pn => bn }

which appear as an expression without a prior match. The expected type of such an expression must in part be defined. It must be either scala.Functionk[S1, ..., Sk, R] for some k > 0, or scala.PartialFunction[S1, R], where the argument type(s) S1, ..., Sk must be fully determined, but the result type R may be undetermined.

The expected type deternines whether this is translated to a FunctionN or PartialFunction.

scala> {case x => x}  
<console>:6: error: missing parameter type for expanded function ((x0$1) => x0$1 match {
  case (x @ _) => x
})
       {case x => x}
       ^

scala> {case x => x}: (Int => Int)
res1: (Int) => Int = <function1>

scala> {case x => x}: PartialFunction[Int, Int]
res2: PartialFunction[Int,Int] = <function1>

Alexey Romanov · Accepted Answer · 2010-09-16 21:16:02Z

4

{case(first, second) => first + second} is treated as a PartialFunction literal. See examples in "Partial Functions" section here: http://programming-scala.labs.oreilly.com/ch08.html or section 15.7 of Programming in Scala.

answered Sep 16, 2010 at 21:16

Alexey Romanov

172k38 gold badges329 silver badges509 bronze badges

Comments

George · Accepted Answer · 2010-09-16 21:16:55Z

1

Method map accepts a function. In your first example you create a function, assign it to a variable, and pass it to the map method. In the second example you pass your created function directly, omitting assigning it to a variable. You are doing just the same thing.

answered Sep 16, 2010 at 21:16

George

8,38812 gold badges67 silver badges109 bronze badges

1 Comment

Randall Schulz Over a year ago

Not precisely. In the first example, the method addTuple is defined. The compiler then uses partial application to generate an equivalent function which is passed to the map method invoked on l.

Collectives™ on Stack Overflow

Unexpected Scala pattern matching syntax

3 Answers 3

Comments

Comments

1 Comment

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

Comments

Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Linked

Related