Emacs Lisp (Elisp) constitue le moteur interne de l'éditeur de texte Emacs. Pour quiconque souhaite personnaliser son environnement ou développer des extensions robustes, la compréhension de son système de types est impérative. Ce guide explore l'écosystème des données en Elisp, allant des types atomiques simples aux structures de programmation avancées.

Types atomiques : les briques élémentaires

Les atomes sont des objets qui ne peuvent pas être divisés en structures plus petites via les fonctions de liste standard. Ils représentent les valeurs fondamentales du langage.

Valeurs numériques

Elisp gère deux grandes catégories de nombres :

• Entiers : Ils peuvent être exprimés en décimal (1024), en hexadécimal (#x400), ou encore en binaire (#b10000000000).
• Flottants : Utilisés pour la précision décimale, par exemple 3.14159 ou 1.5e-3.

Symboles et valeurs booléennes

Un symbole est un objet possédant un nom unique (par exemple, fill-column). En Elisp, la logique booléenne repose sur deux smyboles particuliers :

• t : Représente la vérité (True).
• nil : Représente la fausseté (False) ainsi que la liste vide.

Caractères et chaînes de texte

Contrairement à certains langages, les caractères en Elisp sont traités comme des entiers. On les préfixe par un point d'interrogation : ?A correspond à l'entier 65. Les chaînes de caractères (strings) sont des tableaux de caractères entourés de guillemets, comme "Configuration Emacs".

Structures de données composites

Listes et cellules de cons (Cons Cells)

La liste est la structure centrale du Lisp. Elle est construite à partir de "cons cells", des paires pointées reliant une valeur à la suivante.

;; Création d'une liste simple
(setq ma-liste '(pomme banane cerise))

;; Une cellule de cons (paire pointée)
(setq ma-paire '(clé . valeur))

Tableaux et Vecteurs

Les vecteurs sont des séquences à accès constant, plus performants que les listes pour la lecture directe d'index. On les définit avec des crochets :

;; Un vecteur contenant divers types
(setq mon-vecteur [10 "texte" (1 2)])

Tables de hachage

Pour stocker des associations clé-valeur avec une recherche rapide, Elisp propose les hash-table.

(let ((mon-atlas (make-hash-table :test 'equal)))
  (puthash "Paris" "France" mon-atlas)
  (puthash "Berlin" "Allemagne" mon-atlas)
  (gethash "Paris" mon-atlas))

Types orientés système et programmation avancée

Fonctions et Fermetures (Closures)

En Elisp, les fonctions sont des objets de premier ordre. Avec l'activation du lexical-binding, le langage supoprte les fermetures, permettant de capturer l'état des variables environnantes.

Structures et Objets

Via la bibliothèque cl-lib, il est possible de définir des structures de données nommées, proches des enregistrements (structs) en C :

(cl-defstruct utilisateur
  nom
  id
  actif-p)

(setq nouveau-user (make-utilisateur :nom "Jean" :id 1 :actif-p t))

Objets spécifiques à l'éditeur

Elisp manipule des types propres à l'édition de texte :

• Buffer : Représente un fichier ou un flux de texte ouvert.
• Window : Gère l'affichage d'un buffer à l'écran.
• Marker : Désigne une position spécifique dans un buffer qui s'ajuste lors des modifications de texte.

Manipulation et vérification des types

Il est courant de devoir vérifier le type d'une donnée avant de la traiter pour éviter les erreurs d'exécution.

(defun analyser-donnee (entree)
  "Affiche la nature de la donnée passée en paramètre."
  (message "Nature : %s"
           (cond ((integerp entree) "Nombre entier")
                 ((stringp entree)  "Chaîne de caractères")
                 ((vectorp entree)  "Vecteur")
                 ((symbolp entree)  "Symbole")
                 (t "Type complexe ou inconnu"))))

;; Exemple de conversion
(let ((valeur "42"))
  (string-to-number valeur)) ; Retourne l'entier 42

La maîtrise de ces types permet non seulement d'écrire du code plus propre, mais aussi de mieux comprendre les API internes d'Emacs. Qu'il s'agisse de transformer une liste en vecteur pour optimiser les performances ou de manipuler des buffers via des symboles, la flexibilité du système de types d'Elisp est le socle de l'extensibilité légendaire d'Emacs.