Anonymous Function expression treated as a PartialFunction (spec needs broadened)

[scabug]

The following compiles, although I think the conversion to type PartialFunction from this anonymous function expression is disallowed (there is no mention in SLS, Section 6.23, Anonymous Functions)

val g: PartialFunction[Int, Int] = (x => x match { case 2 => 3 })

Section 8.5, Pattern Matching Anonymous Functions, introduces the syntax {case ...} for defining a PartialFunction. If a Function type is expected, then the expression {case ...} is reinterpreted as x => x match {case ...}. The strange thing here is that the opposite conversion is happening: a Function expression x => x match {case ...} is given, and the compiler is interpreting it as a PartialFunction, {case ...}.

Here's another example:

Seq(1, "a").collect(x => x match { case s: String => s }) // evaluates to Seq(a)

If the Function expression gets a little more complicated, the conversion from Function to PartialFunction fails:

// this compiles
val g: PartialFunction[Int, Int] = (x: Int) => {x match { case 2 => 3 }}

// this fails; found Function[Int, Int], required PartialFunction[Int, Int]
val g: PartialFunction[Int, Int] = (x: Int) => {(); x match { case 2 => 3 }}

Apologies if I am misunderstanding the Spec.

[scabug]

Imported From: https://issues.scala-lang.org/browse/SI-4940?orig=1
Reporter: Kipton Barros (kbarros)

[scabug]

Kipton Barros (kbarros) said:
To clarify, the issue is that the first code sample compiles, although it should be illegal according to (my reading of) the Spec. An anonymous function expression should not be a valid PartialFunction.

[scabug]

@lrytz said:
re-word the spec

[scabug]

@som-snytt said:
Arguably, 8.5 on pattern matching anon funcs already says that if the expected type is Func, then the block of cases is equivalent to the function. If additionally the expected type is narrower, a PartialFunc, then the expression is equivalent to the PF. Maybe substitute s/is/conforms to/.

[scabug]

@SethTisue said:
Why would be it desirable here to change the spec to match the compiler's behavior? My intuition matches Kipton's; it seems like a compiler bug to me.

[scabug]

@som-snytt said:
Bumping the bug part.

SKALA 2.11.7-20150616-093756-43a56fb5a1> val g: PartialFunction[String, Int] = (x: Int) => x match { case "x" => 3 }
g: PartialFunction[String,Int] = <function1>

[SethTisue]

someone want to take a look and see whether this should remain open? I wonder what Dotty does here.

[dwijnand]

// this fails; found Function[Int, Int], required PartialFunction[Int, Int]
val g: PartialFunction[Int, Int] = (x: Int) => {(); x match { case 2 => 3 }}

This one compiles now 😄

Welcome to Scala 2.13.1 (OpenJDK 64-Bit Server VM, Java 11.0.6).
Type in expressions for evaluation. Or try :help.

scala> val g: PartialFunction[Int, Int] = (x: Int) => {(); x match { case 2 => 3 }}
g: PartialFunction[Int,Int] = <function1>

In dotty it doesn't, and Som's variant doesn't work in Dotty:

scala> val g: PartialFunction[Int, Int] = (x: Int) => {(); x match { case 2 => 3 }}
1 |val g: PartialFunction[Int, Int] = (x: Int) => {(); x match { case 2 => 3 }}
  |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |                                    Found:    Int => Int
  |                                    Required: PartialFunction[Int, Int]

scala> val g: PartialFunction[String, Int] = (x: Int) => x match { case "x" => 3 }
1 |val g: PartialFunction[String, Int] = (x: Int) => x match { case "x" => 3 }
  |                                                                 ^^^
  |           Values of types String and Int cannot be compared with == or !=

I don't think this issue is worth fixing (but I'm fine with spec changes, less sure about compiler changes). voteForClose += 1