Función parcial vacía en Scala

partialfunction

Question

Me parece que la sintaxis { case ... => ... } para funciones parciales requiere al menos un case :

scala> val pf: PartialFunction[String, String] = { case "a" => "b" } 
pf: PartialFunction[String,String] = <function1>

scala> val pf: PartialFunction[String, String] = { }                
<console>:5: error: type mismatch;
 found   : Unit
 required: PartialFunction[String,String]
       val pf: PartialFunction[String, String] = { }
                                                 ^

Entonces, ¿cuál es la mejor manera de definir una función parcial "vacía"? ¿Hay alguna manera mejor que la anulación "manual" isDefinedAt y apply ?

Answer 1

Desde Scala 2.10 puedes usar:

val emptyPf = PartialFunction.empty[String, String]

Answer 2

El más corto que puedo pensar:

{ case _ if false => "" }

Answer 3

Map es una función parcial para que pueda hacer:

val undefined: PartialFunction[Any, Nothing] = Map.empty

Answer 4

Puede ser interesante saber que está previsto agregar un miembro vacío a la biblioteca scala y ver cómo se implementa: https://github.com/scala/scala/commit/6043a4a7ed5de0be2ca48e2e65504f56965259dc

Answer 5

Robo de todos, una posible combinación de todo:

val undefined : PartialFunction[Any, Nothing] = {case _ if false =>
  sys.error("undefined")
}

Answer 6

Una solución (que es más un truco) es garantizar que el caso nunca sea verdadero: { case x if x != x => sys.error("unexpected match") }

Curiosidad simple, ¿por qué necesitas esa función?

Answer 7

scala> def pfEmpty[A, B] = new PartialFunction[A, B] {
     |   def apply(a: A): B = sys.error("Not supported")
     |   def isDefinedAt(a: A) = false
     | }
pfEmpty: [A, B]=> java.lang.Object with PartialFunction[A,B]

scala> val f = pfEmpty[String, String]
f: java.lang.Object with PartialFunction[String,String] = <function1>

scala> f.lift
res26: (String) => Option[String] = <function1>

scala> res26("Hola")
res27: Option[String] = None

Como dijo @didierd en los comentarios, debido a las variaciones de los argumentos, una sola instancia puede abarcar todos los posibles tipos de argumentos.

scala> object Undefined extends PartialFunction[Any, Nothing] {
     |   def isDefinedAt(a: Any) = false
     |   def apply(a: Any): Nothing = sys.error("undefined")
     | }
defined module Undefined

scala> val f: PartialFunction[String, String] = Undefined
f: PartialFunction[String,String] = <function1>

scala> f.lift apply "Hola"
res29: Option[String] = None