CLU (langage)

CLU
Date de première version	1974
Paradigmes	Objet, impératif
Auteur	Barbara Liskov et ses étudiants au MIT
Développeurs	Barbara Liskov et ses étudiants au MIT
Typage	Fort
Influencé par	Pascal
A influencé	Ruby, Ada
Implémentations	Portable CLU, Native CLU, clu2c
Site web	www.pmg.lcs.mit.edu/CLU.html

CLU est un langage de programmation créé au Massachusetts Institute of Technology (MIT) par Barbara Liskov et ses étudiants entre 1974 et 1975.

Clusters

La syntaxe de CLU était basée sur ALGOL, qui était alors le point de départ de la plupart des conceptions de nouveaux langages. L'ajout majeur est le concept de cluster, le système d'extension de type de CLU et la racine du nom du langage (CLUster). Les clusters correspondent généralement au concept de "classe" dans un langage orienté objet. Par exemple, voici la syntaxe CLU pour un cluster qui implémente les nombres complexes :

    complex_number = cluster is add, subtract, multiply, ...
        rep = record [ real_part: real, imag_part: real ]
        add = proc ... end add;
        subtract = proc ... end subtract;
        multiply = proc ... end multiply;
        ...
    end complex_number;

Un cluster est un module qui encapsule tous ses composants à l'exception de ceux explicitement nommés dans la clause "is". Ceux-ci correspondent aux composants publics d'une classe dans les langages orientés objet récents. Un cluster définit également un type qui peut être nommé en dehors du cluster (dans ce cas, complex_number), mais son type de représentation (rep) est caché aux clients externes.

Les noms des clusters sont globaux, et aucun mécanisme d'espace de noms n'a été fourni pour regrouper les clusters ou leur permettre d'être créés "localement" à l'intérieur d'autres clusters.

La CLU n'effectue pas de conversions de type implicites. Dans un cluster, les conversions de type explicites ascendante et descendante changent entre le type abstrait et la représentation. Il existe un type universel any, et une procédure force[] pour vérifier qu'un objet est d'un certain type. Les objets peuvent être mutables ou immuables, ces derniers étant des types de base tels que les entiers, les booléens, les caractères et les chaînes de caractères.

Autres fonctionnalités

Une autre caractéristique clé du système de types de CLU sont les itérateurs, qui renvoient les objets d'une collection en série, l'un après l'autre. Les itérateurs offrent une interface de programmation d'application (API) identique, quelles que soient les données avec lesquelles ils sont utilisés. Ainsi, l'itérateur d'une collection complex_number peut être utilisé de manière interchangeable avec celui d'une collection d'entiers. Une caractéristique distinctive des itérateurs CLU est qu'ils sont implémentés comme des coroutines, chaque valeur étant fournie à l'appelant via une instruction yield. Les itérateurs comme ceux de CLU sont maintenant une caractéristique commune de nombreux langages modernes, tels que C#, Ruby et Python, bien que récemment ils soient souvent appelés générateurs.

CLU inclut également la gestion des exceptions, basée sur diverses tentatives dans d'autres langages ; les exceptions sont levées à l'aide de signal et gérées avec except. Contrairement à la plupart des autres langages qui gèrent les exceptions, celles-ci ne sont pas implicitement remontés dans la chaîne d'appel. De même, contrairement à la plupart des autres langages qui gèrent les exceptions, les exceptions en CLU sont considérées comme faisant partie du flux d'exécution ordinaire et sont considérées comme un moyen "normal" et efficace de sortir des boucles ou de retourner des valeurs des fonctions ; cela permet l'attribution directe de valeurs de retour sauf si d'autres conditions s'appliquent. Les exceptions qui ne sont ni capturées ni résignées explicitement sont immédiatement converties en une exception d'échec spéciale qui met généralement fin au programme.

CLU est souvent crédité comme étant le premier langage avec des types sommes, appelés oneofs, avant que le langage ML ne les ait.

Une dernière caractéristique distinctive de CLU est l'affectation parallèle (affectation multiple), où plus d'une variable peut apparaître sur le côté gauche d'un opérateur d'affectation. Par exemple, en écrivant x,y := y,x, on échange les valeurs de x et de y. De la même manière, les fonctions peuvent retourner plusieurs valeurs, comme x,y,z := f(t). L'affectation parallèle (mais pas les valeurs de retour multiples) est antérieure au CLU, apparaissant dans CPL (1963), sous le nom d'affectation simultanée, mais le CLU l'a popularisé et est souvent crédité comme l'influence directe menant à l'affectation parallèle dans les langages ultérieurs.

Tous les objets d'un programme CLU sont alloués dans le tas, et la gestion de la mémoire est automatique.

CLU supporte la généricité. Il a été le premier langage à offrir des types paramétrés délimités sûrs, en utilisant des clauses de structure où pour exprimer des contraintes sur les arguments de type réels.

Influences

CLU et Ada ont été des inspirations majeures pour les templates C++.

Les mécanismes de gestion des exceptions de CLU ont influencé des langages ultérieurs tels que C++ et Java.

Sather, Python et C# incluent des itérateurs, qui sont apparus pour la première fois dans CLU.

Perl et Lua ont emprunté à CLU les assignations multiples et les retours multiples des appels de fonction.

Python et Ruby ont emprunté l'appel par partage, l'instruction yield, et l'affectation multiple.

Notes et références

• (en) Cet article est partiellement ou en totalité issu de l’article de Wikipédia en anglais intitulé « CLU (programming language) » (voir la liste des auteurs).

Liens externes

• Site officiel