Um curso intensivo de Scheme (Livro de Receitas do GNU Guix)

1.1 Um curso intensivo de Scheme

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.

A sintaxe do esquema se resume a uma árvore de expressões (ou 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. #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>
```
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.
Funções anônimas —procedures na linguagem do Scheme — são declaradas com o termo 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.

Qualquer coisa pode receber um nome global com define:

(define a 3)
(define square (lambda (x) (* x x)))
(square a)
⇒ 9

Os procedimentos podem ser definidos de forma mais concisa com a seguinte sintaxe:
```
(define (square x) (* x x))
```
Uma estrutura de lista pode ser criada com o procedimento list:
```
(list 2 a 5 7)
⇒ (2 3 5 7)
```

Os procedimentos padrão são fornecidos pelo módulo (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!

O 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 (veja quote em Manual de referência do GNU Guile). Assim, ele efetivamente retorna uma lista de termos.
```
'(display (string-append "Hello " "Guix" "\n"))
⇒ (display (string-append "Hello " "Guix" "\n"))

'(2 a 5 7)
⇒ (2 a 5 7)
```
O 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.
Guix define uma variante de expressões simbólicas (S-expressions) com esteróides chamada G-expressions ou “gexps”, que vem com uma variante de 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.

Múltiplas variáveis podem ser nomeadas localmente com 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)

Keywords normalmente são usados para identificar os parâmetros nomeados de um procedimento. Eles são prefixados por #: (hash, dois pontos) seguido por caracteres alfanuméricos: #:like-this. Veja Palavras-chave em Manual de referência do GNU Guile.
A porcentagem % 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.
Os módulos são criados com 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 sicp
Você encontrará mais livros, tutoriais e outros recursos em https://schemers.org/.