Lisp — guia de estudo

Leitura de 10 min

Guia técnico em Notas para estudar Lisp com calma. Encosta em Lua e em notas de programação como Demoscene.

1. O que é Lisp?

Lisp é uma família de linguagens de programação criada no fim dos anos 1950 por John McCarthy.
O nome vem de LISt Processing, ou seja, processamento de listas.

Lisp é uma das linguagens mais antigas ainda em uso e teve enorme influência em áreas como:

  • inteligência artificial;
  • programação funcional;
  • metaprogramação;
  • compiladores;
  • linguagens interativas com REPL;
  • garbage collection;
  • manipulação simbólica.

Quando alguém fala “Lisp”, pode estar se referindo a várias linguagens parecidas, como:

  • Common Lisp
  • Scheme
  • Clojure
  • Racket
  • Emacs Lisp

Lisp não é apenas uma linguagem específica. É uma ideia de linguagem.

2. A grande ideia de Lisp

A característica mais importante de Lisp é que código e dados têm praticamente a mesma estrutura.

Em muitas linguagens, código e dados são coisas bem separadas.
Em Lisp, o próprio código é escrito como listas.

Exemplo:

(+ 2 3)

Isso significa:

some 2 e 3

O resultado é:

5

Em Python, você escreveria:

2 + 3

Em Lisp, o operador vem primeiro:

(+ 2 3)

Esse estilo se chama notação prefixada.

3. Sintaxe básica

A sintaxe de Lisp é baseada em parênteses.

Uma expressão Lisp geralmente tem esta forma:

(função argumento1 argumento2 argumento3)

Exemplos:

(+ 1 2)

Resultado:

3
(* 4 5)

Resultado:

20
(- 10 3)

Resultado:

7
(/ 20 4)

Resultado:

5

Uma expressão pode conter outras expressões:

(* (+ 2 3) 4)

Primeiro:

(+ 2 3)

Resultado:

5

Depois:

(* 5 4)

Resultado final:

20

4. Listas

Listas são fundamentais em Lisp.

Exemplo de lista:

'(1 2 3 4)

O apóstrofo ' impede que Lisp tente executar a lista como código.

Sem o apóstrofo, Lisp pensaria que 1 é uma função:

(1 2 3 4)

Isso normalmente causaria erro.

Com o apóstrofo:

'(1 2 3 4)

Lisp entende que isso é dado, não código.

Outro exemplo:

'(maçã banana laranja)

Isso é uma lista de símbolos.

5. Código como dados

Aqui está a parte mais poderosa — e mais esquisita — de Lisp.

Este código:

(+ 2 3)

É também uma lista:

(+ 2 3)

Ou seja, o programa tem a mesma forma que os dados.

Isso permite que programas Lisp manipulem outros programas Lisp com muita facilidade.

Essa ideia é chamada de homoiconicidade.

Nome feio, ideia forte:

Em Lisp, código e dados usam a mesma representação básica.

Essa característica torna Lisp excelente para criar:

  • macros;
  • linguagens internas;
  • sistemas simbólicos;
  • ferramentas de programação;
  • interpretadores;
  • compiladores.

6. Funções

Em Common Lisp, uma função pode ser definida com defun.

Exemplo:

(defun quadrado (x)
  (* x x))

Isso cria uma função chamada quadrado.

Uso:

(quadrado 5)

Resultado:

25

Outro exemplo:

(defun soma (a b)
  (+ a b))

Uso:

(soma 10 20)

Resultado:

30

7. Condicionais

Lisp possui condicionais, como if.

Exemplo:

(if (> 10 5)
    "maior"
    "menor ou igual")

Resultado:

"maior"

A estrutura é:

(if condição
    valor-se-verdadeiro
    valor-se-falso)

Exemplo com função:

(defun positivo? (x)
  (if (> x 0)
      "positivo"
      "não positivo"))

Uso:

(positivo? 7)

Resultado:

"positivo"

8. Recursão

Lisp é muito associada à programação funcional e à recursão.

Recursão acontece quando uma função chama a si mesma.

Exemplo clássico: fatorial.

Matematicamente:

5! = 5 × 4 × 3 × 2 × 1

Em Lisp:

(defun fatorial (n)
  (if (= n 0)
      1
      (* n (fatorial (- n 1)))))

Uso:

(fatorial 5)

Resultado:

120

Como funciona:

(fatorial 5)
= 5 × (fatorial 4)
= 5 × 4 × (fatorial 3)
= 5 × 4 × 3 × (fatorial 2)
= 5 × 4 × 3 × 2 × (fatorial 1)
= 5 × 4 × 3 × 2 × 1 × (fatorial 0)
= 5 × 4 × 3 × 2 × 1 × 1
= 120

9. car, cdr e cons

Três operações clássicas de Lisp:

car

Pega o primeiro elemento de uma lista.

(car '(10 20 30))

Resultado:

10

cdr

Pega o restante da lista, sem o primeiro elemento.

(cdr '(10 20 30))

Resultado:

(20 30)

cons

Constrói uma nova lista colocando um elemento no começo.

(cons 5 '(10 20 30))

Resultado:

(5 10 20 30)

Essas funções são antigas, mas importantes para entender a mentalidade Lisp.

10. Macros

Macros são uma das armas mais fortes de Lisp.

Uma função comum recebe valores.

Uma macro recebe código, transforma esse código e devolve outro código.

Isso permite criar novas formas de expressão dentro da linguagem.

Exemplo conceitual:

(defmacro quando (condição &body corpo)
  `(if ,condição
       (progn ,@corpo)))

Uso:

(quando (> x 10)
  (print "x é maior que 10"))

Isso poderia ser transformado em algo como:

(if (> x 10)
    (progn
      (print "x é maior que 10")))

A ideia importante:

Macros permitem estender a linguagem usando a própria linguagem.

Isso é muito mais poderoso do que apenas criar funções.

11. REPL

Lisp é famosa pelo uso do REPL.

REPL significa:

Read
Eval
Print
Loop

Ou seja:

  1. lê uma expressão;
  2. avalia a expressão;
  3. imprime o resultado;
  4. repete o ciclo.

Isso permite programar de forma interativa.

Você escreve:

(+ 2 2)

O ambiente responde:

4

Esse modo de trabalho influenciou ambientes modernos de Python, JavaScript, Clojure, Racket e várias outras linguagens.

12. Dialetos importantes

Common Lisp

É um Lisp grande, poderoso e cheio de recursos.

Pontos fortes:

  • linguagem madura;
  • sistema de objetos;
  • macros poderosas;
  • alta performance possível;
  • boa para estudar Lisp clássico.

Pontos fracos:

  • comunidade menor;
  • ecossistema menos popular que Python ou JavaScript;
  • aparência inicial intimidadora.

Scheme

É um Lisp minimalista e elegante.

Pontos fortes:

  • ótimo para estudar fundamentos;
  • sintaxe pequena;
  • muito usado em cursos clássicos de ciência da computação.

Pontos fracos:

  • menos usado em sistemas comerciais;
  • várias implementações diferentes.

Clojure

É um Lisp moderno que roda principalmente na JVM.

Pontos fortes:

  • interoperabilidade com Java;
  • bom para sistemas reais;
  • forte em programação funcional;
  • usado em backend, dados e sistemas concorrentes.

Pontos fracos:

  • exige entender JVM para uso profissional;
  • sintaxe ainda assusta iniciantes;
  • curva de aprendizado não é trivial.

Racket

É descendente de Scheme e muito usado para ensino, pesquisa e criação de linguagens.

Pontos fortes:

  • excelente documentação;
  • bom ambiente para aprender;
  • ótimo para experimentar ideias de linguagens.

Pontos fracos:

  • mercado pequeno;
  • menos usado em empresas tradicionais.

Emacs Lisp

É o Lisp usado para configurar e estender o editor Emacs.

Pontos fortes:

  • permite personalizar profundamente o Emacs;
  • muito útil para quem usa Emacs.

Pontos fracos:

  • bem específico;
  • não é a melhor escolha como primeiro Lisp geral.

13. Por que estudar Lisp?

Você provavelmente não deve estudar Lisp achando que vai virar a linguagem principal do seu trabalho amanhã.

Essa expectativa é ruim.

O melhor motivo para estudar Lisp é outro:

Lisp melhora sua cabeça como programador.

Ela força você a entender:

  • funções como valores;
  • estruturas recursivas;
  • representação de código;
  • avaliação de expressões;
  • abstrações;
  • metaprogramação;
  • design de linguagens;
  • simplicidade sintática.

Aprender Lisp pode melhorar sua forma de programar em Python, JavaScript, Ruby, Elixir, Rust ou qualquer outra linguagem.

14. Pontos fortes

  • Sintaxe extremamente regular.
  • Macros muito poderosas.
  • REPL interativo.
  • Excelente para programação simbólica.
  • Influência histórica enorme.
  • Boa para aprender fundamentos profundos.
  • Código pode ser manipulado como dados.
  • Favorece abstrações fortes.

15. Pontos fracos

  • Pouco popular no mercado.
  • Ecossistema menor que Python, JavaScript ou Java.
  • Muitos parênteses assustam no começo.
  • Material moderno pode ser mais difícil de encontrar.
  • Algumas implementações têm ferramentas menos amigáveis.
  • Pode parecer “alienígena” para quem vem de linguagens imperativas.

A verdade brutal:

Lisp é intelectualmente poderosa, mas não é a escolha pragmática padrão para a maioria dos projetos comerciais modernos.

Isso não torna Lisp inútil. Só significa que você deve estudar com o objetivo certo.

16. Comparação rápida com Python

Python:

def quadrado(x):
    return x * x

Lisp:

(defun quadrado (x)
  (* x x))

Python:

if x > 10:
    print("maior")
else:
    print("menor ou igual")

Lisp:

(if (> x 10)
    (print "maior")
    (print "menor ou igual"))

Python usa sintaxe mais familiar.
Lisp usa uma sintaxe mais uniforme.

Essa uniformidade é o que torna macros e manipulação de código tão naturais em Lisp.

17. Exercícios básicos

Exercício 1

Escreva uma expressão Lisp que some 10, 20 e 30.

Resposta:

(+ 10 20 30)

Exercício 2

Escreva uma expressão que calcule:

(2 + 3) × 4

Resposta:

(* (+ 2 3) 4)

Exercício 3

Crie uma função que calcule o dobro de um número.

Resposta:

(defun dobro (x)
  (* x 2))

Uso:

(dobro 8)

Resultado:

16

Exercício 4

Crie uma função que diga se um número é maior que 100.

Resposta:

(defun maior-que-100? (x)
  (if (> x 100)
      "sim"
      "não"))

Exercício 5

Use car para pegar o primeiro item da lista:

'(a b c d)

Resposta:

(car '(a b c d))

Resultado:

a

18. Roteiro de estudo recomendado

Etapa 1 — Sintaxe básica

Estude:

  • expressões;
  • listas;
  • notação prefixada;
  • avaliação;
  • aspas com '.

Objetivo:

Conseguir ler código Lisp simples sem travar nos parênteses.

Etapa 2 — Funções

Estude:

  • defun;
  • parâmetros;
  • retorno;
  • composição de funções.

Objetivo:

Escrever pequenas funções matemáticas e utilitárias.

Etapa 3 — Listas

Estude:

  • car;
  • cdr;
  • cons;
  • listas aninhadas;
  • recursão sobre listas.

Objetivo:

Entender por que listas são tão centrais em Lisp.

Etapa 4 — Recursão

Estude:

  • fatorial;
  • Fibonacci;
  • soma de listas;
  • busca em listas.

Objetivo:

Parar de depender apenas de loops tradicionais.

Etapa 5 — Macros

Estude macros só depois de entender bem funções e listas.

Objetivo:

Entender como Lisp consegue modificar a própria linguagem.

Não tente aprender macros no primeiro dia. É pedir para sofrer à toa.

19. O que instalar para praticar

Algumas opções:

Para Common Lisp

  • SBCL
  • Quicklisp
  • Portacle

Para Scheme/Racket

  • Racket

Para Clojure

  • Clojure CLI
  • Leiningen
  • Babashka

Para começar, a escolha mais amigável costuma ser:

Racket, se o objetivo é aprender.
Common Lisp, se o objetivo é entender Lisp clássico.
Clojure, se o objetivo é usar ideias Lisp em sistemas modernos.

20. Conclusão

Lisp é uma linguagem de programação, mas também é uma forma diferente de pensar programação.

Ela não venceu o mercado de massa, mas influenciou quase tudo.

Estudar Lisp vale a pena porque ensina ideias profundas:

  • código como dados;
  • funções como blocos fundamentais;
  • avaliação simbólica;
  • macros;
  • abstração;
  • composição;
  • simplicidade estrutural.

Resumo final:

Lisp não é a linguagem mais popular.
Lisp não é a mais fácil para arrumar emprego.
Lisp não é a escolha óbvia para projetos comuns.
Mas Lisp é uma das melhores linguagens para expandir sua cabeça como programador.

21. Mini glossário

TermoSignificado
LispFamília de linguagens baseada em listas
ListaEstrutura central de dados em Lisp
S-expressionExpressão simbólica escrita com parênteses
REPLAmbiente interativo de leitura, execução e resposta
MacroCódigo que transforma código
HomoiconicidadeCódigo e dados compartilham representação parecida
carPrimeiro elemento de uma lista
cdrResto da lista
consCria uma nova lista adicionando um item no começo
Common LispDialeto robusto e clássico
SchemeDialeto minimalista
ClojureLisp moderno sobre a JVM
RacketDialeto educacional e experimental

22. Próximos passos práticos

  1. Instale Racket ou SBCL.
  2. Abra um REPL.
  3. Teste expressões simples.
  4. Escreva funções pequenas.
  5. Brinque com listas.
  6. Depois estude recursão.
  7. Só então entre em macros.

Não pule direto para macros.
Esse é o erro clássico de quem quer parecer avançado antes de entender o básico.