Eu estou tentando entender a implementação de Lists em Scala. Em particular, eu estou tentando obter minha cabeça em torno de como você pode escrever expressões de correspondência usando um operador infix, por exemplo:
a match {
case Nil => An empty list
case x :: Nil => A list without a tail
case x :: xs => A list with a tail
}
Como é a expressão de correspondência autorizados a estar x :: xsem vez de List(x, xs)?
Acredito :: é realmente uma classe (que é uma subclasse de List), assim dizendo x :: xsé principalmente equivalente a List(x, xs).
Você pode fazer isso com outras classes de casos que têm nomes de operadores. Por exemplo:
case class %%%(x: Int, y: Int)
a match {
case x %%% y => x + y
}
A resposta de Jay Conrad é quase certa. O importante é que em algum lugar existe um objeto chamado ::que implementa o unapplymétodo, retornando tipo Option[(A, List[A])]. assim:
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]
No caso de ::e List, este objeto acontece a sair do fato de que ::é um caso classe que estende o Listtraço. No entanto, como mostra o exemplo acima, ele não tem que ser uma classe caso.
Como é a expressão de correspondência permitido ser x :: xs em vez de Lista (x, xs)?
Para responder a esta pergunta:
Quando visto como um padrão , uma operação infixa tais como p op q é equivalente a op (p, q) . Ou seja, o op operador infixo é tratado como um padrão de construtor .
(Programação em Scala, 1 ed., P. 331)
Veja também Scala classes case perguntas