Zen

Translation

English type: lisp
"Hello World!"
@result{} "Hello World!"

41/410 · 41

Sign in to save the translation.

English Portuguese (Brazil) Actions
Cluster Disk Usage
Uso de disco de cluster
Disk usage considerations.
Considerações sobre o uso do disco.
Cluster Security Considerations
Considerações sobre segurança de cluster
Keeping the cluster secure.
Mantendo o cluster seguro.
Upgrade Postgres for Cuirass
 
How to handle deprecation of the default postgres package.
 
GNU@tie{}Guix is written in the general purpose programming language Scheme, and many of its features can be accessed and manipulated programmatically. You can use Scheme to generate package definitions, to modify them, to build them, to deploy whole operating systems, etc.
GNU@tie{}Guix foi escrito na linguagem de programação de uso geral Scheme, e muitos de seus recursos podem ser acessados e manipulados programaticamente. Você pode usar Scheme para gerar definições de pacotes, modificá-los, construí-los, implantar sistemas operacionais inteiros, etc.
Knowing the basics of how to program in Scheme will unlock many of the advanced features Guix provides --- and you don't even need to be an experienced programmer to use them!
Conhecer o básico de como programar com Scheme irá desbloquear muitos dos recursos avançados que o Guix oferece --- e você nem precisa ser um programador experiente para usá-los!
Let's get started!
Vamos começar!
Scheme, crash course
Scheme, curso intensivo
Guix uses the Guile implementation of Scheme. To start playing with the language, install it with @code{guix install guile} and start a @dfn{REPL}---short for @uref{https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop, @dfn{read-eval-print loop}}---by running @code{guile} from the command line.
Guix usa a implementação Guile do Scheme. Para começar a brincar com a linguagem, instale-a com @code{guix install guile} e inicie um @dfn{REPL}---abreviação de @uref{https://pt.wikipedia.org/wiki/REPL, @dfn{read-eval-print loop}}---executando @code{guile} na linha de comando.
Alternatively you can also run @code{guix shell guile -- guile} if you'd rather not have Guile installed in your user profile.
Alternativamente, você também pode executar @code{guix shell guile -- guile} se preferir não ter o Guile instalado em seu perfil de usuário.
In the following examples, lines show what you would type at the REPL; lines starting with ``@result{}'' show evaluation results, while lines starting with ``@print{}'' show things that get printed. @xref{Using Guile Interactively,,, guile, GNU Guile Reference Manual}, for more details on the REPL.
Nos exemplos a seguir, as linhas mostram o que você digitaria no REPL; linhas que começam com ``@result{}'' mostram resultados de avaliação, enquanto linhas que começam com ``@print{}'' mostram coisas que são exibidas. @xref{Using Guile Interactively,,, guile, Manual de referência do GNU Guile}, para mais detalhes sobre o REPL.
Scheme syntax boils down to a tree of expressions (or @emph{s-expression} in Lisp lingo). An expression can be a literal such as numbers and strings, or a compound which is a parenthesized list of compounds and literals. @code{#true} and @code{#false} (abbreviated @code{#t} and @code{#f}) stand for the Booleans ``true'' and ``false'', respectively.
A sintaxe de Scheme se resume a uma árvore de expressões (ou @emph{s-expression} no jargão Lisp). Uma expressão pode ser um literal, como números e strings, ou um composto que é uma lista entre parênteses de compostos e literais. @code{#true} e @code{#false} (abreviados @code{#t} e @code{#f}) representam os booleanos ``true'' e ``false'', respectivamente.
Examples of valid expressions:
Exemplos de expressões válidas:
"Hello World!"
@result{} "Hello World!"

"Hello World!"
@result{} "Hello World!"

17
@result{} 17

17
@result{} 17

(display (string-append "Hello " "Guix" "\n"))
@print{} Hello Guix!
@result{} #<unspecified>
(display (string-append "Olá " "Guix" "\n"))
@print{} Olá Guix!
@result{} #<unspecified>
This last example is a function call nested in another function call. When a parenthesized expression is evaluated, the first term is the function and the rest are the arguments passed to the function. Every function returns the last evaluated expression as its return value.
Este último exemplo é uma chamada de função aninhada em outra chamada de função. Quando uma expressão entre parênteses é avaliada, o primeiro termo é a função e o restante são os argumentos passados para a função. Cada função retorna a última expressão avaliada como valor de retorno.
Anonymous functions---@dfn{procedures} in Scheme parlance---are declared with the @code{lambda} term:
Funções anônimas ---@dfn{procedures} na linguagem do Scheme --- são declaradas com o termo @code{lambda}:
(lambda (x) (* x x))
@result{} #<procedure 120e348 at <unknown port>:24:0 (x)>
(lambda (x) (* x x))
@result{} #<procedimento 120e348 em <porta desconhecida>:24:0 (x)>
The above procedure returns the square of its argument. Since everything is an expression, the @code{lambda} expression returns an anonymous procedure, which can in turn be applied to an argument:
O procedimento acima retorna o quadrado do seu argumento. Como tudo é uma expressão, a expressão @code{lambda} retorna um procedimento anônimo, que por sua vez pode ser aplicado a um argumento:
((lambda (x) (* x x)) 3)
@result{} 9
((lambda (x) (* x x)) 3)
@result{} 9
Procedures are regular values just like numbers, strings, Booleans, and so on.
Os procedimentos são valores regulares, assim como números, strings, booleanos e assim por diante.
Anything can be assigned a global name with @code{define}:
Qualquer coisa pode receber um nome global com @code{define}:
(define a 3)
(define square (lambda (x) (* x x)))
(square a)
@result{} 9
(define a 3)
(define square (lambda (x) (* x x)))
(square a)
@result{} 9
Procedures can be defined more concisely with the following syntax:
Os procedimentos podem ser definidos de forma mais concisa com a seguinte sintaxe:
(define (square x) (* x x))
(define (square x) (* x x))
A list structure can be created with the @code{list} procedure:
Uma estrutura de lista pode ser criada com o procedimento @code{list}:
(list 2 a 5 7)
@result{} (2 3 5 7)
(list 2 a 5 7)
@result{} (2 3 5 7)
Standard procedures are provided by the @code{(srfi srfi-1)} module to create and process lists (@pxref{SRFI-1, list processing,, guile, GNU Guile Reference Manual}). Here are some of the most useful ones in action:
Os procedimentos padrão são fornecidos pelo módulo @code{(srfi srfi-1)} para criar e processar listas (@pxref{SRFI-1, processamento de listas,, guile, Manual de referência do GNU Guile}). Aqui estão alguns dos mais úteis em ação:

Loading…

User avatar mccay

Translation added
"Hello World!"
@result{} "Hello World!"

"Hello World!"
@result{} "Hello World!"

9 months ago
Browse all string changes

Things to check

Unchanged translation

Source and translation are identical

Reset

Glossary

English Portuguese (Brazil)
No related strings found in the glossary.

7635433 String information

Source string description
type: lisp
Flags
no-wrap
Source string location
guix-git/doc/guix-cookbook.texi:261
String age
3 years ago
Last updated
yesterday
Source string age
4 years ago
Translation file
po/doc/guix-cookbook.pt_BR.po, string 138