Escrevendo programas

Variáveis globais são variáveis que, normalmente, são acessíveis em qualquer região de um programa.

Majestic Lisp armazena, em um estado global, uma tabela que liga certos rótulos (símbolos) a certos valores.

Podemos usar a forma especial def para definir uma variável.

A seguir, usamos def para definir uma variável global x, de valor numérico 5. Como resposta, o interpretador retorna o mesmo símbolo x, indicando que este foi definido com sucesso.

(def x 5)

x

Se, logo em seguida, formos ao REPL e digitarmos o símbolo x para que seja interpretado, o interpretador retornará o valor associado a esse símbolo:

x

5

Caso digitássemos um símbolo não-quotado que não correspondesse a uma variável anteriormente definida, o interpretador informaria que há um erro.

Podemos redefinir o valor de uma variável com facilidade, usando a forma especial set. Ela nos permite realizar atribuições de novos valores a variáveis já existentes.

(set x 9)

x

x

9

set só pode ser utilizado em uma variável global após a mesma ter sido atribuída, através de def.

Há uma forma de definir variáveis apenas temporariamente através da criação de um escopo. O interpretador de Majestic Lisp tratará essa variável como definida apenas dentro do mesmo; fora, a variável já não estará definida.

(let ((y 9))
  y)

9

Na situação acima, usamos o macro let para definir localmente uma única variável y, que estará definida apenas para o corpo desse macro.

O macro let tem a forma a seguir:

(let (<definições>)
  <corpo>)

…onde <definições> é um número arbitrário de duplas na forma (rótulo valor), e <corpo> é uma única expressão, que será interpretada levando em consideração as variáveis localmente definidas.

O exemplo anterior funciona como se tivéssemos definido a variável y globalmente usando o valor 9 e pedíssemos o valor associado a y. Logo em seguida, o interpretador "esquece" que essa variável foi algum dia definida.

Também podemos redefinir o valor de uma variável local, usando a forma especial set:

(let ((y 9))
  (set y 10)
  y)

10

As funções primitivas de Majestic Lisp são funções já definidas antes da execução do interpretador. Isso significa que qualquer implementação da linguagem precisa garantir que essas funções possam ser utilizadas.

Uma dessas funções é a função +, responsável principalmente por somar números. Essa função aceita qualquer quantidade de números como argumentos e, quando fornecidos dois ou mais argumentos, ela retorna a soma de todos esses números².

(+ 2 3)

5

(+ 5 7 1)

13

Há também outras funções primitivas de aritmética, capazes de executar multiplicação (*), divisão (/) e subtração (-). Podemos inclusive usar sublistas para realizar mais operações com o resultado de outras operações; nesse caso, também é pertinente indentar nosso código para melhor legibilidade.

(+ (/ 8 2)
   (+ 1 3)
   (* 7 7))

57

Outro exemplo de função primitiva, muito utilizada, é cons. Essa função requer exatamente dois argumentos, e pode ser utilizada para criar uma célula cons. Veja o exemplo um pouco mais complexo a seguir.

(let ((x 2)
      (y 3))
  (cons x y))

(2 . 3)

Aqui, temos as variáveis locais x e y, de valores atribuídos 2 e 3, respectivamente.

Ao passarmos as variáveis locais x e y para cons, veja que não estamos quotando esses rótulos. Isso significa que o que está sendo passado a cons não são os nomes das variáveis, mas sim os valores a eles atribuídos.

Da mesma forma, cons é apenas o rótulo de uma certa operação, que cria uma célula cons a partir de dois valores.

O resultado da operação é uma célula cujo car é 2 e cujo cdr é 3. Ao final do escopo do let, as variáveis x e y deixarão de "existir", permanecendo apenas a célula cons retornada, contendo esses valores.

Podemos constatar os valores de car e cdr de uma função através das funções primitivas homônimas, car e cdr. A seguir, temos um exemplo um pouco mais complexo, que toma o retorno do escopo anteriormente demonstrado, colocando-o em uma variável para ser consultada depois.

(def my-cell
  (let ((x 2)
        (y 3))
    (cons x y)))

my-cell

my-cell

(2 . 3)

(car my-cell)

2

(cdr my-cell)

3

As funções de usuário de Majestic Lisp são funções declaradas pelo usuário do sistema, diferentemente das funções primitivas que já existem quando o sistema é iniciado.

A sintaxe para a declaração de uma função envolve a forma especial fn, que pode ser compreendida como:

(fn <argumentos> <corpo>)

…onde <argumentos> é, normalmente, uma lista de argumentos para a função, e <corpo> é uma única expressão a ser executada durante a invocação da função.

O exemplo a seguir envolve a função que eleva um número ao quadrado. Como podemos observar, a função recebe um único argumento (aqui chamado x), e então multiplica-o por si mesmo.

O resultado retornado é um formato de impressão de uma função, que normalmente não pode ser reinserido no REPL.

(fn (x) (* x x))

#<function (fn (x)) {0x565242ffe170}>

Funções são cidadãos de primeira-classe em Majestic Lisp. Isso significa que elas podem ser rotuladas, repassadas em aplicações de outras funções e atribuídas a novos rótulos, assim como faríamos com qualquer outro valor.

Podemos, por exemplo, atribuir a nossa função ao símbolo square:

(def square
  (fn (x) (* x x)))

square

Para que não precisemos usar com frequência a dupla def … fn, instituiremos um atalho sintático (um macro) que faça este trabalho por nós, tornando as funções mais simples de serem lidas. Este macro se chamará defn, e poderá ser escrito usando a regra sintática:

(defn <nome> <argumentos> <corpo>)

Se esse "atalho sintático" fosse expandido, seria exatamente igual ao exemplo anterior, em que usamos def e fn, portanto as regras para o símbolo, os argumentos e o corpo ainda se aplicam.

(defn square (x)
  (* x x))

square

A aplicação de uma função do usuário é muito similar, se não idêntica, à aplicação de uma função primitiva.

(square 5)

25