Re: Petite erreur

Comparons avec Scala :

côté bibliothèque standard [...] au niveau de la VM (Open JDK) [...]

Scala a accès à la bibliothèque standard Java et utilise la JVM donc bonne nouvelle.

- Support des fermetures. Y'a eu tellement de discussions que j'ai meme pas cherché à suivre...

Scala les supporte. Exemple :
val maListe = List(1,8,34,74,785,16)
val uneValeur = 18
val maClosure = (a:Int) => a + uneValeur // <-- La closure est ici
val maListePlusUneValeur = maListe.map(maClosure)

On peut raccourcir :
val maListe = List(1,5,4,78,8)
val uneValeur = 17
val maListePlusUneValeur = maListe.map(_ + uneValeur)

- Nettoyage automatique des ressources à la sortie d'un bloc. On déclare en début de bloc les ressources que l'on utilise et quand on sort du bloc les méthodes de nettoyage sont automagiquement appelées. Le but est d'éviter le code relou de nettoyage dans les finally et d'éviter les leaks


La question a encore été posée aujourd'hui sur #scala :-) Ça s'implémente facilement sans modifier le langage.
http://stackoverflow.com/questions/2395984/scala-using-keywo(...)

- Extension des annotations pour pouvoir les placer un peu plus partout. Un des buts est de pouvoir placer des annotations pour aider les analyseurs statique (indiquer qu'un champ peut être nul ou pas par exemple)


En Scala il est préconisé de n'utiliser "null" que pour la compatibilité avec des classes écrites en Java. Sinon on utilise le type algébrique Option pour remplacer les types "nullables".

Pour les annotations, à priori ça doit être équivalent à celles de Java au moins.

- Inférence de type (ami du CAML pas la peine d'hurler :p ) plus besoin de doubler la déclaration des generics lors d'un new. Map<List, Integer> map = new Map<>(). Merci pour nos petits doigts !


Scala utilise massivement l'inférence de type (et surtout avec des types paramétrés qui peuvent être bien plus compliqués qu'en Java). Ton exemple donnerait :
val map = new Map[List, Integer]() (enfin il faudrait paramétrer List aussi, mais bon c'est un exemple)

- Possibilité de faire des switch/case sur des string


Scala supporte le pattern-matching. Par exemple avec le type Option cité plus haut :
val a:Option[Integer] = Some(5)
...
a match {
case Some(x) => //code qui peut utiliser "x" qui vaut 5 ici
case None => // cas où "a" serait "null" (enfin l'équivalent avec Option...)
}

Avec les strings ça fonctionne pareil :
str match {
case "brol" => ...
case "troll" => ...
}

Pour les exceptions, on utilise du pattern-matching aussi (comme en Java sauf qu'ils ne le disent pas explicitement). Du coup on peut faire du "multicatch" :
try {
...
} catch {
case e:SQLException => println("Database error") //Comme en Java
case e:MalformedURLException
| case e2:URLenBois => println("Bad URL") //multicatch
case e => { //catch par défaut
println("Some other exception type:")
e.printStackTrace()
}
}

Pour la surcharge des opérateurs, en fait le concept d'opérateur n'existe pas en Scala, ce sont des méthodes de classe :
5 + 7 est équivalent à 5.+(7)
Du coup on peut définir les opérateurs qu'on veut (à quelques limitations près). Exemple :
monActeur !! monMessage
(envoie un message à l'acteur avec une syntaxe qui reprend celle d'Erlang).

Ça permet de faire des choses concises comme :
(0 /: maListe)(_ + _)
qui est plus lisible (une fois habitué...) que : maListe.foldLeft(0)((a:Int,b:Int) => a +b)

Voir aussi les parsers du type :
val parser = "void" ~ ident ~ "(" ~ repSep(param, ",") ~ ")" ~ ";" ^^^ {
println("Déclaration de procédure parsée !!!")
}

Bref, Scala c'est bon, mangez en. Et c'est déjà dispo. En plus, la prochaine release (2.8) apportera les paramètres nommés, les valeurs par défaut, etc. Et la beta est assez stable :-) http://www.scala-lang.org/node/1564

http://www.codecommit.com/blog/scala/roundup-scala-for-java-(...)