Common Lisp

Résumé

Common Lisp (en abrégé CL) est une spécification du langage Lisp standardisée par l'ANSI. 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, fonctionnelle et orientée objet (CLOS).
Est typé dynamiquement, mais avec des déclarations de type optionnelles qui peu

Source officielle

https://fr.wikipedia.org/wiki/Common_Lisp

À propos de ce résultat

Cette page est générée automatiquement et peut contenir des informations qui ne sont pas correctes, complètes, à jour ou pertinentes par rapport à votre recherche. Il en va de même pour toutes les autres pages de ce site. Veillez à vérifier les informations auprès des sources officielles de l'EPFL.

Publications associées (9)

Chargement

Afficher plus

Publications associées

Chargement

Personnes associées (1)

Personnes associées

Chargement

Unités associées (1)

Unités associées

Chargement

Concepts associés (104)

Concepts associés

Chargement

Cours associés (3)

Cours associés

Chargement

Séances de cours associées (4)

Séances de cours associées

Chargement

Publications associées (9)

Macro annotations are an important feature in Scala 2 macro system. Many projects use macro annotations to implement their systems or libraries. Due to the unportability of Scala 2 macro system, Scala 3 redesigns the macro system to make it more reliable and portable. But macro annotations have not been implemented in Scala 3 yet, resulting in some inconvenience in migrating projects that use macro annotations to Scala 3. Following the core design of Scala 2 macro annotations, we introduce the macro annotations as transformations from definitions to definitions. In this thesis, we also list rules to keep our simplicity but not hurt its functionality at the same time. The main difference between macro annotations of Scala 2 and Scala 3 is that in Scala 2 macro annotations expand before typechecking, while they expand after typechecking in Scala 3. Our implementation is based on a breadth-first approach, which helps us implement a tail-recursive transformation. We write test cases covering common and even uncommon cases to test the correctness of our macro annotation system.

2022

Chargement

Fast Functional Lists, Hash-Lists, Deques and Variable Length Arrays

Since its inception Functional Programming, J. McCarthy, has almost universally used the Linked List as the underpinning data structure. This paper introduces a new data structure, the VList, that is compact, thread safe and significantly faster to use than Linked Lists for nearly all list operations. Space usage can be reduced by 50% to 90% and in typical list operations speed improved by factors ranging from 4 to 20 or more. Some important operations such as indexing and length are typically changed from O(N) to O(1) and O(lgN) respectively. A language interpreter Visp, using a dialect of Common Lisp, has been implemented using VLists and the benchmark comparison with OCAML reported. It is also shown how to adapt the structure to create variable length arrays, persistent deques and functional hash tables. The VArray requires no resize copying and has an average O(1) random access time. Comparisons are made with previous resizable one dimensional arrays, Hash Array Trees (HAT) Sitarski [1996], and Brodnik, Carlsson, Demaine, Munro, and Sedgewick [1999].

2002

Chargement

Extensions to Common Lisp for concurrent computation on multiprocessors are discussed. Functions for process creation, communication, and synchronization are described. Process objects create multiple threads of control. Processes are lightweight so that programmers can use them to take advantage of fine-grained parallelism. Communication and synchronization are managed with mailboxes. Signals allow processes to communicate using asynchronous interrupts. These constructs are used to implement several higher-level multiprocessing abstractions. These include structured processes, a parallel tree search, and dataflow computation

IEEE1989

Chargement

Afficher plus