100
Cosa fa l'operatore di Scala @?Operatore Scala @
Ad esempio, nel post del blog Formal Language Processing in Scala, Part 2 c'è un qualcosa di simile
case x @ Some(Nil) => x
A
risposta
136
Consente di associare un modello abbinato a una variabile. Si consideri il seguente, per esempio:
val o: Option[Int] = Some(2)
Si può facilmente estrarre il contenuto:
o match {
case Some(x) => println(x)
case None =>
}
Ma cosa succede se non il contenuti di Some volevi, ma l'opzione per sé? Questo sarebbe essere realizzato con questo:
o match {
case x @ Some(_) => println(x)
case None =>
}
noti che @ può essere utilizzato in qualsiasi livello, non solo al livello superiore della corrispondenza.
6
consente di adattare il livello superiore di un modello. Esempio:
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) }
+4
Non solo di livello superiore. –
8
Quando pattern matching variable @ pattern lega variabile al valore riscontro modello se il modello corrisponde. In questo caso, ciò significa che il valore di x sarà Some(Nil) in tale clausola.
2
Imposta il valore di x nel modello che corrisponde. Nel tuo esempio, x sarebbe quindi Some(Nil) (come si potrebbe determinare da una chiamata a println)
+0
Accidenti all'incapacità degli iPhone di rendere un backtick! –
58
@ può essere utilizzato per associare un nome a un modello abbinato con successo, o sotto-regola. I pattern possono essere utilizzati nella corrispondenza dei pattern, nella parte sinistra di <- per le comprensioni e negli assetti di destrutturazione.
scala> val [email protected]([email protected](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 [email protected]([email protected](a), Some(b)) => println(a, b, c, d) }
(1,2,Some(1),(Some(1),Some(2)))
scala> for ([email protected](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)
Dove trovo la risposta nella documentazione? Ho la sensazione che ci siano anche altre cose buone sepolte lì. :) –
@Jim Scala Reference, 8.1. 8.12, in particolare, anche se non so da dove viene "come al solito" - e 8.12 si parla solo di pattern di espressioni regolari ('_ *'). Ma forse questo è stato chiarito su una versione più recente della specifica. –
Aggiungo che probabilmente non userete '@' con 'Some (_)', ma piuttosto se volete abbinare il contenuto di 'Some', ma fate comunque riferimento a Some stesso, ad es. 'case x @ Some (7) => println (x)'. Mentre lo interpreto 'case x @ Some (_)' è solo una versione più dettagliata di 'case x: Some'. – Theo