27 de jul de 2012

Common Lisp

    Lisp é uma linguagem de programação funcional, inventada por John McCarthy em 1958.  Houve uma época que existiam muitos dialetos Lisp, mas hoje em dia o mais usado é o Common Lisp e o Scheme.
     Common Lisp é uma implementação do Lisp. É uma linguagem funcional (prioriza as funções) e procedural (enfatiza as mudanças de estados do programa), com usos convencionais e na IA. Foi criada por Guy L. Steele  nos anos 80 com a finalidade de combinar os diversos dialetos Lisp e torná-los compatíveis. 
    O Lisp tem uma sintaxe simples, clara e simétrica. Ele usa parênteses para organizar os códigos numa lista!!

  • Instalando o CLisp:
 O CLisp é uma implementação do Common Lisp criada por Bruno Haible.  Para instalar o CLisp você pode fazer o download no site http://www.clisp.org/ ou usar o comando apt-get install clisp.

  • Definindo variáveis:
As variáveis podem ser definidas pelas funções:
(defparameter *variavel* 1)     "Define uma variável global"
(let ((a 5)       "define uma variável local"
        (b 6))
       (+ a b))
> 11

  • Definindo Funções:
(defun triplo (x)     "o defun define uma função global"
(* 3 x))
TRIPLO
(triplo 5)
> 15
(flet ((somar-dois (n)     "o comando flet define uma função local"
                             ( + n 2)))
(somar-dois 5))
>  7

  • Listas, Car e Cdr:
     Todas as expressões no Lisp são em forma de listas, até mesmo as funções. 
'(1 2 3 4 5 6 7)
'(comprei 1 2 3 4 5 6 7 quatis)

    A aspas simples são tratadas como dados no Lisp, então é exibida apenas uma lista!!
    O cons cell é um elemento da lista. É um espaço na memória que armazena 2 endereços.
> (cons 1 2)
(1 . 2)


     A função cons armazena dois espaços na memória: No exemplo, o 1 fica na primeira parte e o 2 na outra. A primeira parte é chamada car (constents of the address part of the register) e a parte que guarda o valor 2 é chamada de cdr (constents of the decrement part of the register).




  • Funções sobre pares e listas:
cons: constrói um par.
consp: verifica se o objeto é um par.
car: retorna o primeiro elemento do par.
cdr: retorna o segundo elemento do par.
caar, caaar, etc: composição de car com car. (caar x) = (car (car x))
cadr, caadr, etc: composição de car com cdr. (caadr x) = (car (car (cdr x)))


    Vamos supor que fugiram 3 quatis e que precisamos localizá-los na lista:
(cadr '(comprei 1 2 3 4 5 6 7 quatis))
> 1
(caddr '(comprei 1 2 3 4 5 6 7 quatis))
> 2
(cadddr '(comprei 1 2 3 4 5 6 7 quatis))
> 3

  • Expressões Condicionais:
   A expressão condicional assume a forma de "se...então...caso constrário...". Nessa situação, a função usada é chamada de predicado e o valor do teste é interpretado como sendo verdadeiro ou falso. Toda lista vazia é interpretada como falso, onde o vazio é representado por NIL ou (). * O nil, 'nil, (), '() são a mesma coisa no Lisp.
   Essas expressões permitem escolher entre várias alternativas. Em Lisp os mais usados são o IF e o COND. 
> (if (= (+ 2 2) 5)
         'Yep         
"verdadeiro"
         'Nope)     
"falso"
NOPE

> (if '(3)
'lista-com-alguma-coisa
'lista-vazia)

LISTA-COM-ALGUMA-COISA 
> (if '()
       'verdadeiro
       'falso)
FALSO

  • Imprimindo Texto:
> (print "Zeldani")
"Zeldani"
"Zeldani"
> (princ "Zeldani")    "Para imprimir uma string é usado o comando princ."
Zeldani
"Zeldani" 
   "é repetido a string pois ele mostra o resultado da expressão validada"

     Para imprimir textos de uma maneira mais complicada, use o format
> (format t "lista: ~S~%e um inteiro: ~D~%")     " o T especifica a saída do terminal, o diretivo: ~S~ aceita qualquer objeto, ~D~ aceita inteiros e ~% é o valor retornado."
> (list 1 2 3 4 5) 6)
lista: (1 2 3 4 5)
e um inteiro: 6
NIL  
"o format sempre retorna NIL, exceto se o primeiro argumento for NIL"

  • Hello-World usando Shebangs:
     O shebangs é uma sequência de caracteres (#!) no início do script. Nos sistemas Unix, quando um script com shebangs é executado como um programa, ele vai passar o resto do script depois do shebangs como um interpretador. Por exemplo:  #!/bin/bash no inicio do código permite que seja executado no terminal "./hello.cl", através do shell Bash. Salve o exemplo abaixo como hello.cl:

#!/bin/bash
#|
exec clisp -q -q $0 $0 ${1+"$@"}
exit
|#
(defun hello-world()
  (format t "Hello, Lisp World!~%")
  (quit))
(hello-world)
 

E execute:
$ chmod +x hello.cl
$ ./hello.cl
Hello, Lisp World!

    Essa foi uma breve apresentação sobre o Common Lisp!! Em caso de dúvidas, sugestões ou reclamações postem um comentário!!! ;)


 * Fontes:
Land of Lisp - Conrad Barski
http://www.franz.com/support/documentation/8.2/ansicl/dictentr/carcdrca.htm
http://www.shido.info/lisp/scheme3_e.html 
http://pt.scribd.com/doc/95068620/Lisp
http://www.dca.ufrn.br/~adelardo/lisp/
http://speely.wordpress.com/2010/11/27/writing-scripts-with-common-lisp/
http://rosettacode.org/wiki/Multiline_shebang
http://www.n-a-n-o.com/lisp/cmucl-tutorials/LISP-tutorial-8.html

0 comentários:

Postar um comentário