Utiliser Guix de manière interactive (Manuel de référence de GNU Guix)

8.14 Utiliser Guix de manière interactive

La commande guix repl vous donne accès à une boucle-lecture-évalutation-affichage (BLÉA ou REPL en anglais) chaleureuse et amicale (voir Invoquer guix repl). Si vous commencez la programmation avec Guix — pour définir vos propres paquets, écrire des manifestes, définir des services pour le système Guix ou Guix Home, etc — vous la trouverez sans doute pratique pour jouer avec vos idées sur la REPL.

Si vous utilisez Emacs, le moyen le plus pratique pour cela est d’utiliser Geiser (voir La configuration parfaite), mais vous n’avez pas besoin d’utiliser Emacs pour profiter de la REPL. Lorsque vous utilisez guix repl ou guile dans un terminal, nous vous recommandons d’utiliser Readline pour la complétion et Colorized pour avoir une sortie colorée. Pour cela, vous pouvez lancer :

guix install guile guile-readline guile-colorized

… puis créer un fichier .guile dans votre répertoire personnel, contenant ceci :

(use-modules (ice-9 readline) (ice-9 colorized))

(activate-readline)
(activate-colorized)

La REPL vous permet d’évaluer du code Scheme ; vous tapez une expression Scheme sur l’invite, et la REPL affiche ce en quoi elle s’évalue :

$ guix repl
scheme@(guix-user)> (+ 2 3)
$1 = 5
scheme@(guix-user)> (string-append "a" "b")
$2 = "ab"

Ça devient plus intéressant quand vous commencez à jouer avec Guix sur la REPL. La première chose à faire est « d’importer » le module (guix), qui vous donne accès à la partie principale de l’interface de programmation, et peut-être à un ensemble de modules Guix utiles. Vous pouvez taper (use-modules (guix)), ce qui est du code Scheme valide pour importer un module (voir Using Guile Modules dans manuel de référence de GNU Guile), mais la REPL fournit la commande use comme raccourci (voir REPL Commands dans manuel de référence de GNU Guile) :

scheme@(guix-user)> ,use (guix)
scheme@(guix-user)> ,use (gnu packages base)

Remarquez que les commandes de la REPL sont introduites par une virgule. Une commande REPL comme use n’est pas du code Scheme valide, elle est interprétée de manière spéciale par la REPL.

Guix étend la REPL Guile avec des commandes supplémentaires pour votre confort. Parmi celles-ci, la commande build est pratique : elle s’assure que l’objet simili-fichier donné est construit, en le construisant si nécessaire, et renvoie le nom de fichier de sa sortie. Dans l’exemple ci-dessous, nous construisons les paquets coreutils et grep, ainsi qu’un « fichiers calculé » (voir computed-file), et nous utilisons la procédure scandir pour lister les fichiers du répertoire /bin de Grep :

scheme@(guix-user)> ,build coreutils
$1 = "/gnu/store/…-coreutils-8.32-debug"
$2 = "/gnu/store/…-coreutils-8.32"
scheme@(guix-user)> ,build grep
$3 = "/gnu/store/…-grep-3.6"
scheme@(guix-user)> ,build (computed-file "x" #~(mkdir #$output))
construction de /gnu/store/…-x.drv...
$4 = "/gnu/store/…-x"
scheme@(guix-user)> ,use(ice-9 ftw)
scheme@(guix-user)> (scandir (string-append $3 "/bin"))
$5 = ("." ".." "egrep" "fgrep" "grep")

As a packager, you may be willing to inspect the build phases or flags of a given package; this is particularly useful when relying a lot on inheritance to define package variants (voir Définition de variantes de paquets) or when package arguments are a result of some computation, both of which can make it harder to foresee what ends up in the package arguments. Additional commands let you inspect those package arguments:

scheme@(guix-user)> ,phases grep
$1 = (modify-phases %standard-phases
       (add-after 'install 'fix-egrep-and-fgrep
         (lambda* (#:key outputs #:allow-other-keys)
           (let* ((out (assoc-ref outputs "out"))
                  (bin (string-append out "/bin")))
             (substitute* (list (string-append bin "/egrep")
                                (string-append bin "/fgrep"))
               (("^exec grep")
                (string-append "exec " bin "/grep")))))))
scheme@(guix-user)> ,configure-flags findutils
$2 = (list "--localstatedir=/var")
scheme@(guix-user)> ,make-flags binutils
$3 = '("MAKEINFO=true")

À plus bas niveau, une commande utile est lower : elle prend un objet simili-fichier et l’« abaisse » en une dérivation (voir Dérivations) ou un fichier du dépôt :

scheme@(guix-user)> ,lower grep
$6 = #<derivation /gnu/store/…-grep-3.6.drv => /gnu/store/…-grep-3.6 7f0e639115f0>
scheme@(guix-user)> ,lower (plain-file "x" "Hello!")
$7 = "/gnu/store/…-x"

La liste complète des commandes de la REPL se trouvent en tapant ,help guix et est donnée ci-dessous pour référence.

commande REPL :build objet: Abaisse objet et le construit s’il n’est pas déjà construit, et renvoie le nom de fichier de ses sorties.

commande REPL :lower objet: Abaisse objet en une dérivation ou un nom de fichier du dépôt et le renvoie.

commande REPL :verbosity niveau

Change la verbosité des construction à niveau.

C’est similaire à l’option en ligne de commande --verbosity (voir Options de construction communes) : le niveau 0 signifie le silence total, le niveau 1 montre les événements de construction et les niveaux plus élevés affichent les journaux de construction.

REPL command :phases package
REPL command :configure-flags package
REPL command :make-flags package: These REPL commands return the value of one element of the arguments field of package (voir Référence de package): the first one show the staged code associated with #:phases (voir Phases de construction), the second shows the code for #:configure-flags, and ,make-flags returns the code for #:make-flags.

commande REPL :run-in-store exp: Lance exp, une expression monadique dans la monade du dépôt. Voir La monade du dépôt, pour plus d’information.

command REPL :enter-store-monad: Entre dans une nouvelle REPL pour évaluer des expressions monadiques (voir La monade du dépôt). Vous pouvez quitter la REPL « interne » en tapant ,q.