Синтаксис анонимной частичной функции

Вам нужно указать тип для bar, потому что компилятор не может его вывести. Это компилирует:

val foo = PartialFunction[Int, String] { case 1 => "foo" }
val bar : (Int => String) = foo orElse { case x => x.toString }

В случае List(1,2,3).collect{case x => x.toString} компилятор может вывести тип ввода частичной функции на основе того, как был введен List.

final override def collect[B, That](pf: PartialFunction[A, B])(implicit bf: CanBuildFrom[List[A], B, That])

На основе параметров типа компилятор может сделать вывод, что вы передаете правильно типизированную частичную функцию. Вот почему List(1,2,3).collect{case x:String => x.toString} не компилируется, как и List(1,2,3).collect{case x:Int => x.toString; case x: String => x.toString}.

Поскольку List является ковариантным, компилятор может сделать вывод, что частичная функция {case x => x.toString} является частичной функцией для Int. Вы заметите, что List(1,2,3).collect{case x => x.length} не компилируется, потому что компилятор делает вывод, что вы работаете либо с Int, либо с подклассом Int.

Также имейте в виду, что {case x => x.toString} — это просто синтаксический сахар. Если мы сделаем что-то вроде приведенного ниже, ваш пример будет работать так, как ожидалось.

val f = new PartialFunction[Int, String](){
  override def isDefinedAt(x: Int): Boolean = true
  override def apply(v1: Int): String = v1.toString
}

val foo = PartialFunction[Int, String] { case 1 => "foo" }

val bar = foo orElse f //This compiles fine.

List(1,2,3).collect{f} // This works as well.

Таким образом, единственный логичный ответ, с моей точки зрения, заключается в том, что синтаксический сахар, способный генерировать экземпляр PartialFunction для {case x => x.toString}, не имеет достаточно информации во время компиляции, чтобы иметь возможность адекватно ввести его как PartialFunction[Int, String] в вашем случае orElse.

Вы можете использовать библиотеку Extractor.scala.

import com.thoughtworks.Extractor._

// Define a PartialFunction
val pf: PartialFunction[Int, String] = {
  case 1 => "matched by PartialFunction"
}

// Define an optional function
val f: Int => Option[String] = { i =>
  if (i == 2) {
    Some("matched by optional function")
  } else {
    None
  }
}

// Convert an optional function to a PartialFunction
val pf2: PartialFunction[Int, String] = f.unlift

util.Random.nextInt(4) match {
  case pf.extract(m) => // Convert a PartialFunction to a pattern
    println(m)
  case f.extract(m) => // Convert an optional function to a pattern
    println(m)
  case pf2.extract(m) => // Convert a PartialFunction to a pattern
    throw new AssertionError("This case should never occur because it has the same condition as `f.extract`.")
  case _ =>
    println("Not matched")
}