DIALECTOS:
- Common Lisp(Guy Lewis Steele Jr. y Gerald Jay Sussman):
Descendiente de MacLisp, Interlisp, y Lisp Machine Lisp, es un superconjunto con estándar de lenguaje grande que incluye tipos de datos y formas sintácticas, como un sistema del objeto.
Este dialecto de Lisp con ámbito estático y cola recursiva fue diseñado para tener una semántica clara y simple y pocas maneras diferentes de formar expresiones.

- Scheme:
Con menos características estándar, pero con ciertas de implementación (como optimización de llamada de cola)
Common Lisp adopta algunas características de Scheme, como ámbito de léxico y clausura léxica.
Scheme sigue evolucionando con una serie de los estándares (Revisedn Report on the Algorithmic Language Scheme) y una serie de Scheme Requests for Implementation.

LISTAS:
Los datos y programas son listas que están delimitadas por paréntesis, donde algunas de las funciones predefinidas tienen símbolos:
- Suma: +
- Producto *
- Funciones predefinidas:

	CAR Devuelve la cabeza de la lista

 	CDR Devuelve la cola de la lista

	CONS Construye una lista CONS a partir de otras dos

	LIST Construye una lista a partir de varias sublistas
	
	Asignación, relaciones booleanas y predicados
	SET y SETQ Evalúan sus argumentos

	EQ Comprueba si dos argumentos son iguales

	GREATERP y LESSP Compara si el arg 1 es mayor/ menor que el 2

	NULL Comprueba si la lista es nula

	ATOM; LISTP NUMBERP Averiguan el tipo de un objeto

	OR, AND y NOT Predicados de suma, multiplicación y negación
	
	Aritméticas
	PLUS, DIFERENCE, TIMES, QUOTIENT, REMAINDER Suma, resta, multiplicación, cociente, resto
	
	Condicionales e iterativas
	COND Condicional con varios predicados

	LOOP Función iterativa no declarativa

        Formas funcionales para crear y combinar funciones
	DEFUN Función que permite crear otras funciones

        Objetos de datos
	LISP estructura fundamental
 

Ejemplos:
Comprobar si un número es primo:

    (DEFUN PRIMO(N)
	COND((EQ N 2) T) ((EQ N 3) T)
	(T (PRIMO1 N (QUOTIENT N 2)))))
	(DEFUN PRIMO1 (N Y)
	COND((EQ (REMAINDER N Y) 0) NIL)
	((EQ Y 2) T)
	(T (PRIMO1 N (DIFERENCE Y 1))))

   (PRIMO 3) T 

   (PRIMO 8) NUL 

Ejemplo: ¡Hola, mundo!:

(format t "¡Hola, mundo!")

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

  (vacia '(1 3 4))        ; La lista no esta vacía, devolvería 0
  (vacia '())             ; La lista esta vacía, 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 (= 0 n)
     1                            ; caso base
     (* n (factorial (- n 1)))))  ; caso recursivo

(factorial 4)  produce 24=4*3*2*1

 (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))))))))