Zen

Translation

English type: lisp
;; 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")

193/1980 · 198

Sign in to save translations.

English Portuguese (Brazil) Actions
The @dfn{quote} disables evaluation of a parenthesized expression, also called an S-expression or ``s-exp'': the first term is not called over the other terms (@pxref{Expression Syntax, quote,, guile, GNU Guile Reference Manual}). Thus it effectively returns a list of terms.
O @dfn{quote} desativa a avaliação de uma expressão entre parênteses, também chamada de expressão S ou ``s-exp'': o primeiro termo não é chamado sobre os outros termos (@pxref{Expression Syntax, quote,, guile, Manual de referência do GNU Guile}). Assim, ele efetivamente retorna uma lista de termos.
'(display (string-append "Hello " "Guix" "\n"))
@result{} (display (string-append "Hello " "Guix" "\n"))

'(display (string-append "Hello " "Guix" "\n"))
@result{} (display (string-append "Hello " "Guix" "\n"))

'(2 a 5 7)
@result{} (2 a 5 7)
'(2 a 5 7)
@result{} (2 a 5 7)
The @code{quasiquote} (@code{`}, a backquote) disables evaluation of a parenthesized expression until @code{unquote} (@code{,}, a comma) re-enables it. Thus it provides us with fine-grained control over what is evaluated and what is not.
O @code{quasiquote} (@code{`}, uma crase) desativa a avaliação de uma expressão entre parênteses até que @code{unquote} (@code{,}, uma vírgula) a reative. Assim, nos fornece um controle refinado sobre o que é avaliado e o que não é.
`(2 a 5 7 (2 ,a 5 ,(+ a 4)))
@result{} (2 a 5 7 (2 3 5 7))
`(2 a 5 7 (2 ,a 5 ,(+ a 4)))
@result{} (2 a 5 7 (2 3 5 7))
Note that the above result is a list of mixed elements: numbers, symbols (here @code{a}) and the last element is a list itself.
Observe que o resultado acima é uma lista de elementos mistos: números, símbolos (aqui @code{a}) e o último elemento é uma lista em si.
G-expressions, syntax
G-expressions, sintaxe
gexps, syntax
gexps, sintaxe
#~
#~
#$
#$
gexp
gexp
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 define uma variante de expressões simbólicas (S-expressions) com esteróides chamada @dfn{G-expressions} ou ``gexps'', que vem com uma variante de @code{quasiquote} e @code{unquote}: @code{#~} ( ou @code{gexp}) e @code{#$} (ou @code{ungexp}). Eles permitem @emph{preparar código para execução posterior}.
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:
Por exemplo, você encontrará gexps em algumas definições de pacotes onde eles fornecem código a ser executado durante o processo de construção do pacote. Eles se parecem com isto:
(use-modules (guix gexp) ;so we can write gexps
(gnu packages base)) ;for 'coreutils'

(use-modules (guix gexp) ; para que possamos escrever gexps
(gnu packages base)) ; para '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")

;; Abaixo está uma expressão G representando código preparado.
#~(begin
;; Invoca 'ls' do pacote definido pela variável 'coreutils'.
(system* #$(file-append coreutils "/bin/ls") "-l")

;; Create this package's output directory.
(mkdir #$output))
;; Crie o diretório de saída deste pacote.
(mkdir #$output))
@xref{G-Expressions,,, guix, GNU Guix Reference Manual}, for more on gexps.
@xref{Expressões-G,,, guix.pt_BR, Manual de Referência do GNU Guix}, para saber mais sobre gexps.
Multiple variables can be named locally with @code{let} (@pxref{Local Bindings,,, guile, GNU Guile Reference Manual}):
Múltiplas variáveis podem ser nomeadas localmente com @code{let} (@pxref{Local Bindings,,, guile, Manual de referência do GNU Guile}):
(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{} No procedimento module-lookup: Variável não vinculada: y
Use @code{let*} to allow later variable declarations to refer to earlier definitions.
Use @code{let*} para permitir que declarações de variáveis posteriores se refiram a definições anteriores.
(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}.
@dfn{Palavras-chave} normalmente são usados para identificar os parâmetros nomeados de um procedimento. Eles são prefixados por @code{#:} (hash, dois pontos) seguido por caracteres alfanuméricos: @code{#:like-this}. @xref{Keywords,,, guile, Manual de referência do GNU Guile}.
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.
A porcentagem @code{%} normalmente é usada para variáveis globais somente-leitura no estágio de construção. Observe que é apenas uma convenção, como @code{_} em C. Scheme trata @code{%} exatamente da mesma forma que qualquer outra letra.
Modules are created with @code{define-module} (@pxref{Creating Guile Modules,,, guile, GNU Guile Reference Manual}). For instance
Os módulos são criados com @code{define-module} (@pxref{Creating Guile Modules,,, guile, Manual de referência do GNU Guile}). Por exemplo
(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}.
define o módulo @code{guix build-system ruby} que deve estar localizado em @file{guix/build-system/ruby.scm} em algum lugar no caminho de carregamento do Guile. Depende do módulo @code{(guix store)} e exporta duas variáveis, @code{ruby-build} e @code{ruby-build-system}.
@xref{Package Modules,,, guix, GNU Guix Reference Manual}, for info on modules that define packages.
@xref{Módulos de pacote,,, guix.pt_BR, GNU Guix Reference Manual}, para informações sobre módulos que definem pacotes.
Going further
Indo além

Loading…

User avatar pelzflorian

Translation changed
;; 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")

;; Abaixo está uma expressão G representando código preparado.
#~(begin
;; Invoca 'ls' do pacote definido pela variável 'coreutils'
;; .
.
(system* #$(file-append coreutils "/bin/ls") "-l")

5 months ago
User avatar krascovict

Translation changed
;; 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")

;; Below is a G-Abaixo está uma expressionão G representing staged codeando código preparado.
#~(begin
;; Invokeca 'ls' from thedo packagote defined by the 'coreutils'
;; variable.
ido pela variável 'coreutils'
;; .
(system* #$(file-append coreutils "/bin/ls") "-l")

6 months ago
User avatar mccay

Marked for edit
;; 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")

;; 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")

a year ago
User avatar None

String updated in the repository
;; 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")

 
a year ago
Browse all string changes

Things to check

Mismatching line breaks

Number of new lines in translation does not match source.

Reset

Glossary

English Portuguese (Brazil)
G-expression guix Glossary
package pacote guix Glossary

14832299 String information

Source string description
type: lisp
Flags
no-wrap
Source string location
guix-git/doc/guix-cookbook.texi:405
String age
a year ago
Last updated
3 weeks ago
Source string age
a year ago
Translation file
po/doc/guix-cookbook.pt_BR.po, string 178