1.1 Cours accéléré du language 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 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
  

• 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)
  

• La quote (l’apostrophe) désactive l’évaluation d’une expression parenthésée : 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.

• 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.

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
  

  Un ebook non officiel est aussi disponible.

Vous trouverez plus de livres, de didacticiels et d’autres ressources sur https://schemers.org/.