Descomposición de la coincidencia de Scala en el operador infijo

Question

Estoy tratando de comprender la implementación de List s en Scala. En particular, estoy tratando de conseguir mi cabeza alrededor de cómo se puede escribir expresiones usando un operador infijo, por ejemplo:

a match { 
    case Nil => "An empty list" 
    case x :: Nil => "A list without a tail" 
    case x :: xs => "A list with a tail" 
} 

¿Cómo es la expresión de coincidencia permite ser x :: xs en lugar de List(x, xs)?

Answer 1

La respuesta de Jay Conrad es casi correcta. Lo importante es que en algún lugar hay un objeto llamado :: que implementa el método unapply, devolviendo el tipo Option[(A, List[A])]. Thusly:

object :: { 
    def unapply[A](ls: List[A]) = { 
    if (ls.empty) None 
    else Some((ls.head, ls.tail)) 
    } 
} 

// case objects get unapply for free 
case object Nil extends List[Nothing] 

En el caso de :: y List, este objeto pasa a salir del hecho de que :: es una clase de caso que se extiende el rasgo List. Sin embargo, como muestra el ejemplo anterior, no es tener para ser una clase de caso en absoluto.

Answer 2

Creo :: is actually a class (que es una subclase de List), por lo que decir x :: xs es en su mayoría equivalente a List(x, xs).

Puede hacer esto con otras clases de casos que tengan nombres de operadores. Por ejemplo:

case class %%%(x: Int, y: Int) 

a match { 
    case x %%% y => x + y 
} 

Answer 3

¿Cómo se permite que la expresión coincida sea x :: xs en lugar de List (x, xs)?

Para responder a esta pregunta:

Cuando se ve como un patrón , una operación infija como p op q es equivalente a op (p, q). Es decir, el operador de infix op se trata como un patrón de constructor.

(Programación en Scala, 1st ed., P. 331)

Véase también scala case classes questions