Zen

Translation

(list 2 a 5 7append (list 1 2) (list 3 4))
@result{} (1 2 3 5 74)
English type: lisp
(append (list 1 2) (list 3 4))
@result{} (1 2 3 4)

35/520 · 52

Sign in to save the translation.

English Spanish Actions
(display (string-append "Hello " "Guix" "\n"))
@print{} Hello Guix!
@result{} #<unspecified>
(display (string-append "Hola " "Guix" "\n"))
@print{} ¡Hola 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 ejemplo es una llamada a una función anidada en otra llamada a una función. Cuando se evalúa una expresión entre paréntesis, el primer término es la función y el resto son los argumentos pasados a la función. Cada función devuelve la última expresión evaluada como valor de retorno.
Anonymous functions---@dfn{procedures} in Scheme parlance---are declared with the @code{lambda} term:
Las funciones anónimas se declaran con el término @code{lambda}:
(lambda (x) (* x x))
@result{} #<procedure 120e348 at <unknown port>:24:0 (x)>
(lambda (x) (* x x))
@result{} #<procedure 120e348 at <unknown port>: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:
El procedimiento anterior devuelve el cuadrado de su argumento. Como todo es una expresión, la expresión @code{lambda} devuelve un procedimiento anónimo, que a su vez puede aplicarse a un 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.
 
Anything can be assigned a global name with @code{define}:
Se puede asignar un nombre global a cualquier cosa con @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:
Los procedimientos pueden definirse de forma más concisa con la siguiente sintaxis:
(define (square x) (* x x))
(define (square x) (* x x))
A list structure can be created with the @code{list} procedure:
Se puede crear una estructura de lista con el procedimiento @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:
 
(use-modules (srfi srfi-1)) ;import list processing procedures

 
(append (list 1 2) (list 3 4))
@result{} (1 2 3 4)

(list 2 a 5 7)
@result{} (2 3 5 7)
(map (lambda (x) (* x x)) (list 1 2 3 4))
@result{} (1 4 9 16)

((lambda (x) (* x x)) 3)
@result{} 9
(delete 3 (list 1 2 3 4)) @result{} (1 2 4)
(filter odd? (list 1 2 3 4)) @result{} (1 3)
(remove even? (list 1 2 3 4)) @result{} (1 3)
(find number? (list "a" 42 "b")) @result{} 42
 
Notice how the first argument to @code{map}, @code{filter}, @code{remove}, and @code{find} is a procedure!
 
S-expression
 
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.
El @dfn{quote} desactiva la evaluación de una expresión entre paréntesis: el primer término no es llamado sobre los otros términos (@pxref{Expression Syntax, quote,, guile, GNU Guile Reference Manual}). Por lo tanto, devuelve efectivamente una lista de términos.
'(display (string-append "Hello " "Guix" "\n"))
@result{} (display (string-append "Hello " "Guix" "\n"))

'(display (string-append "Hola " "Guix" "\n"))
@result{} (display (string-append "Hola " "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.
El @dfn{quasiquote} desactiva la evaluación de una expresión entre paréntesis hasta que @dfn{unquote} (una coma) la vuelva a activar. Por lo tanto, nos proporciona un control fino sobre lo que se evalúa y lo que no.
`(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.
Nótese que el resultado anterior es una lista de elementos mixtos: números, símbolos (aquí @code{a}) y el último elemento es una lista propiamente dicha.
G-expressions, syntax
 
gexps, syntax
 
#~
 
#$
 
gexp
 

Loading…

User avatar None

String updated in the repository
(append (list 1 2) (list 3 4))
@result{} (1 2 3 4)

(list 2 a 5 7)
@result{} (2 3 5 7)
a year ago
User avatar None

Source string changed
(list 2 a 5 7append (list 1 2) (list 3 4))
@result{} (1 2 3 5 74)
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 Spanish
No related strings found in the glossary.

14917319 String information

Source string description
type: lisp
Flags
ignore-same, no-wrap
Source string location
guix-git/doc/guix-cookbook.texi:333
String age
a year ago
Last updated
yesterday
Source string age
a year ago
Translation file
po/doc/guix-cookbook.es.po, string 155