Sortie de Scala 2.10

Posté par . Édité par Benoît Sibaud, baud123 et Christophe Guilloux. Modéré par Xavier Claude. Licence CC by-sa
Tags :
31
24
jan.
2013
Java

Comme vous l'avez aperçu sur ce même site, la version 2.10 du langage de programmation Scala 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.

Sommaire

Nouveautés

Documentons nous un peu !

Pas mal de nouveaux documents ont été ajoutés et sont disponibles sur leur site dédié. 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

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

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.

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 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.

val world = "Monde"
println(s"Bonjour, $world!")

Plusieurs interpolateurs existent, que l'on peut retrouver dans la documentation appropriée.

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 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, 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 associé.

Nouveaux acteurs

Le type de programmation concurrente privilégié en Scala est la programmation par acteurs. 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 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. 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 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 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 sont plus configurables
  • Possibilité d'application dynamique 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 et des macros est très enrichissant.

En marge

Plugin Eclipse

Un peu en marge du langage mais pourtant lié, le plugin eclipse a aussi été amélioré et a suivi le rythme des évolutions du langage.

En bonus

Inspiré par Hoogle, le service Scalex permet de trouver des fonctions en connaissant leur signature.

  • # Euh ...

    Posté par . Évalué à  4 .

    […] le langage de programmation Scala est sorti il y a quelques semaines.

    Il ne manquerait pas "la version 2.10 de" avant ce bout de phrase? Mis à part ca, très belle dépêche.

    • [^] # Re: Euh ...

      Posté par (page perso) . Évalué à  2 .

      Corrigé, merci.

    • [^] # Re: Euh ...

      Posté par . Évalué à  0 .

      Difficile de faire un sans faute pour sa première dépêche :D

      • [^] # Re: Euh ...

        Posté par . Évalué à  4 .

        Il est ainsi possible d'additionner torchons et serviettes

        Ce ne serait pas plutôt impossible ?

        • [^] # Re: Euh ...

          Posté par . Évalué à  1 .

          La honte me submerge, en effet oui… Si je m'étais pas planté et étais passé par l'espace de rédaction collaboratif, ça serait pas passé je pense :)

        • [^] # Re: Euh ...

          Posté par (page perso) . Évalué à  2 .

          Corrigé, merci.

  • # Coquille ?

    Posté par . Évalué à  1 . Dernière modification : le 25/01/13 à 07:30

    Je lis:

    Un usage intéressant est d'assurer qu'on additionne pas les torchons et les serviettes

    Deux ligne plus bas, et dans le code:

    Il est ainsi possible d'additionner torchons et serviettes, ce qui est assuré par le compilateur

    t1 + s // erreur de compilation

    La deuxième phrase, ce ne serait pas plutôt "il est ainsi impossible…" ?

Suivre le flux des commentaires

Note : les commentaires appartiennent à ceux qui les ont postés. Nous n'en sommes pas responsables.