Acima: Tutoriais sobre Scheme [Conteúdo][Índice]
Guix usa a implementação Guile do Scheme. Para começar a brincar com a
linguagem, instale-a com guix install guile
e inicie um
REPL—abreviação de read-eval-print loop—executando
guile
na linha de comando.
Alternativamente, você também pode executar guix shell guile -- guile
se preferir não ter o Guile instalado em seu perfil de usuário.
Nos exemplos a seguir, as linhas mostram o que você digitaria no REPL; linhas que começam com “⇒” mostram resultados de avaliação, enquanto linhas que começam com “-|” mostram coisas que são impressas. Veja Using Guile Interactively em GNU Guile Reference Manual, para mais detalhes sobre o REPL.
#true
e #false
(abreviados #t
e
#f
) representam os booleanos “true” e “false”, respectivamente.
Exemplos de expressões válidas:
"Hello World!" ⇒ "Hello World!" 17 ⇒ 17 (display (string-append "Hello " "Guix" "\n")) -| Hello Guix! ⇒ #<unspecified>
lambda
:
(lambda (x) (* x x)) ⇒ #<procedure 120e348 at <unknown port>:24:0 (x)>
O procedimento acima retorna o quadrado do seu argumento. Como tudo é uma
expressão, a expressão lambda
retorna um procedimento anônimo, que
por sua vez pode ser aplicado a um argumento:
((lambda (x) (* x x)) 3) ⇒ 9
Os procedimentos são valores regulares, assim como números, strings, booleanos e assim por diante.
define
:
(define a 3) (define square (lambda (x) (* x x))) (square a) ⇒ 9
(define (square x) (* x x))
list
:
(list 2 a 5 7) ⇒ (2 3 5 7)
(srfi srfi-1)
para
criar e processar listas (veja processamento de listas em GNU Guile Reference Manual). Aqui estão alguns dos mais úteis em ação:
(use-modules (srfi srfi-1)) ;import list processing procedures (append (list 1 2) (list 3 4)) ⇒ (1 2 3 4) (map (lambda (x) (* x x)) (list 1 2 3 4)) ⇒ (1 4 9 16) (delete 3 (list 1 2 3 4)) ⇒ (1 2 4) (filter odd? (list 1 2 3 4)) ⇒ (1 3) (remove even? (list 1 2 3 4)) ⇒ (1 3) (find number? (list "a" 42 "b")) ⇒ 42
Observe como o primeiro argumento para map
, filter
,
remove
e find
é um procedimento!
'(display (string-append "Hello " "Guix" "\n")) ⇒ (display (string-append "Hello " "Guix" "\n")) '(2 a 5 7) ⇒ (2 a 5 7)
quasiquote
(`
, uma crase) desativa a avaliação de uma
expressão entre parênteses até que unquote
(,
, 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))) ⇒ (2 a 5 7 (2 3 5 7))
Observe que o resultado acima é uma lista de elementos mistos: números,
símbolos (aqui a
) e o último elemento é uma lista em si.
quasiquote
e unquote
: #~
( ou gexp
)
e #$
(ou ungexp
). Eles permitem preparar código para
execução posterior.
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' ;; 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") ;; Create this package's output directory. (mkdir #$output))
Veja Expressões-G em GNU Guix Reference Manual, para saber mais sobre gexps.
let
(veja Local Bindings em GNU Guile Reference Manual):
(define x 10) (let ((x 2) (y 3)) (list x y)) ⇒ (2 3) x ⇒ 10 y error→ In procedure module-lookup: Unbound variable: y
Use 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)) ⇒ (2 6)
#:
(hash, dois
pontos) seguido por caracteres alfanuméricos:
#:like-this
. Veja Palavras-chave em Manual de referência do
GNU Guile.
%
normalmente é usada para variáveis globais
somente-leitura no estágio de construção. Observe que é apenas uma
convenção, como _
em C. Scheme trata %
exatamente da mesma
forma que qualquer outra letra.
define-module
(veja Criando Módulos
Guile em GNU Guile Reference Manual). Por exemplo
(define-module (guix build-system ruby)
#:use-module (guix store)
#:export (ruby-build
ruby-build-system))
define o módulo guix build-system ruby
que deve estar localizado em
guix/build-system/ruby.scm em algum lugar no caminho de carregamento
do Guile. Depende do módulo (guix store)
e exporta duas variáveis,
ruby-build
e ruby-build-system
.
Veja Módulos de pacote em GNU Guix Reference Manual, para informações sobre módulos que definem pacotes.
Indo além: Scheme é uma linguagem que tem sido amplamente utilizada para ensinar programação e você encontrará muito material usando-a como veículo. Aqui está uma seleção de documentos para saber mais sobre o Scheme:
- A Scheme Primer, by Christine Lemmer-Webber and the Spritely Institute.
- Scheme at a Glance, por Steve Litt.
- Structure and Interpretation of Computer Programs, por Harold Abelson e Gerald Jay Sussman, com Julie Sussman. Coloquialmente conhecido como “SICP”, este livro é uma referência.
Você também pode instalá-lo e lê-lo em seu computador:
guix install sicp info-reader info sicpVocê encontrará mais livros, tutoriais e outros recursos em https://schemers.org/.
Acima: Tutoriais sobre Scheme [Conteúdo][Índice]