Ver el código de «Lisp»

{{Ficha de lenguaje de programación
|nombre                    = Lisp
|logo                      = Lisp logo.svg
|tamaño_logo               = 120px
|paradigma                 = [[programación multiparadigma|Multiparadigma]]: [[Programación funcional|funcional]], [[Programación por procedimientos|por procedimientos]], [[Reflexión (informática)|reflexión]], [[Metaprogramación]]
|año                       = 1958
|diseñador = [[John McCarthy (científico)|John McCarthy]]
|tipo_dato= varios
|implementaciones = múltiples
|dialectos = [[Common Lisp]], [[Scheme]], [[Emacs Lisp]], [[Clojure]], [[AutoLISP]], [[Hy]], [[Arc (lenguaje de programación)|Arc]], [[Franz Lisp]], [[Maclisp]], [[Racket (lenguaje de programación)|Racket]]
|influido_por = 
|ha_influido = [[Perl]], [[Python]], [[Javascript]], [[Lua]], [[Scala (lenguaje de programación)|Scala]], [[Ruby]], [[R (lenguaje de programación)|R]], [[Elixir (lenguaje de programación)|Elixir]], [[Haskell]], [[Forth]], [[Julia (lenguaje de programación)|Julia]],  [[Smalltalk]], [[CLOS]], [[Dylan (lenguaje de programación)|Dylan]], [[Wolfram (lenguaje de programación)|Wolfram]]
}}

'''Lisp''' (históricamente '''LISP''') es una familia de [[lenguaje de programación|lenguajes de programación]] de [[Computadora electrónica|computadora]] de tipo [[programación multiparadigma|multiparadigma]] con larga historia y una inconfundible y útil sintaxis [[Homoiconicidad|homoicónica]] basada en la [[notación polaca]].

Desarrollado originalmente en 1959 por [[John McCarthy (científico)|John McCarthy]] y sus colaboradores en el [[Instituto Tecnológico de Massachusetts]], Lisp es el segundo [[lenguaje de alto nivel|lenguaje de programación de alto nivel]] de mayor antigüedad; apareció un año después de [[FORTRAN]] y uno antes que [[COBOL]].

Al igual que COBOL y FORTRAN, Lisp ha cambiado mucho desde sus comienzos, y han existido un gran número de [[dialecto (programación)|dialectos]] en su historia. Hoy, los dialectos de Lisp más ampliamente usados son [[Scheme]] (1975), [[Common Lisp]] (1984), [[Emacs Lisp]] (1985) y [[Clojure]] (2007).

Lisp fue creado originalmente como una notación matemática práctica para los programas de computadora, basada en el [[cálculo lambda]] de [[Alonzo Church]]. Se convirtió rápidamente en el lenguaje de programación favorito en la investigación de la [[inteligencia artificial]] (AI). Como lenguajes de programación precursor, Lisp fue pionero en muchas ideas en [[ciencias de la computación]], incluyendo las [[estructura de datos|estructuras de datos]] de [[Árbol (estructura de datos)|árbol]], el [[Recolector de basura|manejo de almacenamiento automático]], [[Tipo de dato|tipos]] dinámicos, y el [[compilador]] [[auto contenido]].

El acrónimo LISP significa «'''LIS'''t '''P'''rocessor» (‘procesador de listas’). Las [[Lista (estructura de datos)|listas encadenadas]] son una de las estructuras de datos importantes de Lisp, y el [[código fuente]] de Lisp en sí mismo está compuesto de listas. Como resultado, los programas de Lisp pueden manipular código fuente de Lisp como si fueran simples datos, dando lugar a sistemas de macros que permiten a los programadores crear [[Lenguaje de dominio específico|lenguajes de dominio específico]] embebidos en Lisp.

La intercambiabilidad del código y los datos también da a Lisp su instantáneamente reconocible sintaxis. Todo el código del programa es escrito como [[expresión S|expresiones S]], o listas entre paréntesis. Una llamada de función o una forma sintáctica es escrita como una lista, con la función o el nombre del operador en primer lugar, y los argumentos a continuación; por ejemplo, una función f que toma tres argumentos puede ser llamada usando <code>(f x y z)</code>.

== Historia ==

Lisp fue inventado por John McCarthy en 1958 mientras estaba en el [[Instituto Tecnológico de Massachusetts]] (MIT). McCarthy publicó su diseño en 1960 en un artículo de [[Communications of the ACM]] titulado «Funciones recursivas de expresiones simbólicas y su cómputo a máquina, Parte I» (la «parte II» nunca fue publicada). Allí mostró que con algunos operadores simples y una notación para las funciones, uno puede construir un lenguaje [[Turing completo]] para procesamiento de [[algoritmo]]s.

Desde 1955 o 1956, el [[Information Processing Language]] fue el primer lenguaje de AI, y ya había incluido muchos de los conceptos, tales como proceso por lista y [[recursión]], que vinieron a ser usados en Lisp.

La notación original de McCarthy usaba «[[expresión M|expresiones M]]» en corchetes que serían traducidas a [[expresión S|expresiones S]]. Como un ejemplo, la expresión M <CODE>car[cons[A,B]]</CODE> es equivalente a la expresión S <code>(car (cons A B))</code>. Una vez que Lisp fue implementado, los programadores rápidamente eligieron usar expresiones S, y las expresiones M fueron abandonadas. las expresiones M emergieron otra vez con los intentos efímeros del [[MLISP]]<ref name="SMITH">{{cita web| título=MLISP Users Manual| autor=David Canfield Smith| url=http://community.computerhistory.org/scc/projects/LISP/stanford/Smith-MLISP-AIM-84.pdf| fechaacceso=13 de octubre de 2006| urlarchivo=https://web.archive.org/web/20060924071457/http://community.computerhistory.org/scc/projects/LISP/stanford/Smith-MLISP-AIM-84.pdf| fechaarchivo=24 de septiembre de 2006}}</ref> de [[Horace Enea]] y el [[CGOL]] de [[Vaughan Pratt]].

Lisp fue implementado primero por [[Steve Russell]] en un computador [[IBM 704]]. Russell había leído el artículo de McCarthy, y se dio cuenta (para la sorpresa de McCarthy) que la función ''eval'' de Lisp podía ser implementada en [[código de máquina]]. El resultado fue un [[intérprete (informática)|intérprete]] de Lisp funcional que podía ser usado para correr programas Lisp, o más correctamente, «evaluar expresiones Lisp».

Dos rutinas de [[lenguaje ensamblador]] para el [[IBM 704]] se convirtieron en las operaciones primitivas para descomponer listas: [[CAR y CDR|car]] (contenido del registro de dirección) y cdr (contenido del registro del decremento). Los dialectos de Lisp todavía usan el car y cdr ({{Pron|ˈkɑr}} y {{IPA|/ˈkʊdər/}}) para las operaciones que retornan el primer elemento y el resto de la lista respectivamente.

El primer compilador completo de Lisp, escrito en Lisp, fue implementado en 1962 por Tim Hart y Mike Levin en el MIT.<ref name="LEVIN">{{cita web| título=AI Memo 39-The new compiler| autor=Tim Hart and Mike Levin| url=ftp://publications.ai.mit.edu/ai-publications/pdf/AIM-039.pdf| fechaacceso=de Wayback Machine, 6 de julio del 2017| fechaarchivo=13 de diciembre de 2020| urlarchivo=https://web.archive.org/web/20201213195043/ftp://publications.ai.mit.edu/ai-publications/pdf/AIM-039.pdf| deadurl=}}</ref> Este compilador introdujo el modelo Lisp de compilación incremental, en el cual las funciones compiladas e interpretadas pueden entremezclarse libremente. El lenguaje en los [[Memorándum|memo]]s de Hart y Levin es mucho más cercano al estilo moderno de Lisp que el anterior código de McCarthy.

=== Genealogía y variantes ===

Sobre su historia de cincuenta años, Lisp ha producido muchas variaciones en el tema base de un lenguaje de expresión S. Por otra parte, cada dialecto dado puede tener varias implementaciones, por ejemplo, hay más de una docena de implementaciones del [[Common Lisp]].

Las diferencias entre los dialectos pueden ser muy visibles, por ejemplo, el Common Lisp y el Scheme usan diferentes palabras clave para definir funciones. Dentro de un dialecto que está estandarizado, sin embargo, las implementaciones conformadas soportan el mismo lenguaje base, pero con diferentes extensiones y bibliotecas.

=== Relación con la inteligencia artificial ===

Desde su inicio, Lisp estaba estrechamente relacionado con la comunidad de investigación de la [[inteligencia artificial]], especialmente en sistemas [[PDP-10]].<ref>The 36-bit word size of the [[PDP-6]]/[[PDP-10]] was influenced by the usefulness of having two Lisp 18-bit pointers in a single word. {{cita noticia | cita = The PDP-6 project started in early 1963, as a 24-bit machine. It grew to 36 bits for LISP, a design goal. | url = http://groups.google.com/group/alt.folklore.computers/browse_thread/thread/6e5602ce733d0ec/17597705ae289112 | título = The History of TOPS or Life in the Fast ACs | obra = alt.folklore.computers | id = 84950@tut.cis.ohio-state.edu | fecha = 18 de octubre de 1990 | autor = Lum Johnson}}</ref> Fue usado como la implementación del lenguaje de programación [[Planner|Micro Planner]] que fue la fundación para el famoso sistema de AI [[SHRDLU]]. En los años 1970, a medida que la investigación del AI engendró descendientes comerciales, el desempeño de los sistemas Lisp existentes se convirtió en un problema creciente.

Lisp era un sistema difícil de implementar con las técnicas de compilador y hardware común de los años 1970. Las rutinas de [[recolección de basura]], desarrolladas por el entonces estudiante graduado del MIT, Daniel Edwards, hicieron práctico correr Lisp en sistemas de computación de propósito general, pero la eficacia todavía seguía siendo un problema. Esto llevó a la creación de las [[máquina Lisp|máquinas Lisp]]: hardware dedicado para correr ambientes y programas Lisp. Avances tanto en el hardware de computadora como en la tecnología de compiladores pronto hicieron obsoletas a las máquinas de Lisp, en detrimento del mercado de Lisp.

Durante los años 1980 y 1990, fue hecho un gran esfuerzo para unificar los numerosos dialectos de Lisp en un solo lenguaje (más notablemente, [[InterLisp]], [[Maclisp]], [[ZetaLisp]], [[MetaLisp]], y [[Franz Lisp]]). El nuevo lenguaje, [[Common Lisp]], fue esencialmente un subconjunto compatible de los dialectos que reemplazó. En 1994, la [[ANSI]] publicó el estándar del Common Lisp, «ANSI X3.226-1994 Information Technology Programming Language Common Lisp». En aquel momento el mercado mundial para Lisp era mucho más pequeño de lo que es hoy.{{Cita requerida|date=March 2009}}

=== Desde el año 2000 ===

Habiendo declinado algo en los años noventa, Lisp experimentó un nuevo auge enfocado en las implementaciones [[fuente abierta|abiertas]] de [[Common Lisp]] y en el desarrollo de aplicaciones y de nuevas bibliotecas portátiles. Una muestra de este interés fue el que la versión impresa de [[Practical Common Lisp]] (Common Lisp Práctico) de [[Peter Seibel]], un tutorial para nuevos programadores publicado en 2004,<ref>{{Cita web |url=http://gigamonkeys.com/blog/2007/05/26/pcl-third-printing.html |título=Practical Common Lisp going into 3rd printing |fechaacceso=19 de septiembre de 2009 |fechaarchivo=20 de junio de 2009 |urlarchivo=https://web.archive.org/web/20090620083904/http://gigamonkeys.com/blog/2007/05/26/pcl-third-printing.html |deadurl=yes }}</ref> estuviese brevemente en [[Amazon.com]] como el segundo libro de programación más popular. El libro es accesible en línea sin costo.<ref>[http://gigamonkeys.com/book/ Practical Common Lisp]</ref>

Muchos nuevos programadores de Lisp fueron inspirados por escritores como [[Paul Graham]] y [[Eric S. Raymond]] luchando por un lenguaje que otros consideran anticuado. Los nuevos programadores de Lisp frecuentemente describen el lenguaje como una experiencia que abre los ojos y afirman que es sustancialmente más productivo que otros lenguajes.<ref>{{cita web | título=The Road To Lisp Survey | url=http://wiki.alu.org/The_Road_To_Lisp_Survey | fechaacceso=13 de octubre de 2006 | urlarchivo=https://web.archive.org/web/20061004031130/http://wiki.alu.org/The_Road_To_Lisp_Survey | fechaarchivo=4 de octubre de 2006 }}</ref> Este aumento de conciencia puede ser contrastado con el «[[Invierno IA|invierno de la inteligencia artificial]]» y el breve crecimiento de Lisp a mediados de los 1990.<ref>{{Cita web |url=http://www.faqs.org/docs/artu/ch14s05.html |título=Trends for the Future |fechaacceso=19 de septiembre de 2009 |urlarchivo=https://web.archive.org/web/20130603002452/http://www.faqs.org/docs/artu/ch14s05.html |fechaarchivo=3 de junio de 2013 }}</ref>

En su encuesta de las implementaciones del Common Lisp, Dan Weinreb lista once implementaciones activamente mantenidas. Scieneer Common Lisp es una nueva implementación comercial que bifurcó (fork) del CMUCL con un primer lanzamiento en 2002.

La comunidad del código libre ha creado la nueva infraestructura de soporte: [[Cliki]] es un Wiki que recoge la información relacionada con Common Lisp, el [https://web.archive.org/web/20080905110332/http://cl-user.net/ Common Lisp directory] lista recursos, el #lisp es un canal popular de IRC (con soporte por un Bot escrito en Lisp), [http://paste.lisp.org/ lisppaste] {{Wayback|url=http://paste.lisp.org/ |date=20210609105556 }} soporta la distribución y el intercambio y comentario de retazos de código (snippets), el [http://planet.lisp.org/ Planet Lisp] recoge el contenido de varios blogs relacionados con Lisp, en el [http://www.lispforum.com/ LispForum] {{Wayback|url=http://www.lispforum.com/ |date=20180314232330 }} el usuario discute asuntos referentes a Lisp, [http://lispjobs.wordpress.com/ Lispjobs] es un servicio para anunciar ofertas de trabajo y hay un nuevo servicio de noticias semanales ([http://lispnews.wordpress.com/ Weekly Lisp News]).

Han sido celebrados los 50 años del Lisp (1958-2008) en [http://www.lisp50.org/ LISP50@OOPSLA]. Hay varias reuniones de usuario locales regulares (Boston, Vancouver, [https://web.archive.org/web/20110714042314/http://lisp-hh.de/wiki/Stammtisch Hamburg],…), Reuniones Lisp ([http://www.weitz.de/eclm2009/ European Common Lisp Meeting], [https://web.archive.org/web/20110726042005/http://european-lisp-symposium.org/, European Lisp Symposium]) y una [http://www.international-lisp-conference.org/ International Lisp Conference].

La comunidad Scheme mantiene activamente más de veinte implementaciones. Se han desarrollado en los últimos años varias significativas nuevas implementaciones (Chicken, Gauche, Ikarus, Larceny, Ypsilon). El estándar de Scheme [http://www.schemers.org/Documents/Standards/R5RS/ Revised<sup>5</sup> Report on the Algorithmic Language Scheme] fue ampliamente aceptado en la comunidad del Scheme. El proceso [[Scheme Requests for Implementation]] ha creado muchas bibliotecas y extensiones casi estándares para el Scheme. Las comunidades de usuario de implementaciones individuales del Scheme continúan creciendo. En 2003 un nuevo proceso de estandarización del lenguaje fue comenzada y condujo al estándar R<sup>6</sup>RS del Scheme en 2007. El uso académico del Scheme para enseñar ciencias de la computación parece haber declinado algo. Algunas universidades ya no están usando Scheme en sus cursos preliminares de ciencias de la computación.

Hay también algunos nuevos dialectos Lisp. Notablemente: [[Newlisp]] (un lenguaje de scripting), Arc (desarrollado por Paul Graham) y recientemente [[Clojure]] (desarrollado por Rich Hickey) y NU para la programación con Cocoa de Apple.

== Dialectos importantes ==

Los dos principales dialectos de Lisp usados para la programación de propósitos generales hoy en día son [[Common Lisp]] y [[Scheme]]. Estos lenguajes representan opciones de diseño significativamente diferentes.

El [[Common Lisp]], descendiente principalmente de [[MacLisp]], [[Interlisp]], y [[Lisp Machine Lisp]], es un superconjunto ampliado de los primeros dialectos del Lisp, con un estándar de lenguaje grande incluyendo muchos tipos de datos y formas sintácticas incorporados, así como un sistema del objeto. El Scheme es un diseño más minimalista, con un mucho más pequeño conjunto de características estándar pero con ciertas características de implementación (tales como [[optimización de llamada de cola]] y [[continuación]] completa) no encontradas necesariamente en Common Lisp. El Common Lisp también tomó prestadas ciertas características de Scheme tales como [[ámbito de léxico]] y [[Clausura (informática)|clausura]] léxica.

El [[Scheme]], es un dialecto del lenguaje Lisp con ámbito estático y cola recursiva auténtica inventado por [[Guy Lewis Steele Jr.]] y [[Gerald Jay Sussman]]. Fue diseñado para tener una semántica excepcionalmente clara y simple y pocas maneras diferentes de formar expresiones. Una amplia variedad de paradigmas programados encuentran una expresión conveniente en Scheme, incluyendo los estilos imperativo, funcional, y paso de mensajes. El Scheme continúa evolucionando con una serie de los estándares (Revised<sup>n</sup> Report on the Algorithmic Language Scheme) y una serie de [[Scheme Requests for Implementation]].

Además, los dialectos de Lisp son usados como lenguajes de scripting en un número de aplicaciones, con los más conocidos siendo el [[Emacs Lisp]] en el editor de [[Emacs]], [[Visual Lisp]] en [[AutoCAD]], Nyquist en [[Audacity]].

== Innovaciones del lenguaje ==


Fue en Lisp donde nacieron muchas ideas de las [[ciencias de la computación]], incluyendo la [[Estructura de datos|estructura de dato]] de [[Árbol (informática)|árbol]], [[Recolector de basura|recolección automática de basura]], [[tipado dinámico]], [[Condicional (programacion)|condicionales]], [[Función de orden superior|funciones de orden superior]] como ''[[Map (función de orden superior)|map]]'' y ''[[Reduce (función de orden superior)|reduce]]'', [[Recursión (ciencias de computación)|recursividad]], el [[Self-hosting|compilador autocontenido]] y el [[REPL]].<ref>{{Cita libro|título=Influential Programming Languages, Part 4: Lisp|url=https://www.informit.com/articles/article.aspx?p=1671639&seqNum=3|fecha=12 de enero de 2011|fechaacceso=22 de mayo de 2020|nombre=David|apellidos=Chisnall}}</ref><ref>{{Cita web|url=http://www.paulgraham.com/icad.html|título=Revenge of the Nerds|fechaacceso=22 de mayo de 2020|sitioweb=www.paulgraham.com}}</ref>

Lisp fue el primer lenguaje de programación [[Homoiconicidad|homoicónico]]: todo el [[código fuente]] del programa es al mismo tiempo una [[estructura de datos]] del lenguaje ([[Lista (tipo de dato abstracto)|listas]] anidadas o [[Árbol (informática)|árboles]]). Como resultado la [[metaprogramación]] en Lisp es relativamente sencilla. Ya que el código fuente de Lisp tiene una correspondencia directa con el [[Árbol de sintaxis abstracta|árbol sintáctico abstracto]] del programa, se puede crear código de Lisp para manipular más código de Lisp, o aún crearlo desde cero, sin necesidad de un extensivo [[analizador sintáctico|análisis sintáctico]] (parsing) o manipulación de código de máquina binario. Esto generalmente es considerado una de las ventajas primarias del lenguaje con respecto a su poder expresivo, y hace al lenguaje favorable a la [[evaluación metacircular]].

La ubicua estructura <code>IF THEN ELSE</code>, ahora admitida como un elemento esencial de cualquier lenguaje de programación, fue inventada por McCarthy para el uso en Lisp, donde vio su primera apariencia en una forma más general (la estructura <code>cond</code>). Fue heredada por el [[ALGOL]], que la popularizó.

Lisp influyó profundamente a [[Alan Kay]], el líder de investigación del [[Smalltalk]], y entonces a su vez Lisp fue influenciado por Smalltalk, adoptando las características de la [[programación orientada a objetos]] (clases, instancias, etc.) a finales de los años 1970.

Lisp introdujo el concepto de [[Recolector de basura|recolección de basura]], mediante el cual el sistema busca en el [[Gestión de memoria|«''heap''» de memoria dinámica]] para eliminar objetos obsoletos sin intervención explícita del programador.<ref>{{Cita publicación|url=https://dl.acm.org/doi/abs/10.1145/358141.358147|título=A real-time garbage collector based on the lifetimes of objects|apellidos=LiebermanHenry|apellidos2=HewittCarl|fecha=1 de junio de 1983|publicación=Communications of the ACM|fechaacceso=22 de mayo de 2020|idioma=EN|doi=10.1145/358141.358147}}</ref>

En gran parte debido a sus requerimientos de recursos con respecto al temprano hardware computacional (incluyendo los primeros [[microprocesador]]es), Lisp no se hizo tan popular fuera de la comunidad de [[inteligencia artificial]], como lo fueron el [[FORTRAN]] y el descendiente del lenguaje [[ALGOL]], el lenguaje [[lenguaje de programación C|C]]. Lenguajes más nuevos como [[Lenguaje de programación Java|Java]] y [[Python]] han incorporado algunas versiones limitadas de algunas de las características de Lisp, pero no pueden necesariamente brindar la coherencia y la sinergia de los conceptos completos encontrados en Lisp. Debido a su conveniencia para aplicaciones mal definidas, complejas, y dinámicas, Lisp están disfrutando actualmente de un cierto resurgimiento del interés popular.

== Listas ==
El elemento fundamental en Lisp es la [[lista (programación)|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 «List Processing».

Las listas en LISP están delimitadas por paréntesis. De aquí viene el chiste del significado de LISP: «LostInStupidParentheses» que aunque con buen humor es completamente ficticio.
 
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|car]]» y «[[CAR y CDR|cdr]]») son un poco extraños, 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 en incluir [[manejo de excepciones]] con las primitivas ''catch'' y ''throw''.

Derivado de 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.

== Orígenes de «car» y «cdr» ==

{{AP|CAR y CDR}}

* car: Content of Address part of Register
* cdr: Content of Decremental part of Register

Son operaciones del [[conjunto de instrucciones]] del [[IBM 704]]

== Ejemplos ==
=== Hola mundo ===
<syntaxhighlight lang="lisp">
(format t "¡Hola, mundo!")
</syntaxhighlight>

==== Trabajando con listas ====
<syntaxhighlight lang="lisp">
*******************************************************************
Definición de la función:

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

Llamada a la función:

  (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

*******************************************************************


; Factorial(x) = 1 si x=0 caso base
; x*factorial(x-1) si x>0 caso recursivo

;Función factorial hecha con recursividad no final
(defun factorial (n)
   (if (= 0 n)
     1                            ; caso base
     (* n (factorial (- n 1)))))  ; caso recursivo

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

*******************************************************************
</syntaxhighlight>

=== Grandes valores de la [[Función de Ackermann]] ===
<syntaxhighlight lang="lisp">
 ;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))))))))
</syntaxhighlight>

== Referencias ==

{{listaref|2}}

== Véase también ==

* [[Inteligencia artificial]]
* [[Common Lisp]]
* [[Scheme]]
* [[Maxima]]

== Enlaces externos ==
{{wikibooks|Programación en LISP}}
* [https://web.archive.org/web/20091226233301/http://abhishek.geek.nz/docs/features-of-common-lisp Features of Common Lisp] Una discusión de algunas de las características más sobresalientes del lenguaje.
* [http://gnu.manticore.es Recursos Lisp en español] {{Wayback|url=http://gnu.manticore.es/ |date=20180116041204 }} Textos en español y traducciones sobre Lisp, Common Lisp, Emacs Lisp, etc.
* [http://www.gigamonkeys.com/book/ Practical Common Lisp] Libro introductorio de Common Lisp. Versión en línea y distribuible por la propia editorial.
* [http://www.defmacro.org/ramblings/lisp.html The Nature of Lisp]. Una introducción para entender la naturaleza del lenguaje y su poder.

=== Aplicaciones en Lisp ===
Entre las más exitosas aplicaciones escritas en Lisp se pueden mencionar:
* [[Emacs]], el [[editor de texto]] http://www.gnu.org/software/emacs/emacs.html
* [[ACL2]], el [[demostrador de teoremas]] http://www.cs.utexas.edu/users/moore/acl2/
* [[Maxima]], el sistema de álgebra computacional http://maxima.sourceforge.net/

=== Compiladores de Lisp ===
* [http://www.gnu.org/software/gcl/gcl.html GNU Common Lisp], [[software libre]]
* [http://www.franz.com/ Allegro Common Lisp], [[software propietario]]
* [http://cmucl.org/ CMU Common Lisp], [[software libre]]
* [[CLISP|CLISP, Una implementación de Common Lisp]], [[software libre]]
* [http://openmcl.clozure.com/ OpenMCL] {{Wayback|url=http://openmcl.clozure.com/ |date=20180305085941 }} Common lisp para [[Macintosh]], [[software libre]]

{{Control de autoridades}}

[[Categoría:Lisp| ]]
[[Categoría:Lenguajes de programación orientada a objetos]]
[[Categoría:Acrónimos de informática]]
[[Categoría:Informática de 1958]]