---

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 exibidas. Veja Using Guile Interactively em Manual de referência do GNU Guile, para mais detalhes sobre o REPL.

• A sintaxe de Scheme 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 "Olá " "Guix" "\n"))
  -| Olá 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))
  ⇒ #<procedimento 120e348 em <porta desconhecida>: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 Manual de referência do GNU Guile). Aqui estão alguns dos mais úteis em ação:

  (use-modules (srfi srfi-1)) ;importar procedimentos de processamento de lista
  
  (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)           ; para que possamos escrever gexps
               (gnu packages base))  ; para 'coreutils'
  
  ;; 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")
  
      ;; Crie o diretório de saída deste pacote.
      (mkdir #$output))
  

  Veja Expressões-G em Manual de Referência do GNU Guix, para saber mais sobre gexps.

• Múltiplas variáveis podem ser nomeadas localmente com let (veja Local Bindings em Manual de referência do GNU Guile):

  (define x 10)
  (let ((x 2)
        (y 3))
    (list x y))
  ⇒ (2 3)
  
  x
  ⇒ 10
  
  y
  error→ No procedimento module-lookup: Variável não vinculada: 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)
  

• Palavras-chave 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 Keywords 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 Creating Guile Modules em 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 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, por Christine Lemmer-Webber e o 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/.