Lisp

De Wikipedia, la enciclopedia libre

**Lisp**
Paradigma:	multiparadigma: orientado a objetos, funcional, declarativo
Apareció en:	1958
Diseñado por:	John McCarthy
Tipo de dato:	fuerte, dinámico
Implementaciones:	múltiples
Dialectos:	Common Lisp, Scheme, Emacs Lisp
Ha influido:	Smalltalk, CLOS, Dylan, Perl

Lisp es el segundo lenguaje de programación, después de Fortran, de alto nivel. Lisp es de tipo declarativo y fue creado por John McCarthy y sus colaboradores en el MIT.

Tabla de contenidos

1 Listas
2 Ejemplos
- 2.1 Grandes valores de la Función de Ackermann
3 Enlaces externos
- 3.1 Aplicaciones en Lisp
- 3.2 Compiladores de Lisp

[editar] Listas

El elemento fundamental en Lisp es la lista, en el sentido más amplio del término, pues tanto los datos como los programas son listas. De ahí viene su nombre, pues Lisp es un acrónimo de "LIStProcessing".

Los lenguajes de este tipo se llaman "aplicativos" o "funcionales", porque se basan en la aplicación de funciones a sus datos.

En Lisp se distinguen dos tipos fundamentales de elementos:

Átomos: son datos elementales y pueden pertenecer a varios tipos: números, caracteres, cadenas de caracteres y símbolos.
Listas: son secuencias de átomos o de listas encerradas entre paréntesis. Además, existe una lista especial, "nil", que es la lista nula, que no tiene ningún elemento.

En Lisp, una función se expresa como una lista.

Algunas de las funciones predefinidas de Lisp tienen símbolos familiares (+ para la suma, * para el producto), pero otras son más exóticas, especialmente dos que sirven precisamente para manipular listas, descomponiéndolas en sus componentes. Sus nombres ("car" y "cdr") son un poco extraños(1), reliquias de tiempos pasados y de la estructura de los ordenadores de segunda generación, "car" devuelve la cabeza de una lista y "cdr" su cola o resto.

Lisp sigue una filosofía de tratamiento no-destructivo de los parámetros, de modo que la mayoría de las funciones devuelven una lista resultado de efectuar alguna transformación sobre la que recibieron, pero sin alterar esta última.

Uno de los motivos por los que Lisp es especialmente adecuado para la IA es el hecho de que el código y los datos tengan el mismo tratamiento (como listas); esto hace especialmente sencillo escribir programas capaces de escribir otros programas según las circunstancias.

Lisp fue uno de los primeros lenguajes de programación a incluir manejo de excepciones con las primitivas catch y throw.

Derivado del Lisp es el lenguaje de programación Logo. Sin entrar en detalles, podría decirse que Logo es Lisp sin paréntesis y con operadores aritméticos infijos.

(1)De ahí que hoy tengan alias más significativos como "first"(car) y "rest"(cdr).

[editar] Ejemplos

*******************************************************************
Definición de la función:

  (defun vacia (l)
    (cond ((null l) 1)    ; si la lista esta vacia devuelve 1
      (t   0)))           ; en otro caso (lista llena) devuelve 0

Llamada a la función:

  (vacia '(1 3 4))        ; La lista no esta vacia, devolvería 0
  (vacia '())             ; La lista esta vacia, devolvería 1
*******************************************************************
(defun último (lista)
  (cond( (null (cdr lista)) (car lista))
    (t (último (cdr lista)))))

(último '(1 2 3 4 5 6 7))  ; devuelve el último de la lista: 7


(defun factorial (n)
   (if (<= n 1) 1          ; si factorial de 1, condición de parada
       (* n (factorial (- n 1)))))  ; si no, llamada recursiva

(factorial 4)              ;esto nos devolvería 24=4*3*2*1

[editar] Grandes valores de la Función de Ackermann

;Propuesta por Nikolai Coica
(defun ackermann (m n) "The Ackermann Function"
(cond ((= m 0) (+ n 1))
      ((= m 1) (+ n 2))
      ((= m 2) (+ 3 (* n 2)))
      ((= m 3) (+ 5 (* 8 (- (expt 2 n) 1))))
      (t (cond ((= n 0) (ackermann (- m 1) 1))
               (t (ackermann (- m 1) (ackermann m (- n 1))))
         ))
))