Lisp (lenguaje de programación)

Desde sus inicios, Lisp estuvo estrechamente vinculado a la comunidad de investigación en inteligencia artificial , especialmente en los sistemas PDP-10 ^{[ 23 ]} . Lisp se utilizó como implementación del lenguaje Micro Planner , que a su vez se empleó en el famoso sistema de IA SHRDLU . En la década de 1970, a medida que la investigación en IA generó ramificaciones comerciales, el rendimiento de los sistemas Lisp existentes se convirtió en un problema creciente, ya que los programadores debían familiarizarse con las implicaciones en el rendimiento de las diversas técnicas y opciones involucradas en la implementación de Lisp. ^{[ 24 ]}

A lo largo de sus sesenta años de historia, Lisp ha dado lugar a numerosas variantes basadas en el concepto fundamental de lenguaje de expresiones S. Algunas de estas variantes han sido estandarizadas e implementadas por distintos grupos con diferentes prioridades (por ejemplo, tanto Common Lisp como Scheme cuentan con múltiples implementaciones). Sin embargo, en otros casos, un proyecto de software define un Lisp sin un estándar, sin que exista una distinción clara entre el dialecto y la implementación (por ejemplo, Clojure y Emacs Lisp entran en esta categoría).

Las diferencias entre dialectos (y/o implementaciones) pueden ser bastante visibles; por ejemplo, Common Lisp usa la palabra clave defunpara nombrar una función, pero Scheme usa define. ^{[ nota 2 ]} Dentro de un dialecto estandarizado, las implementaciones conformes admiten el mismo lenguaje base, pero con diferentes extensiones y bibliotecas. Esto a veces también crea cambios bastante visibles con respecto al lenguaje base; por ejemplo, Guile (una implementación de Scheme) usa define*para crear funciones que pueden tener argumentos predeterminados y/o argumentos de palabra clave , ninguno de los cuales está estandarizado.

Dialectos de importancia histórica

• LISP 1 ^{[ 25 ]} – Primera implementación.
• LISP 1.5 ^{[ 26 ]} – Primera versión ampliamente distribuida, desarrollada por McCarthy y otros en el MIT. Recibió ese nombre porque contenía varias mejoras en el intérprete original "LISP 1", pero no fue una reestructuración importante como lo sería el LISP 2 planeado.
• Stanford LISP 1.6 ^{[ 27 ]} – Sucesor de LISP 1.5 desarrollado en el Laboratorio de IA de Stanford y ampliamente distribuido a los sistemas PDP-10 que ejecutaban el sistema operativo TOPS-10 . Fue reemplazado por Maclisp e InterLisp.
• Maclisp ^{[ 28 ]} – desarrollado para el Proyecto MAC del MIT , MACLISP es un descendiente directo de LISP 1.5. Se ejecutaba en los sistemas PDP-10 y Multics . MACLISP más tarde se llamaría Maclisp, y a menudo se le conoce como MacLisp. La sigla "MAC" en MACLISP no tiene relación con el Macintosh de Apple ni con McCarthy .
• Interlisp ^{[ 29 ]} – desarrollado en BBN Technologies para sistemas PDP-10 que ejecutaban el sistema operativo TENEX , posteriormente adoptado como un Lisp de la "costa oeste" para las máquinas Lisp de Xerox como InterLisp-D. Se publicó una versión reducida llamada "InterLISP 65" para las computadoras Atari de 8 bits basadas en MOS Technology 6502. Maclisp e InterLisp fueron fuertes competidores.
• Franz Lisp – originalmente un proyecto de la Universidad de California, Berkeley ; posteriormente desarrollado por Franz Inc. El nombre es una deformación humorística del nombre " Franz Liszt " y no se refiere a Allegro Common Lisp , el dialecto de Common Lisp que Franz Inc. vendió en años más recientes.
• muLISP , desarrollado inicialmente por Albert D. Rich y David Stoutemeyer para sistemas de microcomputadoras pequeñas, se comercializó en 1979 y funcionaba en sistemas CP/M con tan solo 64 KB de RAM. Posteriormente, se adaptó a MS-DOS, finalizando su desarrollo en 1995. El software matemático "Derive" se escribió en muLISP para MS-DOS y, más tarde, para Windows hasta 2007.
• XLISP , en el que se basó AutoLISP .
• Standard Lisp y Portable Standard Lisp fueron ampliamente utilizados y adaptados, especialmente con el sistema de álgebra computacional REDUCE.
• ZetaLisp , también conocido como Lisp Machine Lisp, se utilizaba en las máquinas Lisp y es descendiente directo de Maclisp. ZetaLisp tuvo una gran influencia en Common Lisp.
• LeLisp es un dialecto francés de Lisp. Uno de los primeros Interface Builders (llamado SOS Interface ^{[ 30 ]} ) fue escrito en LeLisp.
• Esquema (1975). ^{[ 31 ]}
• Common Lisp (1984), como se describe en Common Lisp the Language , es una consolidación de varios intentos divergentes (ZetaLisp, Spice Lisp , NIL y S-1 Lisp ) para crear dialectos sucesores ^{[ 32 ]} de Maclisp, con influencias sustanciales también del dialecto Scheme. Esta versión de Common Lisp estaba disponible para una amplia gama de plataformas y fue aceptada por muchos como un estándar de facto ^{[ 33 ]} hasta la publicación de ANSI Common Lisp (ANSI X3.226-1994). Entre los subdialectos más extendidos de Common Lisp se encuentran Steel Bank Common Lisp (SBCL), CMU Common Lisp (CMU-CL), Clozure OpenMCL (¡que no debe confundirse con Clojure!), GNU CLisp y versiones posteriores de Franz Lisp; todos ellos se adhieren al estándar ANSI CL posterior (véase más abajo).
• En su primera versión, Dylan era una mezcla de Scheme con el Sistema de Objetos de Common Lisp.
• EuLisp : intento de desarrollar una nueva versión de Lisp, más eficiente y depurada.
• ISLISP – intento de desarrollar un nuevo Lisp eficiente y limpio. Estandarizado como ISO/IEC 13816:1997 ^{[ 34 ]} y revisado posteriormente como ISO/IEC 13816:2007: ^{[ 35 ]} Tecnología de la información – Lenguajes de programación, sus entornos e interfaces de software de sistema – Lenguaje de programación ISLISP .
• Esquema IEEE – Norma IEEE, 1178–1990 (R1995).
• ANSI Common Lisp : un estándar del Instituto Nacional Estadounidense de Estándares (ANSI) para Common Lisp, creado por el subcomité X3J13 , establecido ^{[ 36 ]} para comenzar con Common Lisp: The Language como documento base y trabajar a través de un proceso de consenso público para encontrar soluciones a problemas comunes de portabilidad de programas y compatibilidad de implementaciones de Common Lisp. Aunque formalmente es un estándar ANSI, la implementación, venta, uso e influencia de ANSI Common Lisp se ha visto y continúa viéndose en todo el mundo.
• ACL2 , o "Lógica Computacional para Common Lisp Aplicativo", es una variante aplicativa (sin efectos secundarios) de Common LISP. ACL2 es tanto un lenguaje de programación que puede modelar sistemas informáticos como una herramienta para ayudar a demostrar las propiedades de dichos modelos.
• Clojure , un dialecto reciente de Lisp que se compila a la máquina virtual de Java y tiene un enfoque particular en la concurrencia .
• Game Oriented Assembly Lisp (o GOAL) es un lenguaje de programación para videojuegos desarrollado por Andy Gavin en Naughty Dog . Fue escrito utilizando Allegro Common Lisp y se usó en el desarrollo de toda la serie de juegos Jak and Daxter, también desarrollada por Naughty Dog.

Tras un cierto declive en la década de 1990, Lisp ha experimentado un resurgimiento del interés después del año 2000. La mayor parte de la nueva actividad se ha centrado en implementaciones de Common Lisp , Scheme , Emacs Lisp , Clojure y Racket , e incluye el desarrollo de nuevas bibliotecas y aplicaciones portátiles.

Muchos nuevos programadores de Lisp se inspiraron en autores como Paul Graham y Eric S. Raymond para aprender un lenguaje que otros consideraban anticuado. Estos nuevos programadores suelen describir el lenguaje como una experiencia reveladora y afirman ser sustancialmente más productivos que en otros lenguajes. ^{[ 37 ]} Este aumento en la concienciación puede contrastarse con el « invierno de la IA » y el breve auge de Lisp a mediados de la década de 1990. ^{[ 38 ]}

A partir de 2010, había once implementaciones de Common Lisp mantenidas activamente. ^{[ 39 ]}

La comunidad de código abierto ha creado una nueva infraestructura de soporte: CLiki es una wiki que recopila información relacionada con Common Lisp, el directorio Common Lisp enumera recursos, #lisp es un canal popular de IRC y permite compartir y comentar fragmentos de código (con soporte de lisppaste, un bot de IRC escrito en Lisp), Planet Lisp ^{[ 40 ]} recopila el contenido de varios blogs relacionados con Lisp, en LispForum ^{[ 41 ]} los usuarios discuten temas de Lisp, Lispjobs ^{[ 42 ]} es un servicio para anunciar ofertas de trabajo y hay un servicio de noticias semanal, Weekly Lisp News . Common-lisp.net es un sitio de alojamiento para proyectos de código abierto de Common Lisp. Quicklisp ^{[ 43 ]} es un gestor de bibliotecas para Common Lisp.

Se celebraron cincuenta años de Lisp (1958–2008) en LISP50@OOPSLA. ^{[ 44 ]} Se realizan reuniones periódicas de usuarios locales en Boston, Vancouver y Hamburgo. Otros eventos incluyen la Reunión Europea de Lisp Común, el Simposio Europeo de Lisp y una Conferencia Internacional de Lisp.

La comunidad Scheme mantiene activamente más de veinte implementaciones . Varias implementaciones nuevas e importantes (Chicken, Gambit, Gauche, Ikarus, Larceny, Ypsilon) se desarrollaron en la década de 2000. El estándar Scheme del Informe Revisado ⁵ sobre el Lenguaje Algorítmico Scheme ^{[ 45 ]} fue ampliamente aceptado en la comunidad Scheme. El proceso de Solicitudes de Implementación de Scheme ha creado muchas bibliotecas y extensiones cuasi estándar para Scheme. Las comunidades de usuarios de implementaciones individuales de Scheme continúan creciendo. Un nuevo proceso de estandarización del lenguaje se inició en 2003 y condujo al estándar Scheme R6RS ^en 2007. El uso académico de Scheme para la enseñanza de la informática parece haber disminuido un poco. Algunas universidades ya no usan Scheme en sus cursos introductorios de informática; ^{[ 46 ] [ 47 ]} el MIT ahora usa Python en lugar de Scheme para su programa de informática de pregrado y el curso masivo abierto en línea MITx. ^{[ 48 ] [ 49 ]}

Existen varios dialectos nuevos de Lisp: Arc , Hy , Nu , Liskell y LFE (Lisp Flavored Erlang). El analizador sintáctico de Julia está implementado en Femtolisp, un dialecto de Scheme (Julia está inspirada en Scheme, que a su vez es un dialecto de Lisp).

En octubre de 2019, Paul Graham publicó una especificación para Bel , "un nuevo dialecto de Lisp".

Lisp tiene dialectos estandarizados oficialmente: Esquema R6RS , Esquema R7RS , Esquema IEEE, ^{[ 59 ]} ANSI Common Lisp e ISO ILISP .

Lisp es un lenguaje orientado a expresiones . A diferencia de la mayoría de los demás lenguajes, no se distingue entre "expresiones" e "instrucciones" ; todo el código y los datos se escriben como expresiones. Cuando se evalúa una expresión , produce un valor (posiblemente varios), que luego se puede incorporar a otras expresiones. Cada valor puede ser de cualquier tipo de dato.

El artículo de McCarthy de 1958 introdujo dos tipos de sintaxis: expresiones simbólicas ( expresiones S , sexps), que reflejan la representación interna del código y los datos; y metaexpresiones ( expresiones M ), que expresan funciones de las expresiones S. Las expresiones M nunca se popularizaron, y casi todos los lenguajes Lisp actuales utilizan expresiones S para manipular tanto el código como los datos.

El uso de paréntesis es la diferencia más evidente de Lisp con respecto a otras familias de lenguajes de programación. Por ello, los estudiantes le han dado a Lisp apodos como « Lost In Stupid Parentheses » o «Lots of Irritating Superfluous Parentheses » ^{[ 66 ]} . Sin embargo, la sintaxis de expresiones S también es responsable de gran parte del poder de Lisp: su sintaxis es simple y consistente, lo que facilita su manipulación por parte del ordenador. No obstante, la sintaxis de Lisp no se limita a la notación tradicional de paréntesis. Puede extenderse para incluir notaciones alternativas. Por ejemplo, XMLisp es una extensión de Common Lisp que emplea el protocolo de metaobjetos para integrar expresiones S con el Lenguaje de Marcado Extensible ( XML ).

La dependencia de las expresiones confiere al lenguaje una gran flexibilidad. Dado que las funciones de Lisp se escriben como listas, pueden procesarse exactamente como datos. Esto facilita la escritura de programas que manipulan otros programas ( metaprogramación ). Muchos dialectos de Lisp aprovechan esta característica mediante sistemas de macros, lo que permite extender el lenguaje prácticamente sin límites.

Una lista de Lisp se escribe con sus elementos separados por espacios en blanco y entre paréntesis. Por ejemplo, es una lista cuyos elementos son los tres átomos , , y . Estos valores tienen un tipo implícito: son respectivamente dos enteros y un tipo de dato específico de Lisp llamado "símbolo", y no es necesario declararlos como tales.(12foo)12foo

La lista vacía ()también se representa como el átomo especial nil. Esta es la única entidad en Lisp que es a la vez un átomo y una lista.

Las expresiones se escriben como listas, utilizando la notación prefija . El primer elemento de la lista es el nombre de una función, el nombre de una macro, una expresión lambda o el nombre de un "operador especial" (véase más abajo). El resto de la lista son los argumentos. Por ejemplo, la función listdevuelve sus argumentos como una lista, por lo que la expresión

( lista 1 2 ( cita foo ))

se evalúa a la lista . La "comilla" antes del en el ejemplo anterior es un "operador especial" que devuelve su argumento sin evaluarlo. Cualquier expresión sin comillas se evalúa recursivamente antes de que se evalúe la expresión que la contiene. Por ejemplo,(12foo)foo

( lista 1 2 ( lista 3 4 ))

se evalúa a la lista . El tercer argumento es una lista; las listas pueden estar anidadas.(12(34))

Los operadores aritméticos se tratan de forma similar. La expresión

( + 1 2 3 4 )

se evalúa a 10. El equivalente en notación infija sería " ".1+2+3+4

Lisp no tiene el concepto de operadores tal como se implementa en los lenguajes derivados de ALGOL . Los operadores aritméticos en Lisp son funciones variádicas (o n-arias ), capaces de tomar cualquier número de argumentos. A veces se implementa un operador de incremento al estilo de C '++' bajo la incfsintaxis de nombre.

( incf x )

equivalente a (setq x (+ x 1)), devolviendo el nuevo valor de x.

Los "operadores especiales" (a veces llamados "formas especiales") proporcionan la estructura de control de Lisp. Por ejemplo, el operador especial iftoma tres argumentos. Si el primer argumento no es nulo, se evalúa al segundo argumento; de lo contrario, se evalúa al tercer argumento. Por lo tanto, la expresión

( si es nulo ( lista 1 2 "foo" ) ( lista 3 4 "bar" ))

se evalúa a . Por supuesto, esto sería más útil si se hubiera sustituido una expresión no trivial en lugar de .(34"bar")nil

Lisp también proporciona los operadores lógicos and , or y not . Los operadores and y or realizan una evaluación de cortocircuito y devolverán su primer argumento nulo y no nulo, respectivamente.

( o ( y "cero" nulo "nunca" ) "James" 'tarea 'tiempo )

será evaluado como "James".

Otro operador especial, lambda, se utiliza para vincular variables a valores que luego se evalúan dentro de una expresión. Este operador también se utiliza para crear funciones: los argumentos de lambdason una lista de argumentos y la expresión o expresiones a las que se evalúa la función (el valor devuelto es el valor de la última expresión que se evalúa). La expresión

( lambda ( arg ) ( + arg 1 ))

se evalúa como una función que, al aplicarse, toma un argumento, lo vincula argy devuelve el número uno mayor que ese argumento. Las expresiones lambda no se tratan de manera diferente a las funciones con nombre; se invocan de la misma manera. Por lo tanto, la expresión

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

se evalúa como 6. Aquí, estamos haciendo una aplicación de función: ejecutamos la función anónima pasándole el valor 5.

Las funciones con nombre se crean almacenando una expresión lambda en un símbolo mediante la macro defun.

( defun foo ( a b c d ) ( + a b c d ))

(defunf(a)b...)define una nueva función denominada fen el entorno global. Es conceptualmente similar a la expresión:

( setf ( fdefinition 'f ) #' ( lambda ( a ) ( block f b... )))

donde setfes una macro utilizada para establecer el valor del primer argumento de un nuevo objeto de función. es una definición de función global para la función llamada . es una abreviatura de operador especial, que devuelve un objeto de función.fdefinition'ffdefinitionf#'function

En el LISP original existían dos tipos de datos fundamentales : átomos y listas. Una lista era una secuencia finita y ordenada de elementos, donde cada elemento era un átomo o una lista, y un átomo era un número o un símbolo. Un símbolo era esencialmente un elemento con nombre único, escrito como una cadena alfanumérica en el código fuente , y utilizado como nombre de variable o como elemento de datos en el procesamiento simbólico . Por ejemplo, la lista contiene tres elementos: el símbolo , la lista y el número 2.(FOO(BAR1)2)FOO(BAR1)

Una lista de Lisp se implementa como una lista enlazada simple . ^{[ 67 ]} Cada celda de esta lista se llama cons (en Scheme, un par ) y está compuesta por dos punteros , llamados car y cdr . Estos son respectivamente equivalentes a los campos datay nextdiscutidos en el artículo lista enlazada .

De las muchas estructuras de datos que se pueden construir a partir de celdas cons, una de las más básicas se llama lista propia . Una lista propia es el nilsímbolo especial (lista vacía) o un cons en el que carapunta a un dato (que puede ser otra estructura cons, como una lista) y cdrapunta a otra lista propia.

Si un elemento dado se considera la cabeza de una lista enlazada, entonces su `car` apunta al primer elemento de la lista y su `cdr` apunta al resto de la lista. Por esta razón, las funciones ` carand` cdrtambién se denominan first`and` restcuando se hace referencia a elementos que forman parte de una lista enlazada (en lugar de, por ejemplo, un árbol).

Por lo tanto, una lista de Lisp no es un objeto atómico, como lo sería una instancia de una clase contenedora en C++ o Java. Una lista no es más que un conjunto de elementos enlazados. Una variable que hace referencia a una lista dada es simplemente un puntero al primer elemento de la lista. El recorrido de una lista se puede realizar mediante la operación `cdring` , es decir, utilizando `cdrs` sucesivos para visitar cada elemento de la lista, o bien mediante el uso de diversas funciones de orden superior para aplicar una función a una lista.

Debido a que las listas y los cons son tan comunes en los sistemas Lisp, es un error frecuente pensar que son las únicas estructuras de datos de Lisp. De hecho, casi todos los Lisp, excepto los más simples, tienen otras estructuras de datos, como vectores ( arrays ), tablas hash , estructuras, etc.

Las expresiones S representan listas.

Las expresiones S entre paréntesis representan estructuras de listas enlazadas. Hay varias maneras de representar la misma lista como una expresión S. Un cons se puede escribir en notación de par punteado como , donde es el car y el cdr. Una lista propia más larga podría escribirse en notación de par punteado. Esto se abrevia convencionalmente como en notación de lista . Una lista impropia ^{[ nota 3 ]} puede escribirse en una combinación de las dos, como para la lista de tres cons cuyo último cdr es (es decir, la lista en forma completamente especificada).(a.b)ab(a.(b.(c.(d.nil))))(abcd)(abc.d)d(a.(b.(c.d)))

( lista 1 2 'a 3 ) ;Salida: (1 2 a 3)

( lista 1 ' ( 2 3 ) 4 ) ;Salida: (1 (2 3) 4)

( cons 1 ' ( 2 3 )) ;Salida: (1 2 3)

( cons ' ( 1 2 ) ' ( 3 4 )) ;Salida: ((1 2) 3 4)

( agregar ' ( 1 2 ) ' ( 3 4 )) ;Salida: (1 2 3 4)

( agregar ' ( 1 2 3 ) ' () ' ( a ) ' ( 5 6 )) ;Salida: (1 2 3 a 5 6)

( setf foo ( lista 'a 'b 'c )) ( setf bar ( cons 'x ( cdr foo )))

( setf ( tercer foo ) 'ganso )

Lisp evalúa las expresiones que introduce el usuario. Los símbolos y las listas se evalúan a alguna otra expresión (normalmente, más sencilla); por ejemplo, un símbolo se evalúa al valor de la variable que nombra; se evalúa a . Sin embargo, la mayoría de las demás formas se evalúan a sí mismas: si se introduce en Lisp, devuelve .(+23)555

Cualquier expresión también puede marcarse para evitar que se evalúe (como es necesario para los símbolos y las listas). Esta es la función del quoteoperador especial, o su abreviatura '(una comilla). Por ejemplo, normalmente si se introduce el símbolo foo, devuelve el valor de la variable correspondiente (o un error, si no existe dicha variable). Para referirse al símbolo literal, introduzca o, normalmente, .(quotefoo)'foo

Tanto Common Lisp como Scheme admiten el operador de comillas invertidas (denominado cuasicitación en Scheme), que se introduce con el `carácter ( comilla invertida ). Esto es casi igual que la comilla simple, excepto que permite evaluar expresiones y que sus valores se interpolen en una lista entre comillas con los operadores de empalme de coma y coma -at . Si la variable tiene el valor, se evalúa como , mientras que se evalúa como . Las comillas invertidas se utilizan con mayor frecuencia para definir expansiones de macros. ^{[ 68 ] [ 69 ]},,@snue(barbaz)`(foo,snue)(foo(barbaz))`(foo,@snue)(foobarbaz)

Las formas autoevaluables y las formas entre comillas son el equivalente a los literales en Lisp. Es posible modificar los valores de los literales (mutables) en el código del programa. Por ejemplo, si una función devuelve una forma entre comillas y el código que la llama modifica dicha forma, esto puede alterar el comportamiento de la función en invocaciones posteriores.

( defun debería-ser-constante () ' ( uno dos tres ))( let (( stuff ( should-be-constant ))) ( setf ( third stuff ) 'bizarro )) ; ¡mal!( debería ser constante ) ; devuelve (uno dos extraños)

Modificar una cita de esta manera generalmente se considera un mal estilo y ANSI Common Lisp la define como errónea (lo que resulta en un comportamiento "indefinido" en los archivos compilados, porque el compilador de archivos puede fusionar constantes similares, colocarlas en memoria protegida contra escritura, etc.).

La formalización de la cita en Lisp ha sido señalada por Douglas Hofstadter (en Gödel, Escher, Bach ) y otros como un ejemplo de la idea filosófica de autorreferencia .

La familia Lisp se divide en cuanto al uso del ámbito dinámico o estático (también conocido como ámbito léxico) . Clojure, Common Lisp y Scheme utilizan el ámbito estático por defecto, mientras que newLISP , Picolisp y los lenguajes integrados en Emacs y AutoCAD utilizan el ámbito dinámico. Desde la versión 24.1, Emacs utiliza ambos tipos de ámbito.

Una distinción fundamental entre Lisp y otros lenguajes es que, en Lisp, la representación textual de un programa es simplemente una descripción legible para humanos de las mismas estructuras de datos internas (listas enlazadas, símbolos, números, caracteres, etc.) que utilizaría el sistema Lisp subyacente.

Lisp utiliza esto para implementar un sistema de macros muy potente. Al igual que otros lenguajes de macros, como el definido por el preprocesador de C (el preprocesador de macros para los lenguajes de programación C++ , Objective-C y C++ ), una macro devuelve código que luego se puede compilar. Sin embargo, a diferencia de las macros del preprocesador de C, las macros son funciones de Lisp y, por lo tanto, pueden aprovechar todo el potencial de Lisp.

Además, dado que el código Lisp tiene la misma estructura que las listas, se pueden crear macros con cualquiera de las funciones de procesamiento de listas del lenguaje. En resumen, todo lo que Lisp puede hacer con una estructura de datos, las macros de Lisp pueden hacerlo con el código. En cambio, en la mayoría de los demás lenguajes, la salida del analizador sintáctico es puramente interna a la implementación del lenguaje y el programador no puede manipularla.

Esta característica facilita el desarrollo de lenguajes eficientes dentro de otros lenguajes. Por ejemplo, el Sistema de Objetos de Common Lisp se puede implementar de forma limpia como una extensión del lenguaje mediante macros. Esto significa que si una aplicación necesita un mecanismo de herencia diferente, puede usar un sistema de objetos distinto. Esto contrasta notablemente con la mayoría de los demás lenguajes; por ejemplo, Java no admite la herencia múltiple y no existe una forma razonable de añadirla.

En las implementaciones más sencillas de Lisp, esta estructura de lista se interpreta directamente para ejecutar el programa; una función es, literalmente, un fragmento de la estructura de lista que el intérprete recorre durante su ejecución. Sin embargo, la mayoría de los sistemas Lisp más complejos también incluyen un compilador. El compilador traduce la estructura de lista a código máquina o bytecode para su ejecución. Este código puede ejecutarse tan rápido como el código compilado en lenguajes convencionales como C.

Las macros se expanden antes del paso de compilación y, por lo tanto, ofrecen algunas opciones interesantes. Si un programa necesita una tabla precalculada, una macro podría crearla en tiempo de compilación, de modo que el compilador solo tendría que generar la tabla y no tendría que llamar a código para crearla en tiempo de ejecución. Algunas implementaciones de Lisp incluso tienen un mecanismo eval-whenque permite que el código esté presente durante el tiempo de compilación (cuando una macro lo necesitaría), pero no en el módulo generado. ^{[ 70 ]}

Los lenguajes Lisp se utilizan a menudo con una línea de comandos interactiva , que puede combinarse con un entorno de desarrollo integrado (IDE). El usuario introduce expresiones en la línea de comandos o le indica al IDE que las transmita al sistema Lisp. Lisp lee las expresiones introducidas, las evalúa e imprime el resultado. Por este motivo, la línea de comandos de Lisp se denomina bucle de lectura-evaluación-impresión ( REPL ).

El funcionamiento básico del REPL es el siguiente. Esta es una descripción simplificada que omite muchos elementos de un Lisp real, como las comillas y las macros.

La readfunción acepta expresiones S textuales como entrada y las analiza para convertirlas en una estructura de datos interna. Por ejemplo, si escribe el texto en la línea de comandos, lo traduce en una lista enlazada con tres elementos: el símbolo , el número 1 y el número 2. Resulta que esta lista también es un fragmento de código Lisp válido; es decir, se puede evaluar. Esto se debe a que el elemento de la lista nombra una función: la operación de suma.(+12)read+

A foose leerá como un solo símbolo. 123se leerá como el número ciento veintitrés. "123"se leerá como la cadena "123".

La evalfunción evalúa los datos y devuelve cero o más datos Lisp como resultado. La evaluación no tiene por qué significar interpretación; algunos sistemas Lisp compilan cada expresión a código máquina nativo. Sin embargo, es sencillo describir la evaluación como interpretación: para evaluar una lista cuyo nombre de función es, evalprimero se evalúan todos los argumentos dados en su cdr y luego se aplica la función a los argumentos. En este caso, la función es la suma, y ​​al aplicarla a la lista de argumentos se obtiene la respuesta . Este es el resultado de la evaluación.(12)3

El símbolo foose evalúa al valor del símbolo foo. Los datos como la cadena "123" se evalúan a la misma cadena. La lista se evalúa a la lista (1 2 3).(quote(123))

La printfunción se encarga de mostrar el resultado al usuario. Para un resultado sencillo como 3este, es trivial. Una expresión que se evalúa como una lista requeriría printrecorrerla e imprimirla como una expresión S.

Para implementar un REPL de Lisp, solo es necesario implementar estas tres funciones y una función de bucle infinito. (Naturalmente, la implementación de evalserá compleja, ya que también debe implementar todos los operadores especiales como ifo lambda.) Hecho esto, un REPL básico es una línea de código: .(loop(print(eval(read))))

La consola interactiva de Lisp también suele proporcionar edición de entrada, un historial de entrada, manejo de errores y una interfaz para el depurador.

Lisp se evalúa generalmente de forma inmediata . En Common Lisp , los argumentos se evalúan en orden aplicativo (del más a la izquierda al más interno), mientras que en Scheme el orden de los argumentos no está definido, lo que deja margen para la optimización por parte del compilador.

Lisp originalmente tenía muy pocas estructuras de control, pero se añadieron muchas más durante la evolución del lenguaje. (El operador condicional original de Lisp, cond, es el precursor de if-then-elseestructuras posteriores).

Los programadores en el dialecto Scheme a menudo expresan bucles usando recursión de cola . La frecuencia de Scheme en la informática académica ha llevado a algunos estudiantes a creer que la recursión de cola es la única, o la más común, forma de escribir iteraciones en Lisp, pero esto es incorrecto. Todos los dialectos Lisp que se ven con frecuencia tienen construcciones de iteración de estilo imperativo, desde el dobucle de Scheme hasta las expresiones complejas de Common Lisploop . Además, el problema clave que hace que esto sea un asunto objetivo en lugar de subjetivo es que Scheme establece requisitos específicos para el manejo de llamadas de cola , y por lo tanto la razón por la que el uso de la recursión de cola generalmente se fomenta para Scheme es que la práctica está expresamente respaldada por la definición del lenguaje. Por el contrario, ANSI Common Lisp no requiere ^{[ 71 ]} la optimización comúnmente denominada eliminación de llamadas de cola. Por lo tanto, el hecho de que el estilo recursivo de cola como reemplazo casual del uso de construcciones de iteración más tradicionales (como do, dolisto loop) se desaconseje ^{[ 72 ]} en Common Lisp no es solo una cuestión de preferencia estilística, sino potencialmente una cuestión de eficiencia (ya que una llamada de cola aparente en Common Lisp puede no compilarse como un salto simple ) y corrección del programa (ya que la recursión de cola puede aumentar el uso de la pila en Common Lisp, arriesgando un desbordamiento de pila ).

Algunas estructuras de control de Lisp son operadores especiales , equivalentes a las palabras clave sintácticas de otros lenguajes. Las expresiones que utilizan estos operadores tienen la misma apariencia superficial que las llamadas a funciones, pero se diferencian en que los argumentos no necesariamente se evalúan o, en el caso de una expresión de iteración, pueden evaluarse más de una vez.

A diferencia de la mayoría de los demás lenguajes de programación importantes, Lisp permite implementar estructuras de control utilizando el propio lenguaje. Varias estructuras de control se implementan como macros de Lisp, e incluso el programador que desee comprender su funcionamiento puede ampliarlas mediante macros.

Tanto Common Lisp como Scheme cuentan con operadores para el control de flujo no local. Las diferencias en estos operadores constituyen algunas de las diferencias más profundas entre ambos dialectos. Scheme admite continuaciones reentrantes mediante un call/ccprocedimiento que permite a un programa guardar (y posteriormente restaurar) un punto específico de la ejecución. Common Lisp no admite continuaciones reentrantes, pero sí ofrece varias formas de gestionar las continuaciones de escape.

A menudo, un mismo algoritmo puede expresarse en Lisp tanto en estilo imperativo como funcional. Como se mencionó anteriormente, Scheme tiende a favorecer el estilo funcional, utilizando recursión de cola y continuaciones para expresar el flujo de control. Sin embargo, el estilo imperativo sigue siendo perfectamente posible. El estilo preferido por muchos programadores de Common Lisp puede resultar más familiar para quienes están acostumbrados a lenguajes estructurados como C, mientras que el preferido por los programadores de Scheme se asemeja más a lenguajes puramente funcionales como Haskell .

Debido a su origen en el procesamiento de listas, Lisp cuenta con una amplia gama de funciones de orden superior relacionadas con la iteración sobre secuencias. En muchos casos donde se necesitaría un bucle explícito en otros lenguajes (como un forbucle en C), en Lisp la misma tarea se puede realizar con una función de orden superior. (Lo mismo ocurre con muchos lenguajes de programación funcional).

Un buen ejemplo es una función que en Scheme se llama mapy en Common Lisp se llama mapcar. Dada una función y una o más listas, mapcaraplica la función sucesivamente a los elementos de las listas en orden, recopilando los resultados en una nueva lista:

( mapacar #' + ' ( 1 2 3 4 5 ) ' ( 10 20 30 40 50 ))

Esto aplica la +función a cada par correspondiente de elementos de la lista, obteniendo el resultado .(1122334455)