In the scala function literal, when do I have to use the "case" keyword

Question

I keep stumpling upon this problem and it is annoying (Scala 2.13.4).

    case class Coord(x: Int, y: Int)
    val data: List[(Int, Int)] = List( (1,2), (3,4) )

    data.map{ (x,y)  =>
      Coord(x,y)
    }

gives me this error:

 found   : (Int, Int) => Coord
 required: ((Int, Int)) => Coord

Which I can resolve by adding the "case" keyword

    data.map{ case (x,y) =>
      Coord(x,y)
    }

My question ist when is it mandatory to use the 'case' keyword (here in this specific case and in general). The compiler should already know that it will get a tuple of Int. It seems that most of the time it is not needed. Are there special rules for tuples because they also use parens?

Answer 1

It's never mandatory to use case in a function literal.

{ (x, y) => ??? }

defines a function of two arguments, akin to what you'd get from code like

object Foo extends Function2[A, B, C] {
  def apply[A, B, C](x: A, y: B): C = ???
}

When passing a tuple, the tuple is passed as a single argument and it then needs to be destructured inside the function. The following are all equivalent ways of destructuring the tuple

{ tuple => 
  val (x, y) = tuple
  ???
}

{ tuple =>
  tuple match {
    case (x, y) => ???
  }
}

{ case (x, y) => ??? }

Note that if you have a function value which takes more than 1 argument, that value has a tupled method which converts a function of n arguments into a function taking a single tuple of n components.

val f = { (x: Int, y: Int) => Coord(x, y) }
// alternatively:
// val f: (Int, Int) => Coord = Coord.apply

val coordinatePairs = List( (1, 2), (3, 4) )
// alternatively:
// val coordinatePairs = List(1 -> 2, 3 -> 4)

coordinatePairs.map(f.tupled)

Answer 2

data.map{ case (x,y) =>
  Coord(x,y)
}

is equivalent to

data.map { tuple =>
  tuple match {
    case (x, y) => Coord(x,y)
  }
}

Its called pattern matching anonymous function .