Common Lisp

ÔĽŅ
Common Lisp

Common Lisp est un langage fonctionnel impur de la famille Lisp.

Sommaire

Introduction

Common Lisp est un dialecte de Lisp standardisé par l'ANSI X3.226-1994. Développé pour standardiser les variantes divergentes de Lisp qui l'ont précédé, ce n'est pas une implémentation mais une spécification à laquelle les implémentations Lisp essayent de se conformer. Il est fréquemment abrégé en CL.

Common Lisp est un langage de programmation à usage général, a contrario de dialectes de Lisp comme Emacs Lisp et AutoLisp, qui sont des langages d'extension embarqués dans des produits particuliers. Contrairement à de nombreux Lisp plus anciens, mais comme Scheme, Common Lisp utilise la portée lexicale par défaut pour les variables.

Common Lisp est un langage de programmation multi-paradigmes qui :

Syntaxe

Comme tout langage de la famille Lisp, Common Lisp utilise des s-expressions pour d√©noter √† la fois le code et certaines structures de donn√©es. Les invocations de fonctions, de formes sp√©ciales et de macros sont √©crites dans la syntaxe litt√©rale des listes, avec le nom de la fonction (resp. forme sp√©ciale, et macro) en premi√®re place, comme dans ces exemples :

 (+ 2 2)             ; ajoute 2 et 2, renvoie 4
 (setf e 2.7182817)  ; assigne 2.7182817 à la variable e
 (setq e 2.7182817)  ; assigne 2.7182817 à la variable e
 (setq e 'rouge)  ; assigne le mot rouge à la variable e
 
 NIL ; correspond a la valeur nulle 
 T ; correspond à la valeur booléenne true
 
 (if (< x y)
        y ; résultat si condition true
        x) ; résultat par défault
 
 (defun carre (x) (* x x)) ; définit une fonction qui met un nombre au carré
 (carre 3)                 ; exécution de la fonction : retourne 9

Types de données

Common Lisp a une pléthore de types de données, plus qu'aucun autre langage.

Types scalaires

Nombres

Les types num√©riques incluent les entiers, les rationnels, les nombres √† virgule flottante et les nombres complexes. Common Lisp utilise des grands nombres pour repr√©senter des valeurs num√©riques de taille et de pr√©cision arbitraires. Le type rationnel repr√©sente les fractions de fa√ßon exacte. Common Lisp convertit automatiquement les valeurs num√©riques entre ces types de fa√ßon appropri√©e. Voici la tour num√©rique, c‚Äôest-√†-dire la hi√©rarchie des types num√©riques de Common Lisp :

            complex             ratio      fixnum
           /                   /          /
number <--+-real--+-rational--+-integer--+-bignum
                   \           \
                    \           (1) signed-byte--unsigned-byte--bit
                     \
                      float--+-short-float
                              \-single-float
                               \-double-float
                                \-long-float

(1) integer et signed-byte sont des sp√©cifications de types disjointes ; toutefois, les domaines sont identiques.

A titre d'exemple, l'expression

 (+ (sqrt -2) (/ 6 4))

retourne

#C(3/2 1.4142135)

c’est-à-dire un nombre complexe dont la partie imaginaire est le flottant 1.4142135 et la partie réelle est le rationnel 3/2.

Caractères

Le type Common Lisp caract√®re n'est pas limit√© aux caract√®res ASCII ; cela n'est pas surprenant car Lisp est plus ancien que l'ASCII. Certaines impl√©mentations modernes supportent les caract√®res Unicode[1].

Symboles

Le type symbole est commun aux langages Lisp, mais largement inconnu en dehors. Un symbole est un objet nomm√©, unique, relatif √† un espace de noms. Les symboles litt√©raux en Lisp sont utilis√©s comme identificateurs de variables ; toutefois, ils sont plus g√©n√©raux et peuvent √™tre utilis√©s pour eux-m√™mes √©galement, comme des objets. Lorsqu'un symbole est √©valu√©, sa valeur en tant que variable est retourn√©e.

L'existence des symboles en tant que type de données facilite l'écriture des macros (qui effectuent des transformations de code au moment de la compilation) et l'implémentation de systèmes de calcul symbolique. De fait, Lisp a été le premier langage d'implémentation de systèmes de calcul formel. Des systèmes de calcul formel très complets ont été écrits en Lisp (Maxima et Axiom, et pour les transformations symboliques, ils soutiennent généralement la comparaison avec les populaires Mathematica et Maple).

Il existe des cas particuliers :

  • les valeurs bool√©ennes sont repr√©sent√©es par les symboles r√©serv√©s T et NIL.
  • les mots-clefs (de la forme :foo ou :bar) sont des symboles d√©finis dans l'espace de nom KEYWORD. L'√©valutation d'un tel symbole retourne le symbole lui-m√™me.

Exemples :

 foo                    ;; -> La variable FOO n'a pas de valeur.
 (function foo)         ;; -> La fonction FOO n'est pas définie.

L'op√©rateur QUOTE prot√®ge les symboles de l'√©valuation (lorsqu'on veut utiliser un symbole pour lui-m√™me) :

 (quote foo)            ;; -> FOO
 'foo                   ;; -> FOO

On peut demander si un symbole est li√© √† une valeur ou une fonction :

 (boundp 'foo)          ;; -> NIL (pas de valeur liée)
 (fboundp 'foo)         ;; -> NIL (aucune fonction nommée FOO n'existe)

Association symbole-valeur :

 (defparameter foo 77)  ;; -> FOO
 foo                    ;; -> 77

Association symbole-fonction :

 (defun foo (bar)
    (1+ bar))           ;; -> FOO

Appel de la fonction FOO avec la valeur FOO (illustre le fait qu'un symbole dispose de slots s√©par√©s pour les valeurs et les fonctions) :

 (foo foo)              ;; -> 78
 
 (boundp 'foo)          ;; -> T
 (fboundp 'foo)         ;; -> T
 (function foo)         ;; -> #<CLOSURE FOO (BAR) (DECLARE (SYSTEM::IN-DEFUN FOO)) (BLOCK FOO (1+ BAR))>

Recursivit√© :

(defun factoriel (n)
        (if (= n 0)
                1
                (* n (factoriel(- n 1)))))

Autre :

(first '(7 3 10)) ;;-> 7
(rest '(20 2 45)) ;;-> (2 45)
(endp '()) ;;-> T
(endp '(5)) ;;-> NIL liste non vide

Structures de données

Séquences

Les s√©quences sont un type abstrait repr√©sentant une collection ordonn√©e d'√©l√©ments. Les types concrets d√©riv√©s de s√©quence sont les listes et les vecteurs (y compris les vecteurs de bits et cha√ģnes de caract√®res). De nombreuses fonctions sont disponibles pour les s√©quences. Il n'est toutefois pas possible au programmeur de d√©finir ses propres sous-types de s√©quences. Une extension du standard permettant la d√©finition de nouvelles s√©quences est en cours de proposition (circa 2007).

Paires, Listes

Les listes de Common Lisp ne sont pas un type de donn√©e mais sont compos√©es √† partir de conses (pluriel), parfois appel√©s cellules cons ou paires. Un cons est une structure √† deux √©l√©ments de type T, accessibles par les fonctions car et cdr (ou encore first et rest). Une liste est donc une cha√ģne de conses li√©s, o√Ļ le cdr de chaque cons pointe sur l'√©l√©ment suivant, et le dernier cdr pointe sur la valeur NIL. Les conses peuvent √™tre facilement utilis√©s pour impl√©menter des arbres ou toute structures de donn√©es complexe ; bien que dans ce dernier cas il soit recommand√© d'utiliser des structures ou des classes.

L'arbre (1 (2/7 3.14) A "foo") est repr√©sent√© par la cha√ģne de CONS suivante : Lisp-liste.png

Il peut √™tre construit de diff√©rentes fa√ßons, nous en citons deux :

 (list 1 (list 2/7 3.14) 'a "foo")
 (cons 1 (cons (cons 2/7 (cons 3.14 NIL)) (cons 'a (cons "foo" NIL))))

Les listes ou structures cycliques faites √† partir de paires n'ont pas de repr√©sentation litt√©rale, mais elles peuvent √™tre imprim√©es :

 (setf *print-circle* t)             ; active l'affichage des structures circulaires (évite le bouclage infini)
 (let ((list (copy-list '(a b c)))) 
    (setf (cdr (last list)) list))   ; =>   #1=(A B C . #1#)

Tableaux

Common Lisp supporte les tableaux de dimensions arbitraires, et peut aussi redimensionner dynamiquement les tableaux. Des tableaux multidimensionnels peuvent être utilisés pour les mathématiques des matrices. Seuls les tableaux à une dimension (nommés vecteurs) sont un sous-type de séquence.

Les tableaux peuvent √™tre sp√©cialis√©s par le type des √©l√©ments qu'ils contiennent. En particulier, les vecteurs de bits et les vecteurs de caract√®res (cha√ģnes) sont fournis en standard par le langage.

Exemple de creation de vecteur :

(setq v (make-array 3)) ; creation du vecteur
(setf (aref v 0) 1) ; v[0]:= 1
(aref v 0) ; -> 1

Exemple de cr√©ation d'un tableau √† trois dimensions (4 x 2 x 3) et initialis√© :

 (make-array '(4 2 3) :initial-contents
             '(((a b c) (1 2 3))
              ((d e f) (3 1 2))
              ((g h i) (2 3 1))
              ((j k l) (0 0 0))))

... cela retourne :

#3A(((A B C) (1 2 3)) ((D E F) (3 1 2)) ((G H I) (2 3 1)) ((J K L) (0 0 0)))

Registres

Exemples :

(defstruct livre auteur titre) ; construit une structure "livre" contenant trois champs
(make livre) ; construit la structure en mémoire
(setq l (make-livre :auteur 'Hugo)) ; crée un livre dont l'auteur est Hugo et l'associe à la variable l
 
(setf (livre-titre l) 'Miserables) ; associe un titre au livre de Hugo
(livre-titre l) ;;-> Miserables

Tables de hachage

Les tables de hachage stockent des associations entre objets. N'importe quel type d'objet peut être utilisé comme clef ou valeur. Les tables de hachage, comme les tableaux, sont automatiquement redimensionnées si nécessaire.

Paquetages

Les paquetages (packages) sont des collections de symboles, utilisés principalement pour partitionner un programme en espaces de noms. Un paquetage peut exporter certains symboles, les marquant comme une partie d'une interface publique. Les variables et méthodes dites privées des langages à objets classiques (principe de l'encapsulation) sont obtenues en Lisp en les déclarant dans un espace de nom, sans les exporter.

Structures

Les Structures, similaires au structs du C et aux records (enregistrements) du Pascal, représentent des structures de données de complexité arbitraire, avec un nombre quelconque et tout type de champs (appelés slots). Les structures supportent une forme limitée d'héritage. Pour les besoins de la programmation orientée objet, on se reportera à CLOS.

Classes et Objets

Common Lisp a √©t√© le premier langage √† objets standardis√© (en 1995, par l'ANSI). La partie du langage traitant des objets se nomme CLOS pour Common Lisp Object System. Les caract√©ristiques saillantes de CLOS sont les suivantes :

  • c'est un syst√®me √† classes (il existe en effet des syst√®mes √† prototypes),
  • il permet l'h√©ritage multiple entre classes,
  • les classes elles-m√™mes sont des objets, ou instances de m√©ta-classes (des classes de classes),
  • il dispose d'un protocole √† m√©ta-objets (Meta Object Protocol ou MOP), li√© √† l'existence des m√©ta-classes, et permettant de modifier la s√©mantique et le comportement du syst√®me,
  • il offre la s√©lection multiple des m√©thodes, c‚Äôest-√†-dire la s√©lection √† l'ex√©cution d'une m√©thode en fonction du type du tuple de ses param√®tres obligatoires (et non pas d'un receveur privil√©gi√© comme dans les langages √† s√©lection simple, qui sont la tr√®s grande majorit√©) ; les m√©thodes de CLOS sont regroup√©es dans des fonctions g√©n√©riques au lieu d'appartenir √† des classes,
  • il permet la combinaison de m√©thodes, c‚Äôest-√†-dire la d√©finition de m√©thodes auxiliaires s'ex√©cutant avant et/ou apr√®s une m√©thode particuli√®re.

CLOS permet également de définir des méta-classes et des classes, de changer la classe d'un objet, à l'exécution.

Le système de conditions de Common Lisp utilise CLOS pour définir les types des conditions pouvant survenir à l'exécution.

Certaines implémentations proposent en extension de CLOS un protocole à méta-objets décrit par le livre The Art of the Metaobject Protocol.

Fonctions et fermetures lexicales

Fonctions

En Common Lisp, les fonctions sont un type de donnée. Par exemple, il est possible d'écrire des fonctions qui prennent d'autres fonctions en paramètre, et retournent des fonctions (on les nomme fonctions d'ordre supérieur, ou de première classe). Cela rend possible d'écrire des opérateurs très généraux.

Exemple

Par exemple, la fonction sort (tri) prend une séquence et un opérateur de comparaison en paramètre. Elle peut être utilisée non seulement pour trier n'importe quel type de données, mais également pour trier des structures de données selon une clef.

(sort (list 5 2 6 3 1 4) #'>) ;; -> (6 5 4 3 2 1), en utilisant la fonction > comme opérateur de comparaison
 
(sort `((9 a) (3 b) (4 c))
      (lambda (x y) (< (first x) (first y))))  ;; -> ((3 b) (4 c) (9 a)), i.e. la liste triée sur le premier élément

On peut appliquer la fonction FOO d√©finie plus haut √† une s√©quence :

(mapcar #'foo (list 1 2 3 4 5)) ;; -> (2 3 4 5 6)
Espaces de noms

Common Lisp a un espace de nom respectivement pour les fonctions et pour les variables (√† la diff√©rence de, par exemple, Scheme, qui est dit "Lisp-1"). Lisp-2 (ou plus) pr√©sente l'avantage qu'aucun nom de variable ne peut masquer un nom de fonction : on peut nommer une variable cons ou m√™me if sans probl√®me. Toutefois, pour faire r√©f√©rence √† une fonction en tant que variable, on doit utiliser la fonction (function ...) ou la notation √©quivalente #' comme dans les exemples ci-dessus.

Outre les fonctions et les variables, il y a un espace de noms distinct pour les couples d'opérateurs block/return-from et tagbody/go.

Ajoutons pour finir que l'espace de nom des fonctions est en réalité partagé entre les fonctions proprement dites et les différentes sortes de macro.

Evaluation

Le mod√®le d'√©valuation est simple : lorsque l'√©valuateur rencontre une expression (F A1 A2 ... An), le symbole F peut repr√©senter l'un de ces items :

  1. Un opérateur spécial (comme if),
  2. Une macro,
  3. Une fonction, c’est-à-dire le nom d'une fonction définie par (defun ...) ou une fonction anonyme, toujours dénotée par (lambda ...)

Si F est une fonction, les param√®tres sont √©valu√©s successivement de gauche √† droite et la fonction est invoqu√©e avec les valeurs calcul√©es des param√®tres. Pour les op√©rateurs sp√©ciaux ou les macros, cela d√©pend. Ces op√©rateurs tendent en effet √† contr√īler l'√©valuation de leurs param√®tres. Par exemple, l'op√©rateur if n'√©value pas tous ses param√®tres, il doit √©valuer sa condition et puis en fonction du r√©sultat, une branche de l'alternative.

Capture lexicale

Une fermeture lexicale est une fonction dont les variables libres capturent les liaisons de l'environnement lexical dans lequel elles sont d√©finies. Cela permet de construire des fonctions ayant un √©tat interne (en C on utiliserait le mot-clef static pour obtenir l'√©tat interne, mais la capture lexicale n'est pas possible). On peut construire des objets simples √† partir de fermetures, par exemple une fabrique de compteurs :

 (defun fabriquer-compteur ()   ; fabriquer-compteur renvoie une fonction qui incrémente et affiche sa valeur interne
     (let ((valeur 0))          ; dans l'environnement de la fabrique, on crée la valeur du compteur
         (lambda ()             ; le nouveau compteur lui-même
             (incf valeur))))   ; ici, la référence à "valeur" capture sa définition dans la fabrique

Autres types

Les autres types de donn√©es de Common Lisp comprennent :

  • les Pathnames (noms repr√©sentant des chemins) qui repr√©sentent fichiers et r√©pertoires dans le syst√®me de fichier. L'outil de nommage de chemins en Common Lisp est plus g√©n√©ral que la plupart des conventions de nommage des syst√®mes d'exploitation, ce qui rend l'acc√®s des programmes Lisp aux fichiers largement portable √† travers diff√©rents syst√®mes.
  • Les streams (flots) d'entr√©e et de sortie repr√©sentent des sources et des puits de donn√©es binaires et textuelles, comme le terminal ou des fichiers ouverts.
  • Common Lisp poss√®de son propre g√©n√©rateur de nombres pseudo-al√©atoires. Les objets √Čtat al√©atoire repr√©sentent des sources r√©utilisables de nombres pseudo-al√©atoires, permettant √† l'utilisateur d'initialiser le g√©n√©rateur ou de le forcer √† rejouer une s√©quence.
  • Les Conditions sont un type sp√©cial utilis√© pour repr√©senter des erreurs, exceptions et autres √©v√®nements ¬ę int√©ressants ¬Ľ auxquels un programme doit pouvoir r√©pondre. Common Lisp a l'un des syst√®mes de gestion d'exceptions les plus complets ; il permet la reprise apr√®s erreur.

Common Lisp incorpore √©galement une bo√ģte √† outils pour la programmation orient√©e objet, le Common Lisp Object System, ou CLOS. Il est donc possible d'ajouter une infinit√© de types.

Macros

Une macro en Lisp ressemble superficiellement à une fonction. Les macros permettent au programmeur Lisp de créer de nouvelles formes syntaxiques dans le langage, par transformation de leurs paramètres représentant du code source. Par exemple, la macro suivante fournit la forme de boucle until (boucler... jusqu'à), qui est familière dans un langage comme Perl.

  • d√©finition de la macro :
 (defmacro until (test &body body)
   `(do ()
        (, test)
     ,@body))
  • appel de la macro (utilisation dans un programme) :
 (until (= (random 10) 0) 
   (write-line "Hello"))
  • premi√®re √©tape de macro-expansion (permet de retrouver le texte de la d√©finition interpol√© avec les param√®tres de l'appel) :
 (DO NIL ((= (RANDOM 10) 0)) (WRITE-LINE "Hello"))
  • macro-expansion compl√®te (ce qui est ex√©cut√© pour un appel) :
 (BLOCK NIL
   (LET NIL
     (TAGBODY #:G7594 (IF (= (RANDOM 10) 0) (GO #:G7595)) (WRITE-LINE "hello")
     (PSETQ) (GO #:G7594) #:G7595 (RETURN-FROM NIL (PROGN)))))

Les macros ne sont donc pas √©valu√©es √† l'ex√©cution comme les fonctions, mais au moment de la compilation. La valeur de retour d'une macro est sa macro-expansion, c‚Äôest-√†-dire la transformation de code qu'elle a effectu√© ; c'est cela qui est √©valu√© lors de l'ex√©cution du programme pour chaque appel √† la macro.

On peut consid√©rer les macros comme des fonctions qui acceptent et retournent des arbres de syntaxe abstraits (les s-expressions), mais contr√īlent l'√©valuation de leurs param√®tres. En effet dans un appel √† une macro (ma-macro (+ 1 2)), l'expression (+ 1 2) n'est pas d'abord √©valu√©e et son r√©sultat pass√© en argument, elle est pass√©e telle quelle √† la macro, qui peut la r√©utiliser intacte, l'interpoler avec d'autres fragments de code ou la transformer plus ou moins compl√®tement.

Comme les fonctions, les macros peuvent utiliser l'ensemble du langage Common Lisp (et biblioth√®ques tierces) pour effectuer leur travail de transformation (on les appelle pour cela des macros proc√©durales), contrairement aux macros du langage C qui ne permettent que des substitutions de cha√ģnes de caract√®res au niveau du source, sans acc√®s √† l'ensemble du langage C lui-m√™me.

Langages embarqués

L'intérêt principal des macros ne réside pas dans les petits utilitaires comme l'exemple ci-dessus, dont la prolifération dans les programmes Lisp peut conduire à un effet d'obfuscation, mais dans la possibilité de définir des langages embarqués dans Lisp, qui ciblent un domaine applicatif particulier. Un exemple classique est l'inclusion dans le langage d'une extension permettant de faire de la programmation logique à la manière de Prolog ou encore de la programmation par contrainte (ajout d'un nouveau paradigme de programmation). Il est possible en effet de construire, en utilisant des macros et des fonctions Lisp, un compilateur pour un langage de plus haut niveau que le langage de base mais qui reste intégré dans ce dernier.

Tous les domaines applicatifs peuvent b√©n√©ficier de la technique consistant √† √©crire un programme en ayant une approche descendante (top-down), dans laquelle le probl√®me √† r√©soudre est d√©compos√© jusqu'√† pouvoir √™tre exprim√© dans les termes du langage de base, et une approche montante (bottom-up), o√Ļ l'on √©tend le langage de base avec des concepts facilitant l'expression du probl√®me. Aucun langage de programmation √† usage g√©n√©ral ne pouvant √™tre fourni avec les op√©rateurs sp√©cifiques √† une infinit√© de domaines d'applications sp√©cifiques, la facult√© de pouvoir construire un langage adapt√© (l'approche bottom-up), par extension et r√©utilisation de la base, est un avantage majeur de Lisp sur les autres langages universels. Les macros sont de ce point de vue un avantage unique des langages de la famille Lisp. La facilit√© d'√©criture des macros tient √† l'utilisation des s-expressions pour la syntaxe de Lisp.

Templates pour le code

Le m√©canisme des macros ne serait pas assez commode √† l'usage sans un m√©canisme permettant de repr√©senter du code Lisp sous forme de patron (mod√®le, ou encore template) dans lequel des √©l√©ments calcul√©s ou donn√©s en param√®tre peuvent √™tre inject√©s. Common Lisp offre la quasiquotation, repr√©sent√©e par le caract√®re ` (dit backquote). Bien que l'op√©rateur backquote puisse √™tre utilis√© dans des fonctions, c'est dans les macros que son usage s'av√®re primordial : il permet d'am√©liorer la lisibilit√© du code produit par une macro dans des proportions consid√©rables.

Dans l'exemple ci-dessus, les backquotes ont √©t√© utilis√©es pour calculer le r√©sultat. Le corps de la macro until est enti√®rement repr√©sent√© par un template de code, utilisant l'op√©rateur d'it√©rations do. Rappelons que DO accepte trois arguments : un ensemble de variables d'it√©rations d√©finies localement et it√©r√©es en parall√®le, un ensemble de clauses permettant de d√©finir les conditions d'it√©ration des variables et d'arr√™t de la boucle, et un groupe - de taille quelconque - d'op√©rations ou d'actions arbitraires :

 do ({var | (var [init-form [[step-form]])}*) (end-test-form result-form*) declaration* {tag | statement}* 
 => result*

Pour la boucle until, l'utilisation de DO est simple : il n'y a pas de variables d'it√©ration, il y a exactement une clause de test, et on peut admettre un groupe d'op√©ration √† effectuer √† chaque it√©ration. Le template √† produire refl√®te cela :

 `(do ()
      (, test)
   ,@body))

On note la backquote pr√©c√©dant l'expression DO. Dans une expression backquot√©e, on peut injecter des informations de deux mani√®res : avec l'op√©rateur , (unquote) qui injecte l'objet imm√©diatement √† sa droite, ou l'op√©rateur , @ (splice-unquote) qui admet une liste √† sa droite et injecte sur place le contenu de la liste.

Le r√©sultat de :

 (macroexpand-1 '(until (= (random 10) 0) 
                    (write-line "Hello")))

est l'expansion

(DO NIL ((= (RANDOM 10) 0)) (WRITE-LINE "Hello"))

dans laquelle on retrouve le template combiné avec les paramètres de l'appel à la macro. L'expansion finale, produite par (macroexpand ...), contient l'expansion de l'opérateur DO lui-même en termes d'opérateurs de plus bas niveau. Comme DO est un opérateur défini par le langage Common Lisp, la sémantique de l'opérateur est toujours la même. Mais il se peut que cette expansion varie d'un compilateur à l'autre. On voit par là que les macros sont déjà massivement utilisées dans l'implémentation d'un langage riche et complexe comme Common Lisp.

Capture de variable

Les macros Common Lisp sont capables de capture de variable, une situation o√Ļ des symboles situ√©s dans le corps de la macro-expansion coincident avec des symboles du contexte appelant. Pour cette raison elles sont parfois appel√©es macro ¬ę non hygi√©niques ¬Ľ, par comparaison avec le syst√®me de ¬ę macro hygi√©niques ¬Ľ de Scheme, qui garantit la s√©paration entre ces ensembles de symboles.

La capture de variable est parfois un effet d√©sir√© ; lorsque ce n'est pas le cas, elle doit √™tre √©vit√© par l'emploi de gensyms, ou symboles dont l'unicit√© est garantie.

Implémentations

Standard et implémentations

Common Lisp est d√©fini par une sp√©cification (comme Ada et C) plut√īt que par une seule impl√©mentation (comme Perl ou Python). Il y a de nombreuses impl√©mentations, et le standard d√©crit les points sur lesquels elles peuvent √™tre divergentes pour de bonnes raisons.

De plus, les impl√©mentations sont g√©n√©ralement fournies avec diff√©rents ensembles de ¬ę paquets ¬Ľ de biblioth√®ques, qui fournissent des fonctionnalit√©s non couvertes par le standard. Certaines de ces fonctionnalit√©s ont √©t√© introduites par la suite dans le standard, comme CLOS et la forme LOOP ; d'autres restent propres √† ces impl√©mentations. De nombreuses commodit√©s pour le programmeur moderne -- comme l'acc√®s aux r√©seaux TCP/IP -- restent hors du standard, mais sont fournies par les diff√©rentes impl√©mentations avec parfois des diff√©rences mineures. Un processus nomm√© CLRFI (Common Lisp Request For Improvement), similaire aux SRFI de Scheme, a pour objectif de faire converger les fonctionnalit√©s utiles laiss√©es hors du standard ANSI de 1995.

Selon une erreur répandue, les implémentations de Common Lisp sont toutes des interpréteurs. En fait, la compilation fait partie de la spécification du langage. La plupart des implémentations de Common Lisp compilent les fonctions vers du code machine. D'autres compilent vers du code objet ou même vers le code d'une machine virtuelle applicative, ce qui réduit la vitesse mais améliore la portabilité.

Certaines implémentations en environnement UNIX, comme CLISP, peuvent être utilisées comme des interpréteurs de scripts (ou même comme shell).

Liste des implémentations

Folklore

Il existe toute une communauté de programmeurs utilisateurs de Common Lisp. Elle s'est formée au fil des ans et elle continue à se développer, "dopée" par la démocratisation d'Internet, notamment depuis les années 1990.

Naturellement, le plaisir que ces programmeurs ont à utiliser ce langage stimule grandement leur imagination. Cela conduit bien souvent certains d'entre eux à faire preuve d'un humour propre à leur domaine.

De mani√®re g√©n√©rale, les communaut√©s finissent bien souvent par se cr√©er une sorte de "Folklore" bien particulier. La communaut√© qui s'est cr√©√©e autour du langage Common Lisp n'y fait pas exception, en t√©moignent les citations suivantes :

¬ę Common Lisp, la force d'une boule de glaise, est le patriarche bien vivant de la famille Lisp.

L'Ing√©nieur lui a donn√© forme, et non le Chercheur en qu√™te de clart√© conceptuelle. Mais en d√©pit de son applicabilit√© pratique, CL offre des plaisirs h√©las inconnus de la programmation mainstream. ¬Ľ

Le Tao de la Récursion

Voir aussi

Applications

Common Lisp est utilis√© avec succ√®s dans de nombreuses applications commerciales :

  • Orbitz, un site majeur de r√©servation de voyages,
  • Mirai, une suite int√©gr√©e de cr√©ation de graphismes 2D/3D offrant ce qui est presque universellement consid√©r√© comme le meilleur modeleur polygonal de l'industrie, un syst√®me d'animation IK/FK et non-lin√©aire (popularis√© par des produits tels que l'Animanium de Sega et Softimage XSI), et de la coloration avanc√© pour la 2D et la 3D. Il est utilis√© dans divers films (le plus fameux √©tant Le Seigneur des anneaux de New Line Cinema), des jeux vid√©o et des simulations militaires.
  • Piano, un packetage pour la conception pr√©liminaire d'avions commerciaux et l'√©valuation de la comp√©tition.
  • Xanalys Corp. offre une ligne de logiciel d'investigation, utilis√© par les services de police, de s√©curit√© et de pr√©vention de la fraude au niveau mondial.
  • Knowledge Technologies International le logiciel de conception m√©canique ICAD.
  • Genworks International le Langage D√©claratif √† usage G√©n√©ral (GDL), un outil de d√©veloppement pour la cr√©ation d'ing√©nierie Web, de conception et d'applications d'affaires.

Il existe √©galement des applications open-source √©crites en Common Lisp, telles que :

  • Applicative Common Lisp, un d√©monstrateur de th√©or√®mes complet pour un sous-ensemble de Common Lisp.
  • Maxima, un syst√®me de calcul alg√©brique formel sophistiqu√©.
  • Axiom, un (autre) syst√®me de calcul alg√©brique formel sophistiqu√©.
  • Compo, un langage permettant la description naturelle de structures musicales complexes.
  • Lisa, un syst√®me √† base de r√®gles pour construire des agents logiciels "intelligents".
  • OpenMusic Un environnement de programmation visuelle con√ßu pour la composition musicale, mais donnant un acc√®s quasi-complet, sous forme graphique, √† la programmation en Common Lisp et CLOS.

Common Lisp est √©galement utilis√© par de nombreux gouvernements et institutions de type Loi 1901. Des exemples d'utilisation par la NASA incluent :

Liens externes

Bibliographie

en ligne

Sous forme papier

  • ANSI Common Lisp, de Paul Graham chez Prentice Hall (1995)
  • Common Lisp, de Wade Hennessey chez Mcgraw-Hill College (1989)
  • Common Lisp: A Gentle Introduction to Symbolic Computation, de David Touretzky chez Benjamin-Cummings Pub Co (1989)
  • Common LISP : The Language, de Guy L. Steele, Jr. chez Digital Press (1991)
  • Object-Oriented Common LISP, de Stephen Slade chez Prentice Hall (1997)
  • Object-Oriented Programming : The CLOS Perspective, de Adreas Paepcke chez MIT Press (1994)
  • Object-Oriented Programming in Common Lisp: A Programmer's Guide to CLOS, de Sonya Keene chez Addison-Wesley (1989)
  • Objectif : CLOS, de Beno√ģt Habert. MASSON, Paris (1996)
  • Paradigms of Artificial Intelligence Programming : Case Studies in Common Lisp, de Peter Norvig chez Morgan Kaufmann (1991)
  • Practical Common Lisp, de Peter Seibel chez Apress (2005)
  • Successful Lisp: How to Understand and Use Common Lisp, de David Lamkins chez BookFix (2004)
  • The Art of the Metaobject Protocol, de Gregor Kiczales chez MIT Press (1991)
  • The ANSI Common Lisp Reference Book, de David Margolies chez Apress, 2008 (ISBN 1590592204 et 9781590592205)

Notes et références


Wikimedia Foundation. 2010.

Contenu soumis à la licence CC-BY-SA. Source : Article Common Lisp de Wikipédia en français (auteurs)

Regardez d'autres dictionnaires:

  • Common Lisp ‚ÄĒ Paradigm(s) Multi paradigm: procedural, functional, object oriented, meta, reflective, generic Appeared in 1984, 1994 for ANSI Common Lisp Developer ANSI X3J13 committee Typing discipline ‚Ķ   Wikipedia

  • Common-Lisp ‚ÄĒ Inoffizielles Lisp Logo Basisdaten Paradigmen: multiparadigmatisch: funktional, prozedural ‚Ķ   Deutsch Wikipedia

  • Common LISP ‚ÄĒ Inoffizielles Lisp Logo Basisdaten Paradigmen: multiparadigmatisch: funktional, prozedural ‚Ķ   Deutsch Wikipedia

  • Common Lisp ‚ÄĒ Inoffizielles Lisp Logo Basisdaten Paradigmen: multiparadigmatisch: funktional, prozedural, modular, objektorientiert ‚Ķ   Deutsch Wikipedia

  • Common Lisp ‚ÄĒ –°–Ķ–ľ–į–Ĺ—ā–ł–ļ–į: –ľ—É–Ľ—Ć—ā–ł–Ņ–į—Ä–į–ī–ł–≥–ľ–į–Ľ—Ć–Ĺ—č–Ļ: –ĺ–Ī—ä–Ķ–ļ—ā–Ĺ–ĺ –ĺ—Ä–ł–Ķ–Ĺ—ā–ł—Ä–ĺ–≤–į–Ĺ–Ĺ—č–Ļ, —Ą—É–Ĺ–ļ—Ü–ł–ĺ–Ĺ–į–Ľ—Ć–Ĺ—č–Ļ, –ł–ľ–Ņ–Ķ—Ä–į—ā–ł–≤–Ĺ—č–Ļ, –ľ–Ķ—ā–į—Ź–∑—č–ļ –Ę–ł–Ņ –ł—Ā–Ņ–ĺ–Ľ–Ĺ–Ķ–Ĺ–ł—Ź: –ļ–ĺ–ľ–Ņ–ł–Ľ–ł—Ä—É–Ķ–ľ—č–Ļ –ü–ĺ—Ź–≤–ł–Ľ—Ā—Ź –≤: 1984, —Ā—ā–į–Ĺ–ī–į—Ä—ā–ł–∑–ł—Ä–ĺ–≤–į–Ĺ ANSI –≤ 1994 ‚Ķ   –í–ł–ļ–ł–Ņ–Ķ–ī–ł—Ź

  • Common Lisp ‚ÄĒ El Common Lisp, puede ser implementado por medio de JAVA. CLISP com√ļnmente abreviado como TL, es un dialecto del lenguaje de programaci√≥n Lisp, publicado en el documento est√°ndar ANSI INCITS 226 1994 (R2004) del ANSI, (antes X3.226 1994… ‚Ķ   Wikipedia Espa√Īol

  • Common LISP ‚ÄĒ ‚óŹ np. m. ‚ĖļLANG version du langage LISP qui s est impos√©e comme standard, apr√®s quelques temps de chaos int√©gral, chacun ayant alors son LISP √† soi. Normalis√© par le comit√© X3J13 de l ANSI. Voir aussi CLOS. Exemple de (tout petit) programme… ‚Ķ   Dictionnaire d'informatique francophone

  • Common Lisp ‚ÄĒ noun A multiparadigm, general purpose programming language. See Also: LISP ‚Ķ   Wiktionary

  • Common Lisp the Language ‚ÄĒ is an influential book by Guy L. Steele about Common Lisp. Contents 1 History 1.1 Before standardization 1.2 During standardization 1.3 A ‚Ķ   Wikipedia

  • Common lisp object system ‚ÄĒ Cette page est consid√©r√©e comme un article √† approfondir. Le Common Lisp Object System, souvent abr√©g√© en CLOS (prononc√© si lauss ), est l ensemble des primitives pr√©sentes dans le langage de programmation Common Lisp pour construire un programme ‚Ķ   Wikip√©dia en Fran√ßais


Share the article and excerpts

Direct link
… Do a right-click on the link above
and select ‚ÄúCopy Link‚ÄĚ

We are using cookies for the best presentation of our site. Continuing to use this site, you agree with this.