Ambientes de Desenvolvimento: Configuração para Programação em LISP

Imagem do editor de texto GNU Emacs para programação em linguagem LISP, com exemplos de código-fonte apresentados nesta página no editor e resultados de execução no interpretador. Na parte direita da imagem, parte do código-fonte para definição de SLIME, que pode ser usado no Emacs para programação em LISP.

Créditos para a imagem: Imagem criada pelo autor usando o programa Spectacle.

Pré-Requisitos

Os pré-requisitos para iniciar as atividades de programação em LISP são semelhantes aos descritos para JavaScript, Python e Lua: um editor de texto e um interpretador, ou um Ambiente Integrado de Desenvolvimento (em inglês, Integrated Development Environment ou IDE).

Para evitar repetir as discussões feitas anteriormente para JavaScript e Python:

Se você já possui um editor de texto, você pode instalar um interpretador para LISP e começar a programar;
Se você preferir usar um IDE, a opção mais simples é escolher Emacs com SLIME usando Portacle, que inclui, dentre outros, editor de texto, interpretador e depurador;
Se você não sabe como instalar programas, o que é PATH ou como configurá-lo, consulte a entrada sobre instalação de programas.

Parte do conteúdo desta página será idêntico ao conteúdo de Python. Portanto, caso alguns parágrafos sejam familiares, não será impressão, mas um certo déjà vu. Por sinal, isso também ocorrerá em novas entradas sobre ambientes de desenvolvimento em outras linguagens de programação. Afinal, os procedimentos para configuração são similares.

LISP Como Primeira Linguagem de Programação

Python e Lua lideram a minha lista de recomendações de linguagens de programação para iniciantes, como comentado na introdução sobre ambientes de desenvolvimento; a terceira opção é JavaScript, devido à Internet.

Dependendo da pessoa, LISP pode ser uma boa linguagem para primeiras atividades de programação. Em particular, pessoas que conheçam o cálculo lambda (cálculo-λ) provavelmente encontrarão muitas similaridades com LISP. De fato, o cálculo-λ foi uma das inspirações para as primeiras implementações de LISP.

Deve-se considerar que existem vários dialetos para a linguagem LISP. Nesta página, utiliza-se Common LISP. Para iniciantes em programação, Racket (usando DrRacket como IDE), ou Scheme (também usando DrRacket, que, por sinal, originalmente chamava-se DrScheme) podem ser opções mais simples que Common LISP. Outra possibilidade é Clojure (usando um IDE como Nightcode, Lightmod, Light Table, ou Cursive).

Um benefício de LISP é que, embora a linguagem seja conceitualmente complexa, a sintaxe é simples. É verdade que a sintaxe de LISP é diferente de praticamente todas as outras linguagens de programação, mas isso não seria um problema para pessoas iniciantes (que não tiveram contato com outras linguagens).

Por ser uma linguagem funcional, LISP também aproxima-se mais da Matemática escolar que outras linguagens de programação. Por outro lado, expressões em LISP são escritas em formato (notação) prefix, com operadores antes de operandos. Por exemplo, ao invés de (notação infix), escreve-se (+ 1 (- 2 3)).

Sobre LISP

LISP (ou Lisp, em grafia mais moderna) é, simultaneamente, uma linguagem extremamente simples e extremamente complexa. A frase anterior é contraditória, mas a linguagem requer experiência e prática para se explorar seu potencial.

LISP é uma linguagem de programação funcional. Essa primeira característica torna-a diferente de todas as linguagens apresentadas em tópicos anteriores. Não apenas pela sintaxe cheia de parênteses, que é algo imediatamente observável em código-fonte LISP.

Programar em LISP requer uma forma de pensar diferente. Em LISP, quase tudo são expressões (conhecidas como s-expressions ou sexp). Um programa é uma combinação de expressões. Expressões podem resultar de combinações de outras expressões.

A primeira decorrência é que LISP não distingue código de dados. Código e dados são expressões. Código pode ser dados; dados podem ser código. A segunda decorrência é que, se código e dados são intercambiáveis, pode-se modificar código assim como se pode modificar dados de um programa. A terceira decorrência é que LISP permite que programadores e programadores alterem programas e a própria linguagem. Em particular, é possível até mesmo modificar um programa escrito em LISP com ele em execução.

Em outras palavras, LISP é uma linguagem de programação programável. Enquanto a maioria das linguagens permite criar programas, LISP permite modificar (adaptar) a própria linguagem para se resolver problemas.

Uma aplicação prática é a possibilidade de LISP para a definição de Linguagens de Domínio Específico (do inglês, Domain-Specific Language ou DSL).

A linguagem também permite processamento simbólico (isto é, de símbolos). De fato, a letra s em s-expression significa symbolic (ou seja, symbolic expression). Isso faz com que a linguagem seja bastante utilizada em pesquisa para Inteligência Artificial (IA, ou Artificial Intelligence, com sigla AI).

Fora da Ciência da Computação, LISP é usada em alguns sistemas de Desenho Assistido por Computador (do inglês, Computer Aided Design ou CAD). Um exemplo é AutoCAD, que permite o uso de LISP para a escrita de scripts.

Antigamente, existiam máquinas LISP como hardware especializado para uso com LISP. Embora tais máquinas estejam extintas, conhecer sobre elas pode ser uma forma interessante de descobrir potenciais e caminhos esquecidos para a programação.

Atualmente, o editor de texto GNU Emacs persiste com um exemplo do potencial de adaptabilidade de LISP. Emacs, por sinal, é uma das melhores opções de IDEs para LISP (o editor de texto de fato serve como IDE para LISP).

Para se obter documentação em LISP, pode-se consultar:

A documentação provida pela função describe(). Por exemplo, (describe 'string/=);
The Common Lisp HyperSpec, do LispWorks;
Manual do GNU Emacs. Embora o material não se aplique a todos os dialetos de LISP, muitas funções e _macros_ são similares.

Versões e Dialetos

LISP é uma linguagem antiga, com diversas ramificações. Por isso, deve-se escolher um dialeto para programar em LISP (ou uma linguagem derivada). LISP pode ser uma linguagem interpretada ou compilada, dependendo do uso e/ou do dialeto escolhido.

Como mencionado em LISP Como Primeira Linguagem de Programação, alguns dialetos podem ser mais simples e acessíveis para pessoas iniciantes.

Esta página adota Common Lisp (CL) para exemplos e interpretadores (ou compiladores). Opções de interpretadores/compiladores para Common Lisp incluem:

Steel Bank Common Lisp (SBCL);
GNU CLISP;
Clozure CL (CCL);
Armed Bear Common Lisp;
Allegro CL;
LispWorks;
Embeddable Common-Lisp (ECL), para uso como scripting em outras linguagens de programação.

Qualquer opção é válida para aprender LISP. Contudo, algumas opções (como Allegro CL) são pagas. Assim, SBCL, CLISP, CCL e LispWorks (Personal Edition) são boas escolhas para começar a programar usando a linguagem. ECL normalmente é usando como interpretador dentro de um programa escrito em outra linguagem de programação (algo que pode ser feito com Lua e Python); logo, é uma opção mais complexa para iniciantes.

Considerações Adicionais

O restante do texto assume o uso de Common LISP e SBCL, embora os exemplos possivelmente funcionem com outras opções. Além disso, alguns exemplos não apresentam as formas mais idiomáticas para programação em LISP. Para evitar introduzir conceitos mais complexos, alguns deles (por exemplo, para repetições) estão mais próximos de código procedural que funcional.

Interpretador e Editor de Texto

Deve-se usar contas de root ou de administrador apenas para instalar o interpretador. Após instalá-lo, use uma conta de usuário comum, sem privilégios mais altos, para usar o interpretador e programar.

Linux

Distribuições Linux comumente permitem a instalação de diferentes implementações para Common Lisp, como SBCL, CLISP, CCL e ECL.

Arch Linux:
```
pacman -S sbcl
```
Debian, Ubuntu ou distribuições baseadas nas anteriores:
```
apt-get install sbcl
```
Fedora:
```
dnf install sbcl
```

Gentoo:

emerge --ask dev-lisp/asdf
emerge --ask dev-lisp/sbcl

macOS

Em ambientes macOS, pode-se usar brew para instalar SBCL.

Windows

Para obter o Steel Bank Common Lisp (SBCL), deve-se acessar a página de downloads e escolher a opção para Windows. Em sistemas 32-bit, deve-se escolher X86. Em sistemas 64-bit, pode-se escolher AMD64 (isso é válido tanto para processadores AMD, quando para Intel; AMD64 é o nome da arquitetura de 64-bit).

No dia da escrita desta página, a última versão era 2.1.9 newest.

Após a instalação, o comando sbcl para iniciar Common LISP deverá estar disponível no PATH. Para testar, inicie uma sessão de terminal cmd, digite sbcl, depois aperte enter.

Caso não funcione, também é possível iniciar o interpretador pelo menu Iniciar. Basta procurar por sbcl.

Caso queira adicionar o interpretador ao PATH, consulte instalação de programas.

Alternativas para instalar o interpretador em Windows incluem:

Scoop;
Usar um IDE com o interpretador integrado (por exemplo, Emacs com SLIME usando Portacle).

Teste de Ambiente

Com o interpretador instalado, pode-se começar a programar em Common LISP. Para iniciar o interpretador, use o arquivo executável obtido ou digite sbcl seguido por enter em um interpretador de linha de comando (requer configuração de PATH para arquivos baixados manualmente).

sbclThis is SBCL 2.1.9, an implementation of ANSI Common Lisp.
More information about SBCL is available at <http://www.sbcl.org/>.

SBCL is free software, provided as is, with absolutely no warranty.
It is mostly in the public domain; some portions are provided under
BSD-style licenses.  See the CREDITS and COPYING files in the
distribution for more information.
*

Assim como feito para JavaScript e Python, esta seção apresentará os mesmos exemplos para fins de teste e comparações entre linguagens.

Como em Python, deve-se digitar o código em linguagem LISP após o asterisco (*).

Por exemplo, para se escrever no console, pode-se usar princ() (documentação). Para escrever uma mensagem, escreva algo como (princ "Olá! Meu nome é Franco.") após o asterisco e aperte enter. O interpretador escreverá Olá! Meu nome é Franco. e aguardará seu próximo comando.

sbclThis is SBCL 2.1.9, an implementation of ANSI Common Lisp.
More information about SBCL is available at <http://www.sbcl.org/>.

SBCL is free software, provided as is, with absolutely no warranty.
It is mostly in the public domain; some portions are provided under
BSD-style licenses.  See the CREDITS and COPYING files in the
distribution for more information.
* (princ "Olá! Meu nome é Franco.")Olá! Meu nome é Franco.
"Olá! Meu nome é Franco."
*

Exemplo de início e uso do interpretador SBCL na linha de comando. Usa-se `sbcl` para iniciar o interpretador; dentro dele, escreve-se o código desejado. A imagem apresenta exemplos de execução do código desta seção.

Doravante, toda vez que você ler um bloco de código em Common Lisp e quiser executá-lo manualmente no interpretador, basta seguir os passos anteriores.

Para encerrar o interpretador, digite (exit) seguindo de enter ou aperte Ctrl d. No Windows, o atalho pode ser Ctrl z seguido de enter (ou pode não funcionar, exigindo o uso de (exit)).

Assim como Python, pode-se usar LISP em modo Read, Eval, Print, Loop (REPL). Para operações matemáticas, deve-se lembrar de usar a notação infix. Por exemplo, = 1 + 1.

(+ 1 1)

Da mesma forma, você poderia escrever diretamente uma cadeia de caracteres:

"Olá! Meu nome é Franco."

Entretanto, deve-se notar que, assim como em Python, os usos diretos anteriores são possíveis apenas no interpretador para uso interativo, ou seja, no estilo REPL. Eles são convenientes para inspecionar valores e variáveis, mas não são permitidos em programas. Caso queira fazer o mesmo em um arquivo com código-fonte (um script), você deve usar princ() para escrever os resultados.

(princ (+ 1 1))
(princ "Olá! Meu nome é Franco.")

Portanto, convém criar o hábito de usar (princ) quando quiser escrever no console. Por exemplo, crie um arquivo chamado script.lisp (você pode escolher o nome que quiser) com o seguinte conteúdo:

(princ "Meu Primeiro Script em Lisp")
(terpri)
(princ "Olá! Meu nome é Franco.")
(terpri)
(princ "O interpretador saber fazer contas.")
(terpri)
(princ "Veja só: ")
(princ (+ 1 1))
(terpri)
(princ "Tchau!")
(terpri)

O script introduz uma nova função, chamada terpri() (documentação), que adiciona uma quebra de linha.

Para executar seu script, abra um interpretador de linha de comando (shell) no diretório em que ele foi criado e digite lisp --script script.lisp. O interpretador LISP executará o arquivo fornecido como parâmetro (o valor script.lisp após sbcl --script) e mostrará os resultados de chamadas de princ().

sbcl --script script.lispMeu Primeiro Script em Lisp
Olá! Meu nome é Franco.
O interpretador saber fazer contas.
Veja só: 2
Tchau!

Caso o diretório atual no interpretador de linha de comando (shell) não seja o diretório do arquivo, você pode mudar para o diretório do arquivo ou pode escrever o caminho absoluto do arquivo. Exemplos de caminho absoluto poderiam ser C:\Users\Franco\Desktop\script.lisp para um arquivo na área de trabalho do Windows em uma conta de usuário chamada Franco ou ~/Desktop/script.lisp para um arquivo na área de trabalho do Linux.

Execução do arquivo `script.lisp` na linha de comando. A imagem ilustra o comando utilizado (`sbcl --script script.lisp`) e os resultados da execução do programa.

Escrever terpri() toda vez que se quiser pular uma linha pode ser inconveniente. Uma alternativa é usar a função format() (documentação).

(format t "Meu Primeiro Script em Lisp~%")
(format t "Olá! Meu nome é Franco.~%")
(format t "O interpretador saber fazer contas.~%")
(format t "Veja só: ~d~%" (+ 1 1))
(format t "Tchau!")
(terpri)

No caso, ~% permite adicionar uma quebra de linha, enquanto ~d permite escrever um número inteiro calculado como resultado. Caso você desejasse, também seria alterar a última linha para (format t "Tchau!~%"). O restante dos exemplos alternará entre os usos de princ() e format().

Por fim, é conveniente saber que é possível consultar a documentação sobre uma função usando o REPL. Para isso, pode-se usar a função describe().

(describe 'format)COMMON-LISP:FORMAT
  [symbol]

FORMAT names a compiled function:
  Lambda-list: (DESTINATION CONTROL-STRING &REST FORMAT-ARGUMENTS)
  Declared type: (FUNCTION
                  ((OR STRING BOOLEAN STREAM) (OR STRING FUNCTION)
                   &REST T)
                  (VALUES (OR STRING NULL) &OPTIONAL))
  Derived type: (FUNCTION (T T &REST T) *)
  Documentation:
    Provides various facilities for formatting output.
      (...)

Saber usar REPL e executar um arquivo com código LISP bastam para atividades de aprendizado. De forma geral, elas também são suficientes para a maioria das atividades para uso cotidiano ou profissional da linguagem de programação.

IDEs

As considerações feitas sobre o uso de IDE para Python valem para LISP. A conveniência, sobretudo importante para iniciantes, continua a ser um benefício do uso de IDEs.

A opção de executar código com um clique também vale para LISP. Em particular, procure pela opção de executar um projeto com um clique (normalmente sobre um ícone de triângulo (🢒) comumente usado como play, tocar ou reproduzir em eletroeletrônicos) ou com uma tecla (comumente F5). Além disso, lembre-se de atalhos para editores de texto, como Ctrl n para criar novos arquivos (Arquivo / Novo ou File / New em inglês) e Ctrl o (Arquivo / Abrir ou File / Open em inglês) para abrir arquivos existentes.

Emacs com SLIME

O editor de texto GNU Emacs foi apresentado anteriormente. Em particular, Emacs é o editor de texto que eu uso (esta página foi escrita usando ele).

Embora eu não recomende o uso de Emacs por iniciantes, o editor é uma das melhores opções para programar em LISP. A combinação de Emacs com Superior Lisp Interaction Mode for Emacs SLIME, e um interpretador/compilador LISP (como SBCL) é excelente para programar na linguagem. Para LISP, Emacs é um IDE. Inclusive, Emacs define um dialeto próprio de LISP para configuração e adaptação do editor, chamado de Emacs Lisp.

Para iniciantes em LISP que desejem usar Emacs, eu recomendaria optar por Portacle (inclui SBCL) ou Lispbox (inclui CCL) como opções prontas para uso. Ambas as opções incluem um interpretador/compilador e configurações pré-definidas para programação em Common LISP. Das duas opções, Portacle é a mais recente e atualizada.

Portacle

O painel inferior de Portacle fornece uma sessão REPL para LISP. Assim, caso queira, é possível digitar comandos e avaliá-los. Por exemplo, pode-se testar o REPL usando (princ "Olá, meu nome é Franco!").

Para executar um arquivo usando Portacle:

Clique File, depois Visit New File...;
Escolha o caminho para o arquivo. Para voltar ao diretório anterior, você pode digitar ... Após escolher o caminho (diretório, nome de arquivo e extensão), aperte enter;
Digite o código-fonte;
Salve o arquivo: File, depois Save;
Selecione o texto com o código que você quer executar;
Clique em SLIME, acesse Evaluation, depois escolha Eval Region.

A seleção de texto com código é um recurso interessante de LISP. Ao invés de executar um arquivo todo, pode-se executar apenas partes de um programa, dependendo da seleção.

Evidentemente, também é possível executar todo um script (como em outras linguagens de programação). Para executar o arquivo inteiro de uma vez, é possível apertar Ctrl c, depois Ctrl k. Na terminologia do Emacs, escreve-se C-c C-k.

Exemplo de uso de `Portacle` para programação em LISP.

Caso queira usar atalhos usuais para editores de texto ao invés das convenções do Emacs:

Clique em Options;
Escolha Use CUA Keys.

Deve-se observar, entretanto, que o uso de CUA modificará o atalho para executar o arquivo aberto. Caso o atalho mude, uma alternativa é digitar Alt x (na terminologia do Emacs, Meta x ou M-x), em seguida escrever slime-compile-and-load-file e apertar enter.

Para aprender um pouco sobre as convenções, pode-se acessar a ajuda presente na documentação do Portacle.

LispBox

LispBox funciona de forma semelhante ao Portacle. Assim como Portacle, LispBox utiliza Emacs; porém, trata-se de uma versão mais antiga.

Para aprendizado, pode-se escolher tanto um quanto outro. Logo, a escolha mais apropriada tende a ser Portacle, por ser mais recente.

LispWorks

Embora LispWorks seja pago para uso profissional, a versão Personal Edition é gratuita para uso pessoal (embora limitada). Uma vantagem de LispWorks Personal Edition é a facilidade para começar a programar em LISP (especialmente em sistemas Windows). Após a instalação, o programa estará pronto para uso.

Como Emacs é um editor que requer esforços para aprendizado, LispWorks Personal Edition pode ser uma escolha mais simples para iniciar programação em LISP sem maiores complicações.

LispIDE

Uma alternativa ao IDE LispWorks para Windows chama-se LispIDE. Para obter as versões mais recentes, deve-se acessar a página de downloads no GitHub.

Caso queira usá-lo, deve-se, primeiro, instalar um interpretador/compilador para LISP (como SBCL para Windows). No primeiro uso, deve-se fornecer o diretório de instalação para LISP. Para a instalação 64-bit (AMD64), o diretório padrão é C:\Program Files\Steel Bank Common Lisp.

Exemplo de configuração de interpretador/compilador no primeiro uso de `LispIDE`.

Para executar uma linha de código LISP no arquivo aberto, o cursor deve estar após um parênteses. Em seguida, deve-se escolher Edit, depois Send to Lisp (ou apertar Shift Enter).

Exemplo de uso `LispIDE` para programação em LISP.

Eclipse com Dandelion

O IDE Eclipse (previamente citado para Java)) também pode ser usado para programação LISP usando o plugin Dandelion. Dandelion fornece SBCL e CLISP integrados. Assim, basta instalar o plugin para começar a programar em Common LISP.

Outras Opções

Para outras opções de IDEs, pode-se instalar extensões em alguns programas.

Visual Studio Code com Alive;
Atom com SLIMA.

Primeiros Passos para Começar a Programar em LISP

Os trechos de código a seguir ilustram alguns recursos da linguagem LISP. Neste momento, não é necessário entendê-los totalmente; o propósito é apresentar recursos e a sintaxe da linguagem.

Existem três formas de usar o código. Você pode:

Digitar (ou copiar e colar) o código diretamente em no interpretador da linguagem;
Escrever e executar o código no IDE de sua escolha;
Escrever o código usando um editor de texto e executar o arquivo criado no interpretador.

Os exemplos são os mesmos adotados para JavaScript. Logo, você poderá comparar linguagens, e observar semelhanças e diferenças entre elas.

Conhecendo LISP por Meio de Experimentação

Exemplos de uso e saídas dos trechos de código apresentados nesta seção utilizando o interpretador `sbcl` para LISP na linha de comando.

Escrita de texto:

(princ "Uma linha.")
(terpri)
(format t "Outra linha.~%")
(princ "Uma linha.\nOutra linha.")
(terpri)

Comentários (texto ignorado pelo interpretador; documentação):

(princ "Interpretador processa") ;; Interpretador ignora.
(terpri)

#| <- Aqui começa o comentário.
Ele pode ter várias linhas.
Aqui ele termina -> |#

#| Ele também pode começar e terminar na mesma linha. |#

;; Contudo, para isso, é mais fácil usar este estilo de comentário.

Também é possível criar um comentário usando um único ponto-e-vírgula (;). Comentários com apenas um são alinhados à direita.

Cálculos matemáticos:

Soma, subtração, multiplicação e divisão (documentação):

(princ (+ 1 1))
(terpri)
(format t "~d~%" (- 2 2))
(format t "~d~%" (* 3 3))
(format t "~d~%" (/ 4 4)) ;; O que ocorre caso se tente dividir por 0? Faça o teste!

Expressões matemáticas:

(format t "~F~%" (+ 1 (- 2 3) (* 4 (/ 5 6.0))))
(terpri)

Potenciação (documentação):
```
(princ (expt 5 2))
(terpri)
```

Raiz quadrada (documentação: sqrt()):
```
(princ (sqrt 25))
(terpri)
```
Operações trigonométricas, como seno (documentação: sin() e pi):
```
(princ (sin (/ pi 2.0))) ;; Seno.
(terpri)
```

Comparações (t significa verdadeiro; nil significa falso):

Igualdade (documentação; strings):

(princ (= 1 2)) ;; Igual.
(terpri)
(format t "~d~%" (/= 1 2)) ;; Diferente.

(format t "~d~%" (string= "Franco" "Franco"))
(format t "~d~%" (string/= "Franco" "Franco"))
(format t "~d~%" (string/= "Franco" "Seu Nome"))
;; LISP considera que letras minúsculas são diferentes de maiúsculas (e vice-versa).
(format t "~d~%" (string= "F" "f"))
(format t "~d~%" (string/= "F" "f"))
(format t "~d~%" (string= "Franco" "franco"))
(format t "~d~%" (string/= "Franco" "franco"))

Outras comparações (documentação):

(format t "~d~%" (< 1 2)) ;; Menor.
(format t "~d~%" (> 1 2)) ;; Maior.
(format t "~d~%" (<= 1 2)) ;; Menor ou igual.
(format t "~d~%" (>= 1 2)) ;; Maior ou igual.

Variáveis e atribuição (documentação: defvar(); setq()):

Variáveis são como caixinhas que armazenam valores colocados dentro delas. Efetiva-se um armazenamento usando o operador de atribuição, que é feita com setq() em LISP. A declaração de variáveis é feita usando defvar().

(defvar x 123)
(princ x)
(terpri)

(defvar resultado (+ 123.456 987.654))
(princ resultado)
(terpri)

Deve-se notar que a declaração de variáveis pode ser feita uma única vez por nome escolhido. Entretanto, pode-se mudar seu valor quantas vezes forem necessárias.

(defvar nome "Franco")
(format t "~d~%" nome)
(setq nome "Franco Garcia")
(format t "~d~%" nome)

(defvar variaveis_podem_variar "Franco")
(format t "~d~%" variaveis_podem_variar)
(setq variaveis_podem_variar "Seu Nome")
(format t "~d~%" variaveis_podem_variar)
(setq variaveis_podem_variar "Outro Nome")
(format t "~d~%" variaveis_podem_variar)

(defvar valor_logico t)
(format t "~d~%" valor_logico)
(setq valor_logico nil)
(format t "~d~%" valor_logico)
(setq valor_logico (= (+ 1 1) 2))

Constantes (documentação):

(defconstant _PI 3.14159)
(format t "~d~%" _PI)

(defconstant E 2.71828)
(format t "~d~%" E)
(setq E 0) ;; Erro; o valor de uma constante é inalterável após definido.

Erros:

(princ Ooops!) ;; Texto deve estar entre aspas duplas, simples, ou pares de colchetes de cada lado.
(pri "Nome incorreto para princ")
(princ (/ 1 0))
(princ (/ 0 0))

Cadeias de caracteres (strings) para palavras e texto (documentação):

(format t "Ok, cadeia de caracteres válida~%")
(format t "Ok, outra cadeia de caracteres válida~%")
(format t "Ok, também é uma cadeia de caracteres válida~%")

(format t "Para 'misturar' aspas, use diferentes das externas.~%")
(format t "Caso contrário, você precisa escapá-las com uma contrabarra, assim: \". A contrabarra é necessária.~%")

Operações lógicas (documentação):

(format t "~d~%" (and t t)) ;; Operação lógica "e" ("and").
(format t "~d~%" (or t nil)) ;; Operação lógica "ou" ("or").
(format t "~d~%" (not t)) ;; Operação lógica "não" ("not").

Condições (documentação):

(defvar navegador "Firefox")
(if (string= navegador "Firefox")
    (princ "Mozilla Firefox."))
(terpri)

(defvar meu_navegador "Seu Navegador")
(if (string= meu_navegador "Firefox")
    (princ "Você usa um navegador da Mozilla.")
  (princ "Você usa outro navegador."))
(terpri)

(defvar eu_uso "firefox")
(setq eu_uso (string-downcase eu_uso))
(if (string= eu_uso "firefox")
    (princ "Você usa um navegador da Mozilla.")
  (if (or (string= eu_uso "chrome") (string= eu_uso "chromium"))
      (princ "Você usa um navegador do Google.")
    (if (string= eu_uso "edge")
        (princ "Você usa um navegador da Microsoft.")
      (if (string= eu_uso "safari")
          (princ "Você usa um navegador da Apple.")
        (if (string= eu_uso "internet explorer")
           (princ "Você deveria usar um navegador mais moderno...")
         (princ "Você usa outro navegador."))))))
(terpri)

Repetições ou laços (documentação):

(loop for i from 0 to 4 by 1 do
    (princ i)
    (terpri))

(defvar j 0)
(loop while (< j 5) do
    (princ j)
    (terpri)
    (incf j))

(defvar k 0)
(loop
    (princ k)
    (terpri)
    (incf k)
    (when (>= k 4) (return k)))

Funções (documentação):

(defun minha_funcao (x y)
    (let ((resultado (+ x y)))
        resultado))

;; Uma função é um bloco de código que realiza um processamento arbitrário
;; conforme definido pela programadora ou pelo programador.
;; Após a definição, pode-se executar a função quando se quiser, por meio
;; de uma chamada de função.
(defvar z (minha_funcao 12 -34)) ;; Este é um exemplo de uma chamada de função.
(princ z)
(terpri)
(princ (minha_funcao 1 2)) ;; Este é outro.
(terpri)

Tipos de dados (documentação):

(defvar numero_inteiro 1)
(defvar outro_numero_inteiro -1)
(defvar numero_real 1.23)
(defvar valor_logico t) ;; ou nil; só pode ser t ou nil.
(defvar cadeia_caracteres "Texto aqui. Quebras de linha usam\nou seja, isto estará\n na terceira linha.")

Entrada (documentação: read-line(), parse-integer(), e finish-output()):

Para usar este exemplo em REPL, deve-se digitar (ou copiar e colar) uma linha de código por vez. Isso é necessário devido ao uso de read-line(), que solicitará a entrada de um valor. Deve-se digitar um valor e pressionar-se enter para enviá-lo ao interpretador. Caso defina um script, isso não é necessário; o arquivo pode armazenar todo o código para o programa.

;; Quando se solicitar a entrada de um valor, escreva um e aperte `enter`.
(princ "Qual é o seu nome? ")
(finish-output)
(defvar seu_nome (read-line))
(princ "Quantos anos você tem? ")
(finish-output)
(defvar sua_idade (parse-integer (read-line)))
(princ seu_nome)
(terpri)
(princ sua_idade)
(terpri)
;; A função concatenate() realiza uma operação chamada concatenação,
;; que combina a segunda cadeira após a primeira.
(princ (concatenate 'string' "Olá, " seu_nome "!"))
(terpri)
(format t "Você tem ~d anos." sua_idade)
(terpri)

Parabéns! Você Já Pode Escrever Qualquer Programa em LISP

Não acredita? Você pode encontrar a explicação na introdução à linguagem JavaScript.

Em resumo, aprender a sintaxe de uma linguagem não é suficiente para resolver problemas com ela. O aprendizado de lógica de programação e o desenvolvimento de habilidades de pensamento computacional são muito mais importantes que a sintaxe. De fato, quando se tem dúvidas sobre a sintaxe, basta consultar a documentação. Não é preciso decorá-la.

Após aprender uma primeira linguagem de programação, aprender outras linguagens (que adotem paradigmas semelhantes aos da primeira) é relativamente simples. Para constatar a afirmação, pode-se abrir uma nova janela em seu navegador e deixá-la lado a lado com esta. Em seguida, pode-se comparar os blocos de código escritos em LISP (nesta janela) e em Python (na segunda janela).

Caso se deseje fazer comparações entre mais linguagens de programação, pode-se escolher:

Próximos Passos

Com o ambiente de desenvolvimento configurado, você pode continuar sua jornada de desenvolvimento de sistemas.

Para evitar repetições, recomendo a leitura da página sobre configurações de ambiente para JavaScript. Mesmo que você não tenha interesse na linguagem, muitas discussões são relevantes para quaisquer linguagens de programação. Além disso, você entenderá uma forma de criar páginas para a Internet e poderá criar conteúdo para seu navegador.

Até GDScript (para Godot Engine), os tópicos descrevem configurações de ambientes de desenvolvimento para algumas linguagens de programação. Após GDScript, o foco torna-se conceitos básicos para o aprendizado de programação.

← Anterior:
Ambientes de Desenvolvimento: Configuração para Programação em Java

Próximo:→
Ambientes de Desenvolvimento: Configuração para Programação em Prolog