Common Lisp 28391 31271254 2008-07-03T18:13:13Z Pfgomez 147032 '''Common Lisp''' est un langage fonctionnel impur de la famille [[Lisp]]. == 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 : * Accepte des techniques de [[programmation impérative]], [[programmation fonctionnelle|fonctionnelle]] et [[programmation orientée objet|orientée objet]] ([[Common lisp object system|CLOS]]). * Est [[typage dynamique|typé dynamiquement]], mais avec des [[typage statique|déclarations de type]] optionnelles qui peuvent améliorer l'efficacité et la sûreté, * Dispose d'un [[système de gestion d'exceptions]] puissant, nommé ''Condition System'' (système de gestion de conditions), * Est syntaxiquement extensible à travers des fonctionnalités comme les [[Macro-définition|macros]] et les macros de lecture. == Syntaxe == Comme tout langage de la famille Lisp, Common Lisp utilise des [[s-expression]]s 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 : <source lang="lisp"> (+ 2 2) ; ajoute 2 et 2, renvoie 4 (setf e 2.7182817) ; assigne 2.7182817 à la variable e (defun carre (x) (* x x)) ; définit une fonction qui met un nombre au carré (carre 3) ; exécution de la fonction : retourne 9 </source> == 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 [[nombre entier|entier]]s, les [[nombre rationnel|rationnels]], les nombres à [[virgule flottante]] et les [[nombre complexe|nombres complexes]]. Common Lisp utilise des [[Arithmétique multiprécision|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 <source lang="lisp"> (+ (sqrt -2) (/ 6 4)) </source> 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 (informatique)|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]]. [http://www.cliki.net/Unicode%20Support] ==== 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 transformation 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é écrit 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 : <source lang="lisp"> foo ;; -> La variable FOO n'a pas de valeur. (function foo) ;; -> La fonction FOO n'est pas définie. </source> L'opérateur QUOTE protège les symboles de l'évaluation (lorsqu'on veut utiliser un symbole pour lui-même) : <source lang="lisp"> (quote foo) ;; -> FOO 'foo ;; -> FOO </source> On peut demander si un symbole est lié à une valeur ou une fonction : <source lang="lisp"> (boundp 'foo) ;; -> NIL (pas de valeur liée) (fboundp 'foo) ;; -> NIL (aucune fonction nommée FOO n'existe) </source> Association symbole-valeur : <source lang="lisp"> (defparameter foo 77) ;; -> FOO foo ;; -> 77 </source> Association symbole-fonction : <source lang="lisp"> (defun foo (bar) (1+ bar)) ;; -> FOO </source> 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) : <source lang="lisp"> (foo foo) ;; -> 78 (boundp 'foo) ;; -> T (fboundp 'foo) ;; -> T (function foo) ;; -> #<CLOSURE FOO (BAR) (DECLARE (SYSTEM::IN-DEFUN FOO)) (BLOCK FOO (1+ BAR))> </source> === 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 : [[Image:lisp-liste.png|300px]] Il peut être construit de différentes façons, nous en citons deux : <source lang="lisp"> (list 1 (list 2/7 3.14) 'a "foo") (cons 1 (cons (cons 2/7 (cons 3.14 NIL)) (cons 'a (cons "foo" NIL)))) </source> Les listes ou structures cycliques faites à partir de paires n'ont pas de représentation littérale, mais elles peuvent être imprimées : <source lang="lisp"> (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#) </source> ==== 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 création d'un tableau à trois dimensions (4 x 2 x 3) et initialisé : <source lang="lisp"> (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)))) </source> ... 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))) ==== Tables de hachage ==== Les ''[[table de hachage|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 [[espace de noms|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 (programmation)|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 [[Orienté objet|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-classe]]s (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éthode (informatique)|méthode]]s, 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. <source lang="lisp"> (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 </source> On peut appliquer la fonction FOO définie plus haut à une séquence : <source lang="lisp"> (mapcar #'foo (list 1 2 3 4 5)) ;; -> (2 3 4 5 6) </source> ===== 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 : # Un opérateur spécial (comme ''if''), # Une macro, # 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'aternative. ==== 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 : <source lang="lisp"> (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 </source> ===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 convention 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ème de gestion d'exceptions]] les plus complet ; il permet la reprise après erreur. Common Lisp incorpore également une boîte à outils pour la [[programmation orientée objet]], le [[CLOS|Common Lisp Object System]], ou [[CLOS]]. Il est donc possible d'ajouter une infinité de types. == Macros == Une ''[[Macro-définition|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 <CODE>until</CODE> (boucler... jusqu'à), qui est familière dans un langage comme [[Perl (langage)|Perl]]. * définition de la macro : <source lang="lisp"> (defmacro until (test &body body) `(do () (, test) ,@body)) </source> * appel de la macro (utilisation dans un programme) : <source lang="lisp"> (until (= (random 10) 0) (write-line "Hello")) </source> * première étape de macro-expansion (permet de retrouver le texte de la définition interpolé avec les paramètres de l'appel) : <source lang="lisp"> (DO NIL ((= (RANDOM 10) 0)) (WRITE-LINE "Hello")) </source> * macro-expansion complète (ce qui est exécuté pour un appel) : <source lang="lisp"> (BLOCK NIL (LET NIL (TAGBODY #:G7594 (IF (= (RANDOM 10) 0) (GO #:G7595)) (WRITE-LINE "hello") (PSETQ) (GO #:G7594) #:G7595 (RETURN-FROM NIL (PROGN))))) </source> 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-expression]]s 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 : <source lang="lisp"> do ({var | (var [init-form [[step-form]])}*) (end-test-form result-form*) declaration* {tag | statement}* => result* </source> 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 : <source lang="lisp"> `(do () (, test) ,@body)) </source> 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 : <source lang="lisp"> (macroexpand-1 '(until (= (random 10) 0) (write-line "Hello"))) </source> est l'expansion <source lang="lisp">(DO NIL ((= (RANDOM 10) 0)) (WRITE-LINE "Hello"))</source> dans laquelle on retrouve le template combiné avec les paramètres de l'appel à la macro. On notera que 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 [[gensym]]s, ou symboles dont l'unicité est garantie. == Implémentations == ===Standard et implémentations=== Common Lisp est défini par une spécification (comme [[Ada (langage)|Ada]] et [[C (langage)|C]]) plutôt que par une seule implémentation (comme [[Perl (langage)|Perl]] ou [[Langage de programmation Python|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 === * [[SBCL]] : http://www.sbcl.org] * [[Allegro Common Lisp]] by [http://www.franz.com Franz, Inc.] * [[LispWorks]] by [http://www.lispworks.com/ LispWorks Ltd.] * [[Macintosh Common Lisp]] by [http://www.digitool.com/ Digitool, Inc.] * [[Corman Lisp]] by [http://www.cormanlisp.com/ Corman Technologies] * [[Scieneer Common Lisp]] by [http://www.scieneer.com/index.html Scieneer Pty Ltd.]. == 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 90. 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''. » [http://www.schnada.de/hylin/tao.html Le Tao de la Récursion] == Voir aussi == ===Applications=== Common Lisp est utilisé avec succès dans de nombreuses applications commerciales : *[http://www.orbitz.com Orbitz], un site majeur de réservation de voyages, *[http://www.izware.com/mirai/index.htm 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 SXI), 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éos et des simulations militaires. *[http://www.piano.aero/ Piano], un packetage pour la conception préliminaire d'avions commerciaux et l'évaluation de la compétition. *[http://www.xanalys.com/ 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. *[http://www.ktiworld.com/ Knowledge Technologies International] le logiciel de conception mécanique ICAD. *[http://www.genworks.com/ 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 : * [http://www.cs.utexas.edu/users/moore/acl2/ Applicative Common Lisp], un démonstrateur de théorèmes complet pour un sous-ensemble de Common Lisp. * [http://maxima.sourceforge.net/ Maxima], un système de calcul algébrique formel sophistiqué. * [http://wiki.axiom-developer.org/FrontPage Axiom], un (autre) système de calcul algébrique formel sophistiqué. * [http://compo.sourceforge.net Compo], un langage permettant la description naturelle de structures musicales complexes. * [http://lisa.sourceforge.net 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 : *[http://www.stsci.edu/resources/software_hardware/spike/ SPIKE], le système de planification et d'ordonnancement du [[télescope spatial Hubble]]. *[http://ic.arc.nasa.gov/projects/remote-agent/ Remote Agent], gagnant du prix logiciel de la NASA pour l'année 1999. * [[ABCL/1]] === Liens externes === * L'aggrégateur [http://planet.lisp.org/ Planet Lisp] * [http://common-lisp.net common-lisp.net] Hébergements de nombreux projets * La [http://www.lisp.org/HyperSpec/FrontMatter/index.html Common Lisp HyperSpec], une version hypertextuelle du standard. * Le [http://www.cliki.net CLiki], un Wiki Common Lisp. * [http://www.lisp.org/ The Association of Lisp Users]. * [http://cl-cookbook.sourceforge.net/ The Common Lisp Cookbook], une collection de méthodes de programmation utiles. * Le site de [http://www.paulgraham.com Paul Graham], un développeur et avocat de l'utilisation de Common Lisp ; son site contient de nombreux essais sur Lisp et la programmation en général. === Bibliographie === ==== en ligne ==== * [http://www.psg.com/~dlamkins/sl/contents.html Successful Lisp], un livre sur la programmation en Common Lisp. * [http://dept-info.labri.u-bordeaux.fr/~strandh/Teaching/Programmation-Symbolique/Common/Book/HTML/programmation.html Traité de Programmation en Common Lisp], un autre livre, en français, sur la programmation en Common Lisp. * [http://www.paulgraham.com/onlisptext.html On Lisp], un livre de [http://www.paulgraham.com Paul Graham] sur des techniques avancées (en particulier l'art des [[Macro-définition|macros]]). * [http://www-2.cs.cmu.edu/~dst/LispBook Common Lisp: A Gentle Introduction to Symbolic Computation] Un livre très facile d'accès qui présente progressivement les concepts du langage Lisp. * [http://www.gigamonkeys.com/book/ Practical Common Lisp], un livre publié en 2005 sur la constructions d'applications en Common Lisp. Excellente introduction à de nombreuses fonctionnalités avancées du langage, d'un point de vue agréablement concret. * [http://www.ai.univ-paris8.fr/~hw/monCoursIndex.html]un cours en français sur lisp ==== en 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) ====à paraître==== * The ANSI Common Lisp Reference Book, de David Margolies chez Apress (annoncé pour février 2008 sans confirmation de l'auteur) {{Portail|programmation informatique}} [[Catégorie:Langage de programmation]] [[Catégorie:Langage fonctionnel]] [[Catégorie:Langage impératif]] [[de:Common Lisp]] [[en:Common Lisp]] [[fi:Common Lisp]] [[hr:Common Lisp]] [[it:Common LISP]] [[ja:Common Lisp]] [[ko:커먼 리스프]] [[pl:Common Lisp]] [[pt:Common Lisp]] [[ru:Common Lisp]] [[sv:Common Lisp]] [[uk:Коммон Лісп]] [[zh:Common Lisp]]