Cours accéléré du langage Scheme (Livre de recettes de GNU Guix)

1.1 Cours accéléré du langage Scheme

Guix utilise l’implémentation Guile du langage Scheme. Pour commencer à jouer avec le langage, installez-le avec guix install guile et démarrer une BLÉA (REPL en anglais), une boucle de lecture, évaluation, affichage, en lançant guile sur la ligne de commande.

Vous pouvez également lancer la commande guix shell guile -- guile si vous préférez ne pas installer Guile dans votre profil utilisateur.

Dans les exemples suivants, les lignes montrent ce que vous devez taper sur la REPL ; les lignes commençant par « ⇒ » montrent le résultat de l’évaluation, tandis que les lignes commençant par « -| » montrent ce qui est affiché. Voir Using Guile Interactively dans GNU Guile Reference Manual, pour plus d’information sur la REPL.

La syntaxe de Scheme se résume à un arbre d’expressions (ou une s-expression dans le jargon Lisp). Une expression peut être un litéral comme un nombre ou une chaîne de caractères, ou composée d’une liste d’autres éléments composés et litéraux, entourée de parenthèses. #true et #false (abrégés #t et #f) correspondent aux booléens « vrai » et « faux ».
Voici des exemples d’expressions valides :
```
"Bonjour le monde !"
⇒ "Bonjour le monde !"

17
⇒ 17

(display (string-append "Bonjour " "Guix" "\n"))
-| Bonjour Guix
⇒ #<unspecified>
```
Ce dernier exemple est un appel de fonction imbriqué dans un autre appel de fonction. Lorsqu’une expression parenthésée est évaluée, le premier élément est la fonction et le reste sont les arguments passés à la fonction. Chaque fonction renvoie la dernière expression évaluée.
On peut déclarer des fonctions anonymes — des procédures en Scheme — avec le terme lambda :
```
(lambda (x) (* x x))
⇒ #<procedure 120e348 at <unknown port>:24:0 (x)>
```
La procédure ci-dessus renvoie le carré de son argument. Comme tout est une expression, l’expression lambda renvoie une procédure anonyme, qui peut ensuite être appliquée à un argument :
```
((lambda (x) (* x x)) 3)
⇒ 9
```
Les procédures sont des valeurs normales comme les nombres, les chaines de caractère, les booléens, etc.

On peut assigner un nom global à tout ce qu’on veut avec define :

(define a 3)
(define square (lambda (x) (* x x)))
(square a)
⇒ 9

On peut définir des procédure de manière plus concise avec la syntaxe suivante :
```
(define (square x) (* x x))
```
On peut créer une structure de liste avec la procédure list :
```
(list 2 a 5 7)
⇒ (2 3 5 7)
```

Des procédures standards sont fournies par le module (srfi srfi-1) pour créer et traiter des listes (voir list processing dans le manuel de référence de GNU Guile). Voici certaines des plus utiles en action :

(use-modules (srfi srfi-1))  ; importe les procédures de traitement des listes

(append (list 1 2) (list 3 4))
⇒ (1 2 3 4)

(map (lambda (x) (* x x)) (list 1 2 3 4))
⇒ (1 4 9 16)

(delete 3 (list 1 2 3 4))        ⇒ (1 2 4)
(filter odd? (list 1 2 3 4))     ⇒ (1 3)
(remove even? (list 1 2 3 4))    ⇒ (1 3)
(find number? (list "a" 42 "b")) ⇒ 42

Remarquez que le premier argument de map, filter, remove et find est une procédure !

La quote (l’apostrophe) désactive l’évaluation d’une expression parenthésée, aussi appelée S-expression ou « s-exp » : le premier élément n’est pas appelé avec les autres éléments en argument (voir quote dans GNU Guile Reference Manual). Donc, il renvoie une liste de termes.
```
'(display (string-append "Bonjour " "Guix" "\n"))
⇒ (display (string-append "Bonjour " "Guix" "\n"))

'(2 a 5 7)
⇒ (2 a 5 7)
```
La quasiquote (`, l’apostrophe à l’envers) désactive l’évaluation d’une expression parenthésée jusqu’à ce qu’un unquote (,, une virgule) la réactive. De cette manière, on garde un contrôle fin sur ce qui est évalué et sur ce qui ne l’est pas.
```
`(2 a 5 7 (2 ,a 5 ,(+ a 4)))
⇒ (2 a 5 7 (2 3 5 7))
```
Remarquez que le résultat ci-dessus est une liste d’éléments mixtes : des nombres, des symboles (ici a) et le dernier élément est aussi une liste.
Guix définit une variante des S-expressions gonflées aux stéroïdes appelées G-expressions ou « gexps », qui fournit une variante de quasiquote et unquote : #~ (ou gexp) et #$ (ou ungexp). Elles vous permettent d’échelonner du code pour une future exécution.
Par exemple, vous rencontrerez des gexps dans certaines définitions de paquets qui fournissent du code à exécuter pendant la construction du paquet. Elles ressemblent à ceci :
```
(use-modules (guix gexp)           ;pour qu'on puisse écrire des gexps
             (gnu packages base))  ;pour « coreutils »

;; Ci-dessous, une G-expression représentant du code échelonné.
#~(begin
    ;; Invoque « ls » du paquet défini par la variable
    ;; « coreutils ».
    (system* #$(file-append coreutils "/bin/ls") "-l")

    ;; Crée le répertoire de sortie de ce paquet.
    (mkdir #$output))
```
Voir G-Expressions dans le manuel de référence de GNU Guix, pour plus de détails sur les gexps.

On peut nommer localement plusieurs variables avec let (voir Local Bindings dans GNU Guile Reference Manual) :

(define x 10)
(let ((x 2)
      (y 3))
  (list x y))
⇒ (2 3)

x
⇒ 10

y
erreur→ In procedure module-lookup: Unbound variable: y

On peut utiliser let* pour permettre au déclarations de variables ultérieures d’utiliser les définitions précédentes.

(let* ((x 2)
       (y (* x 3)))
  (list x y))
⇒ (2 6)

On utilise typiquement des mot-clés pour identifier les paramètres nommés d’une procédure. Ils sont précédés de #: (dièse, deux-points) suivi par des caractères alphanumériques : #:comme-ça. Voir Keywords dans GNU Guile Reference Manual.
On utilise souvent le signe pourcent % pour les variables globales non modifiables à l’étape de construction. Remarquez que ce n’est qu’une convention, comme _ en C. Scheme traite % de la même manière que les autres lettres.
On peut créer des modules avec define-module (voir Creating Guile Modules dans GNU Guile Reference Manual). Par exemple :
```
(define-module (guix build-system ruby)
  #:use-module (guix store)
  #:export (ruby-build
            ruby-build-system))
```
défini le module guix build-system ruby qui doit se situer dans guix/build-system/ruby.scm quelque part dans le chemin de recherche de Guile. Il dépend du module (guix store) et exporte deux variables, ruby-build et ruby-build-system.

Voir Modules de paquets dans le manuel de référence de GNU Guix, pour plus d’information sur les modules qui définissent des paquets.

Pour aller plus loin : Scheme est un langage qui a été beaucoup utilisé pour enseigner la programmation et vous trouverez plein de supports qui l’utilisent. Voici une liste de documents qui vous en apprendront plus sur le Scheme :
A Scheme Primer, par Christine Lemmer-Webber et le Spritely Institute.
Scheme at a Glance, par Steve Litt.
Structure and Interpretation of Computer Programs, par Harold Abelson et Gerald Jay Sussman, avec Julie Sussman. Souvent appelé “SICP”, ce livre est une référence.
Vous pouvez aussi l’installer et le lire sur votre ordinateur :
guix install sicp info-reader
info sicp
Vous trouverez plus de livres, de didacticiels et d’autres ressources sur https://schemers.org/.