primi veri passi
Daniele Dellafiore
http://www.codecommit.com/blog/scala/scala-for-java-refugees-part-2
fa l'esempio della shape mai rossa e mette un bel if:
def fillColor_=(fillColor:Color) = {
if (!fillColor.equals(Color.RED)) {
theFillColor = fillColor
} else {
throw new IllegalArgumentException("Color cannot be red")
}
}
e poi mostra la sintassi ruby:
raise "Color cannot be red" if color == Color::RED
direi nettamente superiore anche rispetto all'eventuale utilizzo di un
if ternario.
Esiste una cosa simile in Scala?
--
Daniele Dellafiore
http://blog.ildella.net/
gabriele renzi
non sono comparabili, lo snippet ruby equivalente al 100% è
def fill_color=(color) # se usi una string exception come fai client
side a fare rescue?
raise ArgumentError.new("Color cannot be red") if color == Color::RED
@fill_color = color
end
in scala immagino sarebbe semplificabile eliminando equals (tanto ==
lo richiama) e riordinando
def fillColor_=(color: Color) = {
if (color == Color.RED)
throw new IllegalArgumentException("Color cannot be red")
theFillColor = color
}
e a questo punto sono abbastanza uguali :)
--
blog en: http://www.riffraff.info
blog it: http://riffraff.blogsome.com
Lorenzo Bolzani
>
> raise "Color cannot be red" if color == Color::RED
>
> direi nettamente superiore anche rispetto all'eventuale utilizzo di un
> if ternario.
> Esiste una cosa simile in Scala?
Ma lo scopo e' far compilare questo frammento di codice in scala
oppure sapere qual'e' lo scala idiom corrispondente?
Visto che si riesce a far compilare del codice simil basic penso sia
possibile masticare anche questo, magari stasera ci provo.
Non so altrimenti se ci sia un modo di mettere la condizione
"postfissa" ad un'instruzione.
print("aaa") if not monday
Ciao
Lorenzo
Franco Lombardo
> Visto che si riesce a far compilare del codice simil basic penso sia
> possibile masticare anche questo
Ad esempio così:
http://www.francolombardo.net/ruby-in-scala_post-79.html
(ma si può fare meglio ;-)
Ciao
Franco
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
http://www.francolombardo.net
Scala, Java, As400.....
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Daniele Dellafiore
Lorenzo Bolzani
>
> Il 23/04/09, Lorenzo Bolzani<l.bo...@gmail.com> ha scritto:
>> Visto che si riesce a far compilare del codice simil basic penso sia
>> possibile masticare anche questo
>
> Ad esempio così:
> http://www.francolombardo.net/ruby-in-scala_post-79.html
>
> (ma si può fare meglio ;-)
Forse, ma non di molto visto che la cosa e' gia' ridotta al minimo.
Sono riuscito a trovare solo 2 variazioni sul tema:
raise("Language cannot be Ruby") ::when { language == "Scala" }
la differenza principale e' aver aggiunto la parola "when" e
l'operatore :: che di fatto permette di scrivere un if in ordine
inverso
azione ::when condizione
In questo modo si puo' utilizzare per qualunque azione, con l'unica
complicazione di passare dentro una funzione unapplied con zero
parametri che in natura e' difficile da ottenere, ma con un piccolo
aiuto si puo' scrivere
unApp(println("Print Ruby")) ::when { language == "Ruby" }
Altro vantaggio della parola "when" e' che se ne possono aggiungere
altre come ad esempio
raise("Language should be Scala") ::unless { language == "Scala" }
Nonostante questo, la soluzione e' un po' fragilina e puo' creare
diverse sorprese (il problema di fondo e' che l'"azione" viene
valutata cmq prima della condizione, per questo serve che sia
unapplied). In altre parole: don't try this at home!
L'altro esperimento e' stato riuscire ad utilizzare la operator
notation, quella senza punti e parentesi. Per "attivarla" bisogna,
purtroppo, indicare esplicitamente il ricevente, e quindi diventa
this raise "Language cannot be Ruby" when language == "Ruby"
e anche qui si possono aggiungere unless, whenNull, whenEmpy e cosi' via.
this raise "Choose something!" whenNull language
Unico difetto il this iniziale. Con un trucco indegno
def please = this
possiamo pero' scrivere
please raise "Choose something!" whenNull language
:)
Questo e il codice della seconda soluzione
def raise(s: String): DelayedException = {
new DelayedException(s);
}
class DelayedException(msg: String) {
def when(f: => Boolean) = {
if (f) throw new IllegalArgumentException(msg)
}
def whenNull(f: Any) = {
if (f == null) throw new IllegalArgumentException(msg)
}
}
Ciao
Lorenzo