loop - string*scala

Operador Scala @

Question

¿Qué hace el @ operador de Scala?

Por ejemplo, en la publicación de blog Formal Language Processing en Scala, Parte 2, hay algo como esto

case x @ Some(Nil) => x

Answer 1

Cuando la variable @ pattern coincidencia de patrón variable @ pattern vincula variables al valor que coincide con el patrón si el patrón coincide. En este caso, eso significa que el valor de x será Some(Nil) en esa case-clause.

Answer 2

Establece el valor de x en el patrón que coincide. En su ejemplo, x sería, por lo tanto, Some(Nil) (como podría determinar de una llamada a println )

Answer 3

Le permite a uno vincular un patrón combinado a una variable. Considere lo siguiente, por ejemplo:

val o: Option[Int] = Some(2)

Puede extraer fácilmente el contenido:

o match {
case Some(x) => println(x)
case None =>
}

Pero, ¿y si no quisieras el contenido de Some , sino la opción en sí? Eso se lograría con esto:

o match {
case x @ Some(_) => println(x)
case None =>
}

Tenga en cuenta que @ se puede usar en cualquier nivel, no solo en el nivel superior de la coincidencia.

Answer 4

Le permite hacer coincidir el nivel superior de un patrón. Ejemplo:

case x @ "three" => assert(x.equals("three"))
case x @ Some("three") => assert(x.get.equals("three")))
case x @ List("one", "two", "three") => for (element <- x) { println(element) }

Answer 5

@ se puede usar para vincular un nombre a un patrón coincidente exitoso, o subpatrón. Los patrones se pueden usar en la coincidencia de patrones, el lado izquierdo del <- en para las comprensiones y en las asignaciones de desestructuración.

scala> val d@(c@Some(a), Some(b)) = (Some(1), Some(2))
d: (Some[Int], Some[Int]) = (Some(1),Some(2))
c: Some[Int] = Some(1)
a: Int = 1
b: Int = 2
scala> (Some(1), Some(2)) match { case d@(c@Some(a), Some(b)) => println(a, b, c, d) }
(1,2,Some(1),(Some(1),Some(2)))
scala> for (x@Some(y) <- Seq(None, Some(1))) println(x, y)
(Some(1),1)
scala> val List(x, xs @ _*) = List(1, 2, 3)
x: Int = 1
xs: Seq[Int] = List(2, 3)