Zen

Translation

English type: itemize
Modules are created with @code{define-module} (@pxref{Creating Guile Modules,,, guile, GNU Guile Reference Manual}). For instance
136/1300 · 130

Sign in to save the translation.

English French Actions
ungexp
ungexp
Guix defines a variant of S-expressions on steroids called @dfn{G-expressions} or ``gexps'', which come with a variant of @code{quasiquote} and @code{unquote}: @code{#~} (or @code{gexp}) and @code{#$} (or @code{ungexp}). They let you @emph{stage code for later execution}.
Guix définit une variante des S-expressions gonflées aux stéroïdes appelées @dfn{G-expressions} ou « gexps », qui fournit une variante de @code{quasiquote} et @code{unquote} : @code{#~} (ou @code{gexp}) et @code{#$} (ou @code{ungexp}). Elles vous permettent @emph{d'échelonner du code pour une future exécution}.
For example, you'll encounter gexps in some package definitions where they provide code to be executed during the package build process. They look like this:
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) ;so we can write gexps
(gnu packages base)) ;for 'coreutils'
(use-modules (guix gexp) ;pour qu'on puisse écrire des gexps
(gnu packages base)) ;pour « coreutils »
;; Below is a G-expression representing staged code.
#~(begin
;; Invoke 'ls' from the package defined by the 'coreutils'
;; variable.
(system* #$(file-append coreutils "/bin/ls") "-l")
;; 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")
;; Create this package's output directory.
(mkdir #$output))
;; Crée le répertoire de sortie de ce paquet.
(mkdir #$output))
@xref{G-Expressions,,, guix, GNU Guix Reference Manual}, for more on gexps.
@xref{G-Expressions,,, guix.fr, le manuel de référence de GNU Guix}, pour plus de détails sur les gexps.
Multiple variables can be named locally with @code{let} (@pxref{Local Bindings,,, guile, GNU Guile Reference Manual}):
On peut nommer localement plusieurs variables avec @code{let} (@pxref{Local Bindings,,, guile, GNU Guile Reference Manual}) :
(define x 10)
(let ((x 2)
(y 3))
(list x y))
@result{} (2 3)
(define x 10)
(let ((x 2)
(y 3))
(list x y))
@result{} (2 3)
x
@result{} 10
x
@result{} 10
y
@error{} In procedure module-lookup: Unbound variable: y
y
@error{} In procedure module-lookup: Unbound variable: y
Use @code{let*} to allow later variable declarations to refer to earlier definitions.
On peut utiliser @code{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))
@result{} (2 6)
(let* ((x 2)
(y (* x 3)))
(list x y))
@result{} (2 6)
@dfn{Keywords} are typically used to identify the named parameters of a procedure. They are prefixed by @code{#:} (hash, colon) followed by alphanumeric characters: @code{#:like-this}. @xref{Keywords,,, guile, GNU Guile Reference Manual}.
On utilise typiquement des @dfn{mot-clés} pour identifier les paramètres nommés d'une procédure. Ils sont précédés de @code{#:} (dièse, deux-points) suivi par des caractères alphanumériques : @code{#:comme-ça}. @xref{Keywords,,, guile, GNU Guile Reference Manual}.
The percentage @code{%} is typically used for read-only global variables in the build stage. Note that it is merely a convention, like @code{_} in C. Scheme treats @code{%} exactly the same as any other letter.
On utilise souvent le signe pourcent @code{%} pour les variables globales non modifiables à l'étape de construction. Remarquez que ce n'est qu'une convention, comme @code{_} en C. Scheme traite @code{%} de la même manière que les autres lettres.
Modules are created with @code{define-module} (@pxref{Creating Guile Modules,,, guile, GNU Guile Reference Manual}). For instance
On peut créer des modules avec @code{define-module} (@pxref{Creating Guile Modules,,, guile, GNU Guile Reference Manual}). Par exemple :
(define-module (guix build-system ruby)
#:use-module (guix store)
#:export (ruby-build
ruby-build-system))
(define-module (guix build-system ruby)
#:use-module (guix store)
#:export (ruby-build
ruby-build-system))
defines the module @code{guix build-system ruby} which must be located in @file{guix/build-system/ruby.scm} somewhere in the Guile load path. It depends on the @code{(guix store)} module and it exports two variables, @code{ruby-build} and @code{ruby-build-system}.
défini le module @code{guix build-system ruby} qui doit se situer dans @file{guix/build-system/ruby.scm} quelque part dans le chemin de recherche de Guile. Il dépend du module @code{(guix store)} et exporte deux variables, @code{ruby-build} et @code{ruby-build-system}.
@xref{Package Modules,,, guix, GNU Guix Reference Manual}, for info on modules that define packages.
@xref{Modules de paquets,,, guix.fr, le manuel de référence de GNU Guix}, pour plus d'information sur les modules qui définissent des paquets.
Going further
Pour aller plus loin
Scheme is a language that has been widely used to teach programming and you'll find plenty of material using it as a vehicle. Here's a selection of documents to learn more about Scheme:
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 :
@uref{https://spritely.institute/static/papers/scheme-primer.html, @i{A Scheme Primer}}, by Christine Lemmer-Webber and the Spritely Institute.
@uref{https://spritely.institute/static/papers/scheme-primer.html, @i{A Scheme Primer}}, par Christine Lemmer-Webber et le Spritely Institute.
@uref{http://www.troubleshooters.com/codecorn/scheme_guile/hello.htm, @i{Scheme at a Glance}}, by Steve Litt.
@uref{http://www.troubleshooters.com/codecorn/scheme_guile/hello.htm, Scheme at a Glance}, par Steve Litt.
@uref{https://sarabander.github.io/sicp/, @i{Structure and Interpretation of Computer Programs}}, by Harold Abelson and Gerald Jay Sussman, with Julie Sussman. Colloquially known as ``SICP'', this book is a reference.
@uref{https://sarabander.github.io/sicp/, @i{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.
You can also install it and read it from your computer:
Vous pouvez aussi l'installer et le lire sur votre ordinateur :
guix install sicp info-reader
info sicp
guix install sicp info-reader
info sicp
You'll find more books, tutorials and other resources at @url{https://schemers.org/}.
Vous trouverez plus de livres, de didacticiels et d'autres ressources sur @url{https://schemers.org/}.
packaging
empaquetage
This chapter is dedicated to teaching you how to add packages to the collection of packages that come with GNU Guix. This involves writing package definitions in Guile Scheme, organizing them in package modules, and building them.
Ce chapitre est conçu pour vous enseigner comment ajouter des paquets à la collection de paquets de GNU Guix. Pour cela, vous devrez écrire des définitions de paquets en Guile Scheme, les organiser en modules et les construire.
GNU Guix stands out as the @emph{hackable} package manager, mostly because it uses @uref{https://www.gnu.org/software/guile/, GNU Guile}, a powerful high-level programming language, one of the @uref{https://en.wikipedia.org/wiki/Scheme_%28programming_language%29, Scheme} dialects from the @uref{https://en.wikipedia.org/wiki/Lisp_%28programming_language%29, Lisp family}.
GNU Guix se démarque des autres gestionnaire de paquets en étant @emph{bidouillable}, surtout parce qu'il utilise @uref{https://www.gnu.org/software/guile/,GNU Guile}, un langage de programmation de haut-niveau puissant, l'un des dialectes @uref{https://fr.wikipedia.org/wiki/Scheme, Scheme} de @uref{https://fr.wikipedia.org/wiki/Lisp, la famille Lisp}.
Package definitions are also written in Scheme, which empowers Guix in some very unique ways, unlike most other package managers that use shell scripts or simple languages.
Les définitions de paquets sont aussi écrites en Scheme, ce qui le rend plus puissant de manière assez unique par rapport aux autres gestionnaires de paquets qui utilisent des scripts shell ou des langages simples.

Loading…

User avatar roptat

Translation added

  1. guix
  2. documentation-cookbook
  3. French
Modules are created with @code{define-module} (@pxref{Creating Guile Modules,,, guile, GNU Guile Reference Manual}). For instance
On peut créer des modules avec @code{define-module} (@pxref{Creating Guile Modules,,, guile, GNU Guile Reference Manual}). Par exemple :
3 years ago
Browse all string changes

Things to check

Mismatched colon

Source and translation do not both end with a colon

Reset

Glossary

English French
module module guix Glossary

String information

Source string description
type: itemize
Source string location
guix-git/doc/guix-cookbook.texi:444
String age
3 years ago
Last updated
10 months ago
Source string age
3 years ago
Translation file
po/doc/guix-cookbook.fr.po, string 182