Lisp

Origem: Wikipédia, a enciclopédia livre.

O LISP é uma linguagem de programação funcional concebida por John McCarthy em 1958. Num célebre artigo este mostra que é possível usar exclusivamente funções matemáticas como estruturas de dados elementares (o que é possível a partir do momento em que há um mecanismo formal para manipular funções: o Cálculo Lambda de Church). Durante os anos de 1970 e 1980 o LISP se tornou a principal linguagem da comunidade de inteligência artificial, tendo sido pioneiro em aplicações como administração automática de armazenamento, linguagens interpretadas e programação funcional.

O seu nome vem de LISt Processing (a lista é a estrutura de dados fundamental desta linguagem). Tanto os dados como o programa são representados como listas o que permite que a linguagem manipule o código fonte como qualquer outro tipo de dados.

Existem diversos dialetos de Lisp, sendo os mais conhecidos o Common Lisp e o Scheme.

[editar] História

O LISP (List Processing) foi criada por John McCarthy na década de 50 enquanto estava no MIT.

O LISP foi influenciado pelo Cálculo Lambda de Alonzo Church nos anos 40, que permite através da chamada abstracção-lambda a manipulação formal de funções matemáticas. Além de servir de base ao LISP, teve um papel fundamental na formulação da conjectura de Church-Turing, sobre o conceito de computabilidade abstracta, e tem aplicações fundamentais em estudos de semântica formal das línguas naturais e de programação.

[editar] Implementação das Listas

Em termos práticos em LISP temos 2 estruturas de dados: o átomo e a lista; o átomo pode ser numérico, ou alfanumérico. Exemplos de átomos: atomo1 a 12 54 bola nil O átomo nil representa o valor nulo e ao mesmo tempo representa uma lista vazia. A lista é a associação de átomos ou outras listas (numa lista chamamos de elementos a cada um dos itens) representandos entre parêntesis. Exemplo de lista: (esta lista contém 5 átomos) ( (jose (22 solteiro)) (antonio (15 casado) ) )

Normalmente a implementação de uma lista é um encadeamento de átomos e cada átomo é representado como um par separado por um ponto onde o primeiro elemento é um ponteiro para o conteúdo do átomo e segundo elemento é um ponteiro para o próximo elemento da lista;

  [   .   ]
    |   |
    |   +---- ponteiro para o elemento seguinte da lista (quando for o último aponta para nil)
    +-------- ponteiro para o conteúdo do elemento 

  [   .   ] +->[   .   ] +->[   .   ] +->[   .   ] +->[   .   ]
    |   |   |    |   |   |    |   |   |    |   |   |    |   |
    |   +---+    |   +---+    |   +---+    |   +---+    |   +--> nil
   esta        lista        contem         5          atomos

Avaliação dados: os átomos quando avaliados retornam eles mesmos. As listas, quando avaliadas, são funções, onde o primeiro elemento representa o nome da função e os elementos seguintes são os argumentos para esta função. Exemplos de função: (+ 3 4)
> 7
(* 5 (+ 2 5))
> 35
(car (quote a b))
> a

Normalmente é mais fácil encontrar interpretadores LISP do que compiladores. Os exemplos acima apresentam o resultado interativo das funções. Como pode ser visto também, um programa LISP pode facilmente confundir um programador porque para cada parêntesis aberto deve haver o seu fechamento, o que criou o trocadilho para o nome da linguagem (LISP = Lots of Irritant Stupid Parenthesis - Um mundo de parênteses irritantes estúpidos).

[editar] Funções

(quote atomo1 atomo2 ... ) ==> Retorna um átomo (quando tem somente 1 argumento) ou uma lista a patir dos átomos. Esta função normalmente tem uma abreviação utilizando-se do apóstrofe. (quote jose silva) <==> '(jose silva)

(car lista) ==> Retorna o primeiro elemento da lista. Ex: (car '(jose silva)) retorna jose. Nas implementações mais recentes o LISP foi padronizado pela ISO e esta função foi duplicada como nome de first.

(cdr lista) ==> Retorna a lista sem o primeiro elemento. Ex: (cdr '(jose da silva)) retorna (da silva). Novo nome desta função rest.

(cons atomo lista) ==> Adiciona átomo ao início da lista. Ex: (cons 'jose '(da silva)) retorna (jose da silva).

Funções matemáticas
+ --> Adição
- --> Subtração
* --> Multiplicação
/ --> Divisão

[editar] Macros

O grande diferencial do LISP são as macros. As macros do LISP são completamente diferentes das que se encontram em C, pois estas somente fazem substituição de texto, enquanto que no LISP as macros são programas que geram programas.

[editar] Uso do LISP

O LISP foi utilizado para desenvolver o primeiro sistema computacional de matématica simbólica, o MACSYMA.

Ele também é utilizado como linguagem de extensão do software de CAD AutoCAD, desenvolvido pela AutoDesk. O editor de textos Emacs também utiliza o LISP como linguagem de extensão, segundo o seu próprio autor, Richard Stallman, o LISP que fez com que o Emacs se tornasse tão popular pois o fato da linguagem de extensão dele ser tão poderosa permite que ele seja extendido muito além do que se imaginava que ele originalmente poderia fazer.

A ITA software desenvolveu um sistema de reserva de passagens chamado Orbitz em LISP, ele é utilizado por diversas companhias aéreas. A Simbolics criou um sistema de modelagem 3D que depois foi adquirido pela IZWare e atualmente se chama Mirai, ele foi utilizado nos efeitos do filme Senhor dos Anéis.

O LISP foi utilizado pelo Paul Graham para desenvolver o sistema de e-commerce da viaweb, que posteriormente foi vendido para o Yahoo por US$ 40 milhões, na época da bolha da internet.

[editar] Exemplos de código

[editar] Expressões Lambda

((lambda (arg) (+ arg 1)) 5)

Resultado: 6

[editar] Fatorial

(defun factorial (n)
  (if (<= n 1)
      1
      (* n (factorial (- n 1)))))

[editar] Ligações externas

• http://www-formal.stanford.edu/jmc/history/lisp/lisp.html
• http://www-formal.stanford.edu/jmc/lisp20th/lisp20th.html
• http://www.gigamonkeys.com/book/
• http://www.paulgraham.com/onlisp.html
• http://www.lisp.com.br/
• Linguagem LISP (em Common Lisp)
• Introdução à Linguagem Lisp
• Grupo de usuários no Brasil