La version 3 de Scala, un langage orienté objet et fonctionnel, est disponible
La version 3 de Scala, un langage orienté objet et fonctionnel, est disponible,
elle apporte une nouvelle conception des abstractions contextuelles et améliore le système de types
Anatolii Kmetiuk, programmeur Scala, a annoncé le 14 mai Scala 3, un langage de programmation polyvalent à typage statique qui prend en charge la programmation orientée objet et la programmation fonctionnelle. Cette version intègre les dernières recherches en théorie des types ainsi que l'expérience industrielle de Scala 2. « Après 8 ans de travail, 28 000 commits, 4 100 problèmes résolus, Scala 3 est enfin disponible », a déclaré Anatolii Kmetiuk. « Nous avons vu ce qui a bien (ou moins bien) fonctionné pour la communauté dans Scala 2. Sur la base de cette expérience, nous avons créé la troisième itération de Scala, facile à utiliser, à apprendre et à adapter », a-t-il ajouté.
Rappelons que Scala est un langage de programmation polyvalent à typage statique qui prend en charge la programmation orientée objet et la programmation fonctionnelle. Conçu pour être concis, Scala avec ses nombreuses décisions de conception vise à répondre aux critiques de Java. La version 3 du langage est une refonte complète du langage Scala. À la base, de nombreux aspects du système de types ont été modifiés pour être davantage fondés sur des principes. Une chose qui a complètement changé dans Scala 3 par rapport à Scala 2 : ce sont les macros. Le langage comporte également un grand nombre de nouvelles fonctionnalités. Voici, ci-dessous, quelques-unes de ces nouvelles fonctionnalités.
Abstractions contextuelles
L'un des concepts fondamentaux sous-jacents de Scala était (et est toujours dans une certaine mesure) de fournir aux utilisateurs un petit ensemble de fonctionnalités qui peuvent être combinées à une grande expressivité (et parfois même imprévue). Par exemple, la fonctionnalité des implicites a été utilisée pour modéliser l'abstraction contextuelle, pour exprimer le calcul au niveau du type, pour modéliser les classes de type, pour effectuer des coercitions implicites, pour encoder des méthodes d'extension, et bien plus encore. Tirant les leçons de ces cas d'utilisation, Scala 3 adopte une approche légèrement différente et se concentre sur l'intention plutôt que sur le mécanisme. Au lieu d'offrir une seule fonctionnalité très puissante, Scala 3 propose plusieurs fonctionnalités de langage sur mesure, permettant aux programmeurs d'exprimer directement leur intention :
- abstraction des informations contextuelles : les clauses d'utilisation permettent aux programmeurs de s'abstraire des informations qui sont disponibles dans le contexte d'appel et qui devraient être transmises implicitement. En tant qu'amélioration par rapport aux implicites de Scala 2, les clauses d'utilisation peuvent être spécifiées par type, ce qui libère les signatures de fonctions des noms de variables qui ne sont jamais explicitement référencés ;
- fournir des instances de classe de type : les instances données permettent aux programmeurs de définir la valeur canonique d'un certain type. Cela rend la programmation avec les classes de type plus simple sans divulguer les détails d'implémentation ;
- extension rétroactive des classes : dans Scala 2, les méthodes d'extension devaient être codées à l'aide de conversions implicites ou de classes implicites. En revanche, dans Scala 3, les méthodes d'extension sont désormais directement intégrées au langage, ce qui permet d'améliorer les messages d'erreur et l'inférence de type ;
- considérer un type comme un autre : les conversions implicites ont été repensées dès le départ comme des instances d'une classe de type Conversion ;
- abstractions contextuelles d'ordre supérieur : la toute nouvelle fonctionnalité des fonctions contextuelles fait des abstractions contextuelles un citoyen de première classe. Elles constituent un outil important pour les auteurs de bibliothèques et permettent d'exprimer des langages concis spécifiques à un domaine ;
- retour d'information du compilateur : dans le cas où un paramètre implicite ne peut pas être résolu par le compilateur, il fournit maintenant des suggestions d'importation qui peuvent résoudre le problème.
Améliorations du système de types
Outre l'amélioration considérable de l'inférence de type, le système de types de Scala 3 offre également de nombreuses nouvelles fonctionnalités, elle apporte des outils pour exprimer de manière statique des invariants dans les types :
- énumérations : les énumérations ont été redessinées pour se fondre dans les classes de cas et former le nouveau standard pour exprimer les types de données algébriques ;
- types opaques : cachez les détails de mise en œuvre derrière des alias de types sans en payer le prix en termes de performances. C'est tout l’intérêt des types opaques qui remplacent les classes de valeurs et permettent de mettre en place une barrière d'abstraction sans causer de surcharge supplémentaire ;
- types d'intersection et d'union : le fait de baser le système de types sur de nouvelles bases a conduit à l'introduction de nouvelles caractéristiques du système de types : les instances des types d'intersection, comme A & B, sont des instances de A et de B. Les instances des types d'union, comme A | B, sont des instances de A ou de B. Ces deux constructions permettent aux programmeurs d'exprimer de manière flexible les contraintes de type en dehors de la hiérarchie d'héritage ;
- types de fonctions dépendantes : Scala 2 permettait déjà aux types de retour de dépendre des arguments (valeurs). Dans Scala 3, il est maintenant possible de faire abstraction de ce modèle et d'exprimer des types de fonctions dépendantes. Dans le type F = (e : Entry) => e.Key le type de résultat dépend de l'argument ;
- types de fonctions polymorphes : comme pour les types de fonctions dépendantes, Scala 2 supportait les méthodes qui autorisent les paramètres de type, mais ne permettait pas aux programmeurs de s'abstraire de ces méthodes. Avec Scala 3, les types de fonctions polymorphes comme [A] => Liste[A] => Liste[A] peuvent s'abstraire des fonctions qui prennent des arguments de type en plus de leurs arguments de valeur ;
- les lambdas de type : ce qui devait être exprimé à l'aide d'un plugin de compilation dans Scala 2 est maintenant une fonctionnalité de première classe dans Scala 3 : les lambdas de type sont des fonctions de niveau de type qui peuvent être passées comme arguments de type sans nécessiter une définition de type auxiliaire ;
- correspondance des types : au lieu d’implémenter le calcul au niveau du type en utilisant la résolution implicite, Scala 3 offre un support direct pour la mise en correspondance des types. L'intégration du calcul au niveau du type dans le vérificateur de type permet d'améliorer les messages d'erreur et de supprimer le besoin d'encodages complexe.
Programmation orientée objet
Scala a toujours été la frontière entre la programmation fonctionnelle et la programmation orientée objet. Les modifications du système de types mentionnées ci-dessus et la nouvelle conception des abstractions contextuelles rendent la programmation fonctionnelle plus facile qu'auparavant. En même temps, les nouvelles fonctionnalités suivantes permettent des conceptions orientées objet bien structurées et soutiennent les meilleures pratiques.[B]
- prévoir l'extension : l'extension des classes qui ne sont pas prévues pour l'extension est un problème de longue date dans la conception orientée objet. Pour résoudre ce problème, les classes ouvertes exigent que les concepteurs de bibliothèques marquent explicitement les classes comme étant ouvertes ;
- cacher les détails d'implémentation : les traits utilitaires qui implémentent un comportement ne devraient parfois pas faire partie des types inférés. Dans Scala 3, ces traits peuvent être marqués comme transparents, cachant l'héritage à l'utilisateur (dans les types inférés) ;
- la composition au lieu de l'héritage : cette phrase est souvent citée, mais fastidieuse à mettre en œuvre. Avec Scala 3, symétriquement aux importations, les clauses d'exportation permettent à l'utilisateur de définir des alias pour des membres d'un objet sélectionnés.
Et vous ?
Avez-vous une expérience avec Scala ?
Voir aussi :
Répondre avec citation
Envoyé par Bruno
Partager