Nel suo programmazione libro a Scala (capitolo 5 Sezione 5.9 Pg 93) Odersky menzionato questa espressione "bills !*&^%~ code!"Odersky è serio con "fatture! * E ^% ~ codice!"?
Nella nota sulla stessa pagina:
"A questo punto si dovrebbe essere in grado di capire che dato questo codice, il compilatore Scala sarebbe
invocare (bills.!*&^%~(code)).!()."
questo è un po 'criptico per me, qualcuno potrebbe spiegare che cosa sta succedendo qui?
Ciò che Odersky intende dire è che sarebbe possibile avere un codice valido simile a quello. Per esempio, il codice qui sotto:
class BadCode(whose: String, source: String) {
def ! = println(whose+", what the hell do you mean by '"+source+"'???")
}
class Programmer(who: String) {
def !*&^%~(source: String) = new BadCode(who, source)
}
val bills = new Programmer("Bill")
val code = "def !*&^%~(source: String) = new BadCode(who, source)"
bills !*&^%~ code!
basta copiare e incollare & sul REPL.
@Daniel grazie mille per questo fantastico esempio. Dovresti ricevere un distintivo di scala balck – stacker
@stacker Ho un distintivo d'oro, dovrebbe essere sufficiente per ora. :-) –
non sono sicuro se il libro fornisce metodo firme ma suppongo che sia solo un commento sullo zucchero sintattico della Scala in modo che assume se si digita:
bill add monkey
dove c'è un disegno di legge oggetto che ha un metodo add che prende un parametro allora interpreta automaticamente come:
bill.add(monkey)
Essere un po 'arrugginito Scala, non sono del tutto sicuro di come si divide codice! in (codice).!() tranne per un vago solletico delle celle grigie che il! l'operatore è usato per sparare a un attore che nei termini del compilatore può essere interpretato come un metodo implicito.!() sull'oggetto.
+1 per la spiegazione opzionale '.()', che dire di questo rumoroso '! * e ^% ~' hanno senso? – stacker
Il periodo è facoltativo per chiamare un metodo che accetta un singolo parametro o ha un elenco di parametri vuoto.
Quando questa funzione viene utilizzata, si presuppone che il blocco successivo dopo lo spazio che segue il nome del metodo sia il singolo parametro.
Pertanto,
(bollette.! * & ^% ~ (codice)).!().
è identico a
bollette! * & ^% ~ codice!
Il secondo punto esclamativo chiama un metodo sul valore restituito dalla prima chiamata di metodo.
La combinazione di ".()" È facoltativa con chiamate di metodo (come spiegato in precedenza da Wysawyg) e la possibilità di utilizzare (quasi) qualsiasi carattere che si preferisce per i metodi di denominazione, rende possibile scrivere metodi in Scala che sembrano come il sovraccarico dell'operatore. Puoi persino inventare i tuoi operatori.
Ad esempio, ho un programma che si occupa di computer grafica 3D. Io ho la mia classe Vector per rappresentare un vettore 3D:
class Vector(val x: Double, val y: Double, val z: Double) {
def +(v: Vector) = new Vector(x + v.x, y + v.y, z + v.z)
// ...etc.
}
Ho anche definito un metodo ** (non mostrato sopra) per calcolare i cross product di due vettori.È molto conveniente che tu possa creare i tuoi operatori come quello in Scala, non molti altri linguaggi di programmazione hanno questa flessibilità.
Nessuno ha spiegato il", ancora. – ziggystar
@ziggystar La domanda mancava la citazione di chiusura. Non è parte del codice. –
I per pensare che il signor Odersky dovrebbe evitare la moltitudine confusa di simboli e scrivere la profanità in ASCII. Almeno, questo è quello che mi piacerebbe fare. –