preguntas de las clases de scala case

Question

Tengo dos preguntas con respecto a la clase de caso '::'.

:: puede ser utilizado como

case head :: tail => ... 

¿Cómo funciona? Es decir, ¿cuál es exactamente el flujo que usa Scala para hacer coincidir una instancia de List con la clase :: case? Dado que tengo una clase MiClase, con el operador op, puedo crear una clase llamada op caso de que puedo utilizar como:

case foo op bar => .... 

?

Answer 1

 scala> abstract class Stack { 
    |  def push(n :Int):Stack 
    | } 
     defined class Stack 

    scala> final case class push(st :Stack,hd :Int) extends Stack { 
    |  override def push(n :Int):Stack = new push(this,n) 
    | } 
    defined class push 

    scala> object NullStack extends Stack { 
    |  override def push(n :Int):Stack = new push(null,n) 
    | } 
    defined module NullStack 

    scala> val s = NullStack.push(1).push(2) 
    s: Stack = push(push(null,1),2) 

    scala> def test(s :Stack) = s match { case st push i => println(st +"push " + i) } 
    test: (Stack)Unit 

    scala> test(s) 
    push(null,1)push 2 

Answer 2

Es detalla en la página 301 del Programming in Scala, Acerca de patrones sobre List s.

The "cons" pattern x :: xs is a special case of an infix operation pattern. You know already that, when seen as an expression, an infix operation is equivalent to a method call. For patterns, the rules are different: When seen as a pattern, an infix operation such as p op q is equivalent to op(p, q) . That is, the infix operator op is treated as a constructor pattern. In particular, a cons pattern such as x :: xs is treated as ::(x, xs) . This hints that there should be a class named :: that correspond to the pattern constructor. Indeed there is such a class. It is named scala.:: and is exactly the class that builds non-empty lists.

Answer 3

En realidad, el hecho de que :: es una clase de caso es solo la mitad de la respuesta. La razón por la que esto funciona en la coincidencia de patrones es que existe un extractor para object ::, que se genera automáticamente cuando se define una clase de caso. Convenientemente, ::. Unapply devuelve una lista, porque :: extends List. Sin embargo, si desea utilizar el mismo truco para Listas, no podrá extender la Lista, porque es final. Lo que puede hacer es definir un objeto con el método apropiado de aplicación, que tiene la firma de devolución esperada. Por ejemplo, para que coincida con la última elemento de una lista, que puede hacer:

object ::> {def unapply[A] (l: List[A]) = Some((l.init, l.last))} 

List(1, 2, 3) match { 
    case _ ::> last => println(last) 
} 

(1 to 9).toList match { 
    case List(1, 2, 3, 4, 5, 6, 7, 8) ::> 9 => "woah!" 
} 
(1 to 9).toList match { 
    case List(1, 2, 3, 4, 5, 6, 7) ::> 8 ::> 9 => "w00t!" 
} 

El extractor debe devolver una opción, que contiene una tupla de los dos elementos de la deconstrucción.

Answer 4

El texto citado por eed3si9n está en la p. 331 en la edición en PDF de "Programación en Scala" (1ª edición)