URL: https://linuxfr.org/news/sortie-de-scala-2-10 Title: Sortie de Scala 2.10 Authors: Lucas Benoît Sibaud, baud123 et rootix Date: 2013年01月24日T11:56:34+01:00 License: CC By-SA Tags: scala Score: 31 Comme vous l'avez aperçu [sur ce même site](http://linuxfr.org/news/scala-2-10-rekonq-2-0-cassandra-1-2), la version 2.10 du langage de programmation [Scala](http://www.scala-lang.org) est sortie, il y a quelques semaines. Cette version apporte pas mal de nouveautés, de corrections et d'améliorations. Cette dépêche propose une petite revue rapide des différents apports de cette version. ---- [Site officiel](http://scala-lang.org/) [Annonce de la sortie](http://www.scala-lang.org/node/27499) ---- # Nouveautés # ## Documentons nous un peu ! ## Pas mal de nouveaux documents ont été ajoutés et sont disponibles [sur leur site dédié](http://docs.scala-lang.org/). Cette documentation permet d'avoir un aperçu des différentes fonctionnalités et APIs du langage. Vous pourrez retrouver la plupart des nouveautés documentées sur ce site notamment. La documentation de la bibliothèque standard a aussi été améliorée et enrichie, ce qui ne sera sûrement pas pour déplaire aux développeurs Scala. ## Les classes valeur et classes implicites ## L'écosystème Scala (à commencer par la bibliothèque standard) fait un usage intensif de bibliothèques Java, et les enrichit, souvent par le biais de wrappers. Certaines autres bibliothèques (parfois les mêmes) ajoutent aussi des opérateurs sur des types existants (notamment les types primitifs et chaînes de caractères). Tout ceci donne souvent naissance à pas mal de code pour construire des wrappers, de manières implicite ou non, et, à l'exécution, à la création d'une myriade d'objets. Deux nouveaux concepts permettent de réduire ces deux problèmes : Les _classes valeur_ permettent de créer des wrappers qui ne résultent pas en la création d'un objet à l'exécution. Ces classes ont plusieurs restrictions, notamment, elles ne peuvent pas avoir d'état interne. Un usage intéressant est d'assurer qu'on n'additionne pas les torchons et les serviettes ```scala class Torchon(val value: Double) extends AnyVal { def +(t: Torchon): Torchon = new Torchon(value + t.value) } class Serviette(val value: Double) extends AnyVal { def +(t: Serviette): Serviette = new Serviette(value + t.value) } ``` Il est ainsi impossible d'additionner torchons et serviettes, ce qui est assuré par le compilateur ```scala val t1 = new Torchon(2) val t2 = new Torchon(4) val s = new Serviette(4) t1 + t2 // ok t1 + s // erreur de compilation ``` Par contre à l'exécution, aucun objet `Torchon` ou `Serviette` n'est créé, et seuls des `Double` existent. Les classes implicites permettent de réduire le code pour créer des wrapper implicites. Plutôt que de définir la classe wrapper et une fonction implicite du type à enrichir vers le type wrapper, il suffit de déclarer la classe wrapper comme étant implicite. Un peu plus de détails [sur la page du document SIP](http://docs.scala-lang.org/sips/pending/implicit-classes.html). En combinant ces deux fonctionnalités, il devient possible d'implémenter les extensions de méthodes sans création d'objet à l'exécution, dont on peut [voir un exemple](http://docs.scala-lang.org/overviews/core/value-classes.html#extension_methods) sur le site de la documentation. ## L'interpolation des chaînes de caractères ## Voilà quelque chose qui manquait cruellement à Scala et est présent dans beaucoup de langages. Il est désormais possible de créer des chaînes de caractères à partir de données en éviter d'horribles concaténations de chaînes dans le source, et le tout de manière typée. ```scala val world = "Monde" println(s"Bonjour, $world!") ``` Plusieurs interpolateurs existent, que l'on peut retrouver [dans la documentation appropriée](http://docs.scala-lang.org/overviews/core/string-interpolation.html). ## Futures et Promises ## Les `Futures` et `Promises` sont des objets représentant une valeur (ou un calcul) qui sera disponible à un moment donné dans le futur. Ils permettent un style de programmation monadique assez élégant, et la manipulation de ces objets avant même que le résultat ne soit disponible. Un petit tour [sur la documentation](http://docs.scala-lang.org/overviews/core/futures.html) donnera une bonne idée de comment tout cela marche. Cette manière de programmer est particulièrement agréable lorsque l'on souhaite accéder à des ressources de manière asynchrone et exécuter une opération lorsque le résultat sera disponible. ## Modularisation des fonctionnalités ## Scala est complet, souvent perçu comme très (trop) complexe. Ce langage est multi-paradigme (langage principalement objet avec des possibilités fonctionnelles) et possède un certain nombre de concepts de haut niveau ([types d'ordre supérieur](http://en.wikipedia.org/wiki/Higher-kinded_type), conversions implicites, types existentiels, ...). Dans cette nouvelle version il est désormais possible de n'activer certains de ces concepts qu'à la demande, soit pour tout le programme, soit pour certains fichiers uniquement. Il devient ainsi possible de n'utiliser qu'un sous ensemble du langage et de s'assurer que c'est bien le cas en n'activant pas les fonctionnalités non souhaitées. Vous trouverez quelques détails [dans le document SIP](http://docs.scala-lang.org/sips/pending/modularizing-language-features.html) associé. ## Nouveaux acteurs ## Le type de programmation concurrente privilégié en Scala est la [programmation par acteurs](http://en.wikipedia.org/wiki/Actor_%28programming%29). Jusqu'ici la bibliothèque standard Scala incluait une API d'acteurs simple mais limitée. Depuis cette nouvelle version, la bibliothèque d'acteurs [Akka](http://akka.io/) devient la bibliothèque d'acteurs officielles du langage. # Améliorations # ## Un nouveau pattern matcher ## Une fonctionnalité intéressante de Scala et l'utilisation des `case classes` et du [pattern matching](http://fr.wikipedia.org/wiki/Filtrage_par_motif). La compilation de cette fonctionnalité souffrait de plusieurs bugs insolvables dans son ancienne implémentation, et ne permettait pas de faire toutes les vérifications nécessaires. La manière de compiler cette fonctionnalité a été changée en Scala 2.10, et crée maintenant des appels à des méthodes virtuelles, et génère du code plus robuste. Une autre idée est aussi que la sémantique du pattern matching peut ainsi être modifiée (notamment pour les besoins d'une DSL) en surchargeant les méthodes appelées. ## Un nouveau générateur de bytecode ## La bibliothèque de manipulation de bytecode Java [ASM](http://asm.ow2.org/) est désormais utilisée par un des générateurs de bytecode du compilateur Scala (l'ancien générateur était fait maison). Ce changement permet notamment de générer du bytecode pour des versions plus récentes de Java. De plus [Miguel Garcia](http://lampwww.epfl.ch/~magarcia/ScalaCompilerCornerReloaded/) en profite pour ajouter certaines optimisations sur le bytecode qui semblent très prometteuses. L'ancien générateur de bytecode est classé obsolète. ## Plein d'autres petites choses indispensables ## * Au chapitre des améliorations, les performances ont été améliorées tant sur le temps de compilation que sur le temps d'exécution du code compilé * Un beau nettoyage du code du compilateur a été fait * Les [collections parallèles](http://docs.scala-lang.org/overviews/parallel-collections/overview.html) sont plus configurables * Possibilité [d'application dynamique](http://docs.scala-lang.org/sips/pending/type-dynamic.html) de méthodes qui n'est pas vérifiée à la compilation * Types dépendants plus puissants * ... # Expérimentons # Une grosse nouveauté dans cette version de Scala et l'apparition d'une API de réflexion avancée et uniformisée, ainsi que l'apparition des macros. Ces deux API et fonctionnalité sont encore expérimentales mais permettent pas mal de nouvelles choses comme ajouter des vérifications à la compilation, changer la manière dont est compilé le code ponctuellement (attention, terrain glissant !) ou d'embarquer plus facilement des DSL. Un petit tour sur la documentation [de l'API de réflexion](http://docs.scala-lang.org/overviews/reflection/overview.html) et [des macros](http://docs.scala-lang.org/overviews/macros/overview.html) est très enrichissant. # En marge # ## Plugin Eclipse ## Un peu en marge du langage mais pourtant lié, le [plugin eclipse](http://scala-ide.org/) a aussi été amélioré et a suivi le rythme des évolutions du langage. ## En bonus ## Inspiré par [Hoogle](http://www.haskell.org/hoogle/), le service [Scalex](http://scalex.org/) permet de trouver des fonctions en connaissant leur signature.

AltStyle によって変換されたページ (->オリジナル) /