View source for Lisp (programming language)

{{Short description|Programming language family}}
{{Redirect|LISP|the speech impediment|Lisp|other uses|Lisp (disambiguation)}}
{{Infobox programming language
| name = Lisp
| logo = Lisp logo.svg
| logo size = 150px
| paradigm = [[Multi-paradigm programming language|Multi-paradigm]]: [[Functional programming|functional]], [[Procedural programming|procedural]], [[Reflective programming|reflective]], [[Metaprogramming|meta]]
| released = {{Start date and age|1960}}
| designer = [[John McCarthy (computer scientist)|John McCarthy]]
| developer = [[Steve Russell (computer scientist)|Steve Russell]], Timothy P. Hart, Mike Levin
| latest release version =
| latest release date =
<!-- | turing-complete = Yes -->
| typing = [[Dynamic typing|Dynamic]], [[Strong and weak typing|strong]]
| implementations =
| dialects = {{startflatlist}}
* [[Arc (programming language)|Arc]]
* [[AutoLISP]]
* [[Clojure]]
* [[Common Lisp]]
* [[Emacs Lisp]]
* [[EuLisp]]
* [[Franz Lisp]]
* [[Game Oriented Assembly Lisp|GOAL]]
* [[Hy (programming language)|Hy]]
* [[Interlisp]]
* [[ISLISP]]
* [[LeLisp]]
* [[LFE (programming language)|LFE]]
* [[Maclisp]]
* [[MDL (programming language)|MDL]]
* [[newLISP]]
* [[NIL (programming language)|NIL]]
* [[Picolisp]]
* [[Portable Standard Lisp]]
* [[Racket (programming language)|Racket]]
* [[RPL (programming language)|RPL]]
* [[Scheme (programming language)|Scheme]]
* [[Cadence SKILL|SKILL]]
* [[Spice Lisp]]
* [[T (programming language)|T]]
* [[Zetalisp]]
{{endflatlist}}
| influenced by = [[Information Processing Language]] (IPL)
| influenced = {{startflatlist}}
* [[CLIPS]]
* [[CLU (programming language)|CLU]]
* [[COWSEL]]
* [[Dylan (programming language)|Dylan]]
* [[Elixir (programming language)|Elixir]]
* [[Microsoft Excel|Excel]]
* [[Forth (programming language)|Forth]]
* [[Haskell]]
* [[Io (programming language)|Io]]
* [[Ioke (programming language)|Ioke]]
* [[JavaScript]]
* [[Julia (programming language)|Julia]]<ref name="Julia">{{cite web |url=http://julia.readthedocs.org/en/latest/manual/introduction/ |title=Introduction |work=The Julia Manual |publisher=Read the Docs |access-date=2016-12-10 |archive-url=https://web.archive.org/web/20160408134008/http://julia.readthedocs.org/en/latest/manual/introduction/ |archive-date=2016-04-08}}</ref>
* [[Logo (programming language)|Logo]]
* [[Lua (programming language)|Lua]]
* [[ML (programming language)|ML]]
* [[Nim (programming language)|Nim]]
* [[Nu (programming language)|Nu]]
* [[OPS5]]
* [[Perl]]
* [[POP-2]]/[[POP-11|11]]
* [[Python (programming language)|Python]]
* [[R (programming language)|R]]
* [[Rebol]]
* [[Red (programming language)|Red]]
* [[Ruby (programming language)|Ruby]]
* [[Scala (programming language)|Scala]]
* [[Swift (programming language)|Swift]]
* [[Smalltalk]]
* [[Tcl]]
* [[Wolfram Language]]<ref name="Wolfram">{{cite web |url=https://www.wolfram.com/language/faq/ |title=Wolfram Language Q&A |publisher=Wolfram Research |access-date=2016-12-10}}</ref>{{endflatlist}}
}}

'''Lisp''' (historically '''LISP''', an abbreviation of "list processing") is a family of [[programming language]]s with a long history and a distinctive, fully [[parenthesized]] [[Polish notation#Explanation|prefix notation]].<ref name="6AN93">{{cite book |title=Milestones in computer science and information technology |author=Edwin D. Reilly |publisher=Greenwood Publishing Group |year=2003 |isbn=978-1-57356-521-9 |pages=156–157 |url=https://books.google.com/books?id=JTYPKxug49IC&pg=PA157}}</ref>
Originally specified in the late 1950s, it is the second-oldest [[high-level programming language]] still in common use, after [[Fortran]].<ref name="uOUnJ">{{cite web|url=http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-5.html|archive-url=https://web.archive.org/web/20010727170154/http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-5.html|archive-date=2001-07-27|quote=Lisp is a survivor, having been in use for about a quarter of a century. Among the active programming languages only Fortran has had a longer life.|title=SICP: Foreword}}</ref><ref name="AfFRW">{{cite web|url=http://www-formal.stanford.edu/jmc/history/lisp/node6.html#SECTION00060000000000000000|title=Conclusions|access-date=2014-06-04|archive-url=https://web.archive.org/web/20140403021353/http://www-formal.stanford.edu/jmc/history/lisp/node6.html#SECTION00060000000000000000|archive-date=2014-04-03}}</ref> Lisp has changed since its early days, and many [[Programming language dialect|dialects]] have existed over its history. Today, the best-known general-purpose Lisp dialects are [[Common Lisp]], [[Scheme (programming language)|Scheme]], [[Racket (programming language)|Racket]], and [[Clojure]].<ref>{{Cite book |last=Steele |first=Guy L. |title=Common Lisp: the language |date=1990 |publisher=Digital Press |isbn=1-55558-041-6 |edition=2nd |location=Bedford, MA |oclc=20631879}}</ref><ref>{{Cite web |last1=Felleisen |first1=Matthias |last2=Findler |first2=Robert |last3=Flatt |first3=Matthew |last4=Krishnamurthi |first4=Shriram |last5=Barzilay |first5=Eli |last6=McCarthy |first6=Jay |last7=Tobin-Hochstadt |first7=Sam |date=2015 |title="The Racket Manifesto" |url=https://www2.ccs.neu.edu/racket/pubs/manifesto.pdf}}</ref><ref>{{Cite web |title=Clojure - Differences with other Lisps |url=https://clojure.org/reference/lisps |access-date=2022-10-27 |website=clojure.org}}</ref>

Lisp was originally created as a practical [[mathematical notation]] for [[computer program]]s, influenced by (though not originally derived from)<ref name="Steele, Guy Lewis, Jr.; Sussman, Gerald Jay">{{cite web |url=https://dspace.mit.edu/handle/1721.1/6094/ |title=The Art of the Interpreter, or the Modularity Complex (Parts Zero, One, and Two), Part Zero, P. 4 |date=May 1978 |publisher=MIT Libraries |hdl=1721.1/6094 |access-date=2020-08-01|last1=Steele |first1=Guy Lewis |last2=Sussman |first2=Gerald Jay}}</ref> the notation of [[Alonzo Church]]'s [[lambda calculus]]. It quickly became a favored programming language for [[artificial intelligence]] (AI) research.<ref>{{Citation
 | last = Hofstadter
 | first = Douglas R.
 | title = Gödel, Escher, Bach: An Eternal Golden Braid (Twentieth Anniversary Edition)
 | publisher = Basic Books
 | year = 1999
 | orig-year= 1979
 | isbn = 0-465-02656-7
 | url = https://books.google.com/books?id=izy9Tg6rmb8C
 | page = 292
 | quote = One of the most important and fascinating of all computer languages is LISP (standing for "List Processing"), which was invented by John McCarthy around the time Algol was invented. Subsequently, LISP has enjoyed great popularity with workers in Artificial Intelligence.
}}</ref> As one of the earliest programming languages, Lisp pioneered many ideas in [[computer science]], including [[tree (data structure)|tree data structures]], [[garbage collection (computer science)|automatic storage management]], [[dynamic typing]], [[Conditional (computer programming)|conditionals]], [[higher-order function]]s, [[recursion (computer science)|recursion]], the [[Self-hosting (compilers)|self-hosting compiler]],<ref name="Graham">{{cite web |title=Revenge of the Nerds |author=Paul Graham |url=http://www.paulgraham.com/icad.html |access-date=2013-03-14}}</ref> and the [[read–eval–print loop]].<ref name="hC1qm">{{Cite book|url=http://www.informit.com/articles/article.aspx?p=1671639&seqNum=3|title=Influential Programming Languages, Part 4: Lisp|last=Chisnall|first=David|date=2011-01-12}}</ref>

The name ''LISP'' derives from "LISt Processor".<ref name="ArtOfLisp">{{cite book|last1=Jones|first1=Robin|last2=Maynard|first2=Clive|last3=Stewart|first3=Ian|title=The Art of Lisp Programming|date=December 6, 2012|publisher=Springer Science & Business Media|isbn=9781447117193|page=2}}</ref> [[Linked list]]s are one of Lisp's major [[data structure]]s, and Lisp [[source code]] is made of lists. Thus, Lisp programs can manipulate source code as a data structure, giving rise to the [[macro (computer science)|macro]] systems that allow programmers to create new syntax or new [[domain-specific language]]s embedded in Lisp.

The interchangeability of code and data gives Lisp its instantly recognizable syntax. All program code is written as ''[[s-expression]]s'', or parenthesized lists. A function call or syntactic form is written as a list with the function or operator's name first, and the arguments following; for instance, a function {{Lisp2|f}} that takes three arguments would be called as {{Lisp2|(f arg1 arg2 arg3)}}.

==History==
{{Multiple image |direction=vertical |image1=John McCarthy Stanford.jpg |image2=Steve Russell.jpg |footer=[[John McCarthy (computer scientist)|John McCarthy]] (top) and [[Steve Russell (computer scientist)|Steve Russell]]}}

[[John McCarthy (computer scientist)|John McCarthy]] began developing Lisp in 1958 while he was at the [[Massachusetts Institute of Technology]] (MIT). He was motivated by a desire to create an AI programming language that would work on the IBM 704, as he believed that "IBM looked like a good bet to pursue Artificial Intelligence research vigorously."<ref name="wexelblat-history-programming-languages">{{cite book |title=History of programming languages |last1=McCarthy |first1=John |last2=Wexelblat |first2=Richard L. |year=1978 |isbn=0127450408 |publisher=Association for Computing Machinery |pages=173–183}}</ref> He was inspired by [[Information Processing Language]], which was also based on list processing, but did not use it because it was designed for different hardware and he found an algebraic language more appealing.<ref name="wexelblat-history-programming-languages" /> Due to these factors, he consulted on the design of the [[Fortran]] List Processing Language, which was implemented as a Fortran library. However, he was dissatisfied with it because it did not support [[Recursion (computer science)|recursion]] or a modern [[Conditional (computer programming)#If–then(–else)|if-then-else]] statement (which was a new concept when lisp was first introduced) {{NoteTag|At the time, Fortran had an if-then-else construct that accepted line numbers as jump targets, in the manner of a [[Goto]] statement, rather than accepting arbitrary expression in "then" and "else" blocks}}.<ref name="wexelblat-history-programming-languages" />

McCarthy's original notation used bracketed "[[M-expression]]s" that would be translated into [[S-expression]]s. As an example, the M-expression {{Lisp2|car[cons[A,B]]}} is equivalent to the S-expression {{Lisp2|(car (cons A B))}}. Once Lisp was implemented, programmers rapidly chose to use S-expressions, and M-expressions were abandoned.<ref name="wexelblat-history-programming-languages"/> M-expressions surfaced again with short-lived attempts of [[MLisp]]<ref name="Smith">{{cite book |last=Smith |first=David Canfield |title=MLISP Users Manual |url=http://www.softwarepreservation.org/projects/LISP/stanford/Smith-MLISP-AIM-84.pdf |access-date=2006-10-13}}</ref> by Horace Enea and [[CGOL]] by [[Vaughan Pratt]].

Lisp was first implemented by [[Steve Russell (computer scientist)|Steve Russell]] on an [[IBM 704]] computer using [[punched card]]s.<ref name="4VwQq">{{Cite web |url=http://jmc.stanford.edu/articles/lisp/lisp.pdf |title=History of Lisp: Artificial Intelligence Laboratory |last=McCarthy |first=John |date=12 February 1979}}</ref> Russell was working for McCarthy's at the time and realized (to McCarthy's surprise) that the Lisp ''[[eval]]'' function could be implemented in [[machine code]].

According to McCarthy<ref name="k4CmX">{{cite conference |title=Early LISP history (1956–1959) |last1=Stoyan |first1=Herbert |date=1984-08-06 |page=307 |publisher=[[Association for Computing Machinery]] |book-title= |pages= |location= |conference=LFP '84: Proceedings of the 1984 ACM Symposium on LISP and functional programming |doi=10.1145/800055.802047|doi-access=free}}</ref>
{{Blockquote |text=Steve Russell said, look, why don't I program this ''eval''&nbsp;... and I said to him, ho, ho, you're confusing theory with practice, this ''eval'' is intended for reading, not for computing. But he went ahead and did it. That is, he [[Compiler|compiled]] the ''eval'' in my paper into [[IBM 704]] machine code, fixing [[Software bug|bugs]], and then advertised this as a Lisp interpreter, which it certainly was. So at that point Lisp had essentially the form that it has today&nbsp;...}}

The result was a working Lisp [[Interpreter (computing)|interpreter]] which could be used to run Lisp programs, or more properly, "evaluate Lisp expressions".

Two [[assembly language macros]] for the [[IBM 704]] became the primitive operations for decomposing lists: [[car and cdr|car]] (''Contents of the Address part of Register'' number) and [[car and cdr|cdr]] (''Contents of the Decrement part of Register'' number),<ref name="PREHISTORY">{{cite web |title=LISP prehistory - Summer 1956 through Summer 1958 |last=McCarthy |first=John |url=http://www-formal.stanford.edu/jmc/history/lisp/node2.html |access-date=2010-03-14}}</ref> where "register" refers to [[Processor register|registers]] of the computer's [[central processing unit]] (CPU). Lisp dialects still use {{Lisp2|car}} and {{Lisp2|cdr}} ({{IPAc-en|k|ɑːr}} and {{IPAc-en|ˈ|k|ʊ|d|ər}}) for the operations that return the first item in a list and the rest of the list, respectively.

McCarthy published Lisp's design in a paper in ''[[Communications of the ACM]]'' on April 1, 1960, entitled "Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I"<ref>{{cite web |last1=McCarthy |first1=John |title=Recursive functions of symbolic expressions and their computation by machine, Part I |url=https://dl.acm.org/doi/10.1145/367177.367199 |website=Association for computer machinery digital library |publisher=Association for computer machinery |access-date=28 February 2025}}</ref>.<ref name="McCarthy">{{cite web |title=Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I |last=McCarthy |first=John |url=http://www-formal.stanford.edu/jmc/recursive.html |access-date=2006-10-13 |archive-url=https://web.archive.org/web/20131004215327/http://www-formal.stanford.edu/jmc/recursive.html |archive-date=2013-10-04}}</ref> He showed that with a few simple operators and a notation for anonymous functions borrowed from Church, one can build a [[Turing completeness|Turing-complete]] language for algorithms.

The first complete Lisp compiler, written in Lisp, was implemented in 1962 by Tim Hart and Mike Levin at MIT, and could be compiled by simply having an existing LISP interpreter interpret the compiler code, producing [[machine code]] output able to be executed at a 40-fold improvement in speed over that of the interpreter.<ref name="Levin">{{cite web |title=AI Memo 39-The new compiler |last1=Hart |first1=Tim |last2=Levin |first2=Mike |url=ftp://publications.ai.mit.edu/ai-publications/pdf/AIM-039.pdf |archive-url=https://web.archive.org/web/20201213195043/ftp://publications.ai.mit.edu/ai-publications/pdf/AIM-039.pdf |archive-date=2020-12-13 |access-date=2019-03-18}}</ref> This compiler introduced the Lisp model of [[incremental compiler|incremental compilation]], in which compiled and interpreted functions can intermix freely. The language used in Hart and Levin's memo is much closer to modern Lisp style than McCarthy's earlier code.

[[Garbage collection (computer science)|Garbage collection]] routines were developed by MIT graduate student [[Daniel Edwards (programmer)|Daniel Edwards]], prior to 1962.<ref>{{cite book |title=LISP 1.5 Programmer's Manual |url=http://www.softwarepreservation.org/projects/LISP/book/LISP%201.5%20Programmers%20Manual.pdf |page=Preface |orig-date=1962 |year=1985 |version=15th printing |last1=McCarthy |first1=John |last2=Abrahams |first2=Paul W. |last3=Edwards |first3=Daniel J. |last4=Hart |first4=Timothy P. |last5=Levin |first5=Michael I. |edition=2nd}}</ref>

During the 1980s and 1990s, a great effort was made to unify the work on new Lisp dialects (mostly successors to [[Maclisp]] such as [[ZetaLisp]] and NIL (New Implementation of Lisp) into a single language. The new language, [[Common Lisp]], was somewhat compatible with the dialects it replaced (the book ''[[Common Lisp the Language]]'' notes the compatibility of various constructs). In 1994, [[ANSI]] published the Common Lisp standard, "ANSI X3.226-1994 Information Technology Programming Language Common Lisp".

=== Timeline ===
{{Lisp}}

===Connection to artificial intelligence===
Since inception, Lisp was closely connected with the [[artificial intelligence]] research community, especially on [[PDP-10]]<ref name="PYuEL">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. {{cite newsgroup |quote=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 |title=The History of TOPS or Life in the Fast ACs |newsgroup=alt.folklore.computers |message-id=84950@tut.cis.ohio-state.edu |date=18 October 1990 |author=Peter J. Hurley}}</ref> systems. Lisp was used as the implementation of the language [[Planner (programming language)|Micro Planner]], which was used in the famous AI system [[SHRDLU]]. In the 1970s, as AI research spawned commercial offshoots, the performance of existing Lisp systems became a growing issue, as programmers needed to be familiar with the performance ramifications of the various techniques and choices involved in the implementation of Lisp.<ref>{{Citation |last1=Steele |first1=Guy L. |title=The evolution of Lisp |date=January 1996 |url=http://dl.acm.org/doi/10.1145/234286.1057818 |work=History of programming languages---II |pages=233–330 |editor-last=Bergin |editor-first=Thomas J. |place=New York, NY, US |publisher=ACM |language=en |doi=10.1145/234286.1057818 |isbn=978-0-201-89502-5 |access-date=2022-07-25 |last2=Gabriel |first2=Richard P. |editor2-last=Gibson |editor2-first=Richard G.}}</ref>

===Genealogy and variants===
Over its sixty-year history, Lisp has spawned many variations on the core theme of an S-expression language. Some of these variations have been standardized and implemented by different groups with different priorities (for example, both [[Common Lisp]] and [[Scheme (programming language)|Scheme]] have multiple implementations). However, in other cases a software project defines a lisp without a standard and there is no clear distinction between the dialect and the implementation (for example, [[Clojure]] and [[Emacs Lisp]] fall into this category).

Differences between dialects (and/or implementations) may be quite visible—for instance, Common Lisp uses the keyword <code>defun</code> to name a function, but Scheme uses <code>define</code>.<ref name="jbyrI">Common Lisp: <code>(defun f (x) x)</code><br />Scheme: <code>(define f (lambda (x) x))</code> or <code>(define (f x) x)</code></ref> Within a dialect that is standardized conforming implementations support the same core language, but with different extensions and libraries. This sometimes also creates quite visible changes from the base language - for instance, [[GNU Guile|Guile]] (an implementation of Scheme) uses <code>define*</code> to create functions which can have [[default argument]]s and/or [[Named parameter|keyword arguments]], neither of which are standardized.

====Historically significant dialects====
[[File:LISP machine.jpg|thumb|right|A [[Lisp machine]] in the [[MIT Museum]]]]
[[File:4.3 BSD UWisc VAX Emulation Lisp Manual.png|thumb|[[4.3BSD]] from the [[University of Wisconsin]], displaying the [[man page]] for [[Franz Lisp]]]]
* LISP 1<ref name="Fs6VP">{{Cite book |last1=McCarthy |first1=J. |author-link=John McCarthy (computer scientist) |last2=Brayton |first2=R. |last3=Edwards |first3=D. |last4=Fox |first4=P. |author4-link=Phyllis Fox |last5=Hodes |first5=L. |author5-link=Louis Hodes |last6=Luckham |first6=D. |author6-link=David Luckham |last7=Maling |first7=K. |last8=Park |first8=D. |author8-link=David Park (computer scientist) |last9=Russell |first9=S. |author9-link=Steve Russell (computer scientist) |title=LISP I Programmers Manual |location=Boston |publisher=Artificial Intelligence Group, [[M.I.T. Computation Center]] and Research Laboratory |date=March 1960 |url=http://history.siam.org/sup/Fox_1960_LISP.pdf |archive-url=https://web.archive.org/web/20100717111134/http://history.siam.org/sup/Fox_1960_LISP.pdf |archive-date=2010-07-17}} Accessed May 11, 2010.</ref> – First implementation.
* LISP 1.5<ref name="1.5 manual">{{Cite book |url =http://www.softwarepreservation.org/projects/LISP/book/LISP%201.5%20Programmers%20Manual.pdf |title=LISP 1.5 Programmer's Manual |publisher=[[MIT Press]] |first1=John |last1=McCarthy |first2=Paul W. |last2=Abrahams |first3=Daniel J. |last3=Edwards |first4=Timothy P. |last4=Hart |first5=Michael I. |last5=Levin |isbn=0-262-13011-4 |orig-date=1962 |edition=2nd |year=1985}}</ref> – First widely distributed version, developed by McCarthy and others at MIT. So named because it contained several improvements on the original "LISP 1" interpreter, but was not a major restructuring as the planned [[LISP 2]] would be.
* Stanford LISP 1.6<ref name="7q5x9">{{Cite book |last1=Quam |first1=Lynn H. |last2=Diffle |first2=Whitfield |url=http://www.softwarepreservation.org/projects/LISP/stanford/SAILON-28.6.pdf |title=Stanford LISP 1.6 Manual}}</ref> – A successor to LISP 1.5 developed at the [[Stanford AI Lab]], and widely distributed to [[PDP-10]] systems running the [[TOPS-10]] operating system. It was rendered obsolete by Maclisp and InterLisp.
* [[Maclisp]]<ref name="UNDMs">{{cite web |url=http://zane.brouhaha.com/~healyzh/doc/lisp.doc.txt |title=Maclisp Reference Manual |date=March 3, 1979 |archive-url=https://web.archive.org/web/20071214064433/http://zane.brouhaha.com/~healyzh/doc/lisp.doc.txt |archive-date=2007-12-14}}</ref> – developed for MIT's [[Project MAC]], MACLISP is a direct descendant of LISP 1.5. It ran on the PDP-10 and [[Multics]] systems. MACLISP would later come to be called Maclisp, and is often referred to as MacLisp. The "MAC" in MACLISP is unrelated to Apple's [[Macintosh]] or [[John McCarthy (computer scientist)|McCarthy]].
* [[Interlisp]]<ref name="5CtB3">{{Cite book |url=http://www.bitsavers.org/pdf/xerox/interlisp/1974_InterlispRefMan.pdf |title=InterLisp Reference Manual |first=Warren |last=Teitelman |year=1974 |access-date=2006-08-19 |archive-url=https://web.archive.org/web/20060602134835/http://www.bitsavers.org/pdf/xerox/interlisp/1974_InterlispRefMan.pdf |archive-date=2006-06-02}}</ref> – developed at [[BBN Technologies]] for PDP-10 systems running the [[TENEX (operating system)|TENEX operating system]], later adopted as a "West coast" Lisp for the Xerox Lisp machines as [[InterLisp-D]]. A small version called "InterLISP 65" was published for the [[MOS Technology 6502]]-based [[Atari 8-bit computers]]. Maclisp and InterLisp were strong competitors.
* [[Franz Lisp]] – originally a [[University of California, Berkeley]] project; later developed by Franz Inc. The name is a humorous deformation of the name "[[Franz Liszt]]", and does not refer to [[Allegro Common Lisp]], the dialect of Common Lisp sold by Franz Inc., in more recent years.
* [[XLISP]], which [[AutoLISP]] was based on.
* [[Standard Lisp]] and [[Portable Standard Lisp]] were widely used and ported, especially with the Computer Algebra System REDUCE.
* [[ZetaLisp]], also termed Lisp Machine Lisp – used on the [[Lisp machine]]s, direct descendant of Maclisp. ZetaLisp had a big influence on Common Lisp.
* [[LeLisp]] is a French Lisp dialect. One of the first [[Graphical user interface builder|Interface Builders]] (called SOS Interface<ref name="pq98z">[https://hal.archives-ouvertes.fr/file/index/docid/70041/filename/RT-0126.pdf Outils de generation d'interfaces : etat de l'art et classification by H. El Mrabet]</ref>) was written in LeLisp.
* [[Scheme (programming language)|Scheme]] (1975).<ref name="dp6Mp">{{cite web |author1=Gerald Jay Sussman |author2=Guy Lewis Steele Jr. |name-list-style=amp |title=Scheme: An Interpreter for Extended Lambda Calculus |website=[[MIT Computer Science and Artificial Intelligence Laboratory|MIT AI Lab]] |id=AIM-349 |date=December 1975 |url=https://dspace.mit.edu/bitstream/handle/1721.1/5794/AIM-349.pdf|access-date=23 December 2021}}</ref>
* [[Common Lisp]] (1984), as described by ''[[Common Lisp the Language]]'' – a consolidation of several divergent attempts (ZetaLisp, [[Spice Lisp]], [[NIL (programming language)|NIL]], and [[S-1 Lisp]]) to create successor dialects<ref name="Rb5BT">{{Cite book |chapter-url=https://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node6.html |title=Common Lisp the Language |edition=2nd |chapter=Purpose |first=Guy L. Jr. |last=Steele |year=1990 |publisher=Digital Press |isbn=0-13-152414-3}}</ref> to Maclisp, with substantive influences from the Scheme dialect as well. This version of Common Lisp was available for wide-ranging platforms and was accepted by many as a [[de facto standard]]<ref name="Xvsoj">{{cite web |url=https://www.cs.cmu.edu/Groups/AI/html/faqs/lang/lisp/part2/faq-doc-13.html |title=History: Where did Lisp come from? |work=FAQ: Lisp Frequently Asked Questions 2/7 |date=20 February 1996 |first1=Mark |last1=Kantrowitz |first2=Barry |last2=Margolin}}</ref> until the publication of ANSI Common Lisp (ANSI X3.226-1994). Among the most widespread sub-dialects of Common Lisp are [[Steel Bank Common Lisp]] (SBCL), CMU Common Lisp (CMU-CL), Clozure OpenMCL (not to be confused with Clojure!), GNU CLisp, and later versions of Franz Lisp; all of them adhere to the later ANSI CL standard (see below).
* [[Dylan (programming language)|Dylan]] was in its first version a mix of Scheme with the Common Lisp Object System.
* [[EuLisp]] – attempt to develop a new efficient and cleaned-up Lisp.
* [[ISLISP]] – attempt to develop a new efficient and cleaned-up Lisp. Standardized as ISO/IEC 13816:1997<ref name="E4h75">{{cite web|url=http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=22987 |title=ISO/IEC 13816:1997 |publisher=Iso.org |date=2007-10-01 |access-date=2013-11-15}}</ref> and later revised as ISO/IEC 13816:2007:<ref name="xECKU">{{cite web|url=http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=44338 |title=ISO/IEC 13816:2007 |publisher=Iso.org |date=2013-10-30 |access-date=2013-11-15}}</ref> ''Information technology – Programming languages, their environments and system software interfaces – Programming language ISLISP''.
* IEEE [[Scheme (programming language)|Scheme]] – IEEE standard, 1178–1990 (R1995).
* ANSI [[Common Lisp]] – an [[American National Standards Institute]] (ANSI) [[Standardization|standard]] for Common Lisp, created by subcommittee [[X3J13]], chartered<ref name="CAXAD">{{cite web |url=http://www.nhplace.com/kent/CL/x3j13-86-020.html |title=X3J13 Charter}}</ref> to begin with ''Common Lisp: The Language'' as a base document and to work through a public [[Consensus decision-making|consensus]] process to find solutions to shared issues of [[Portability (software)|portability]] of programs and [[Computer compatibility|compatibility]] of Common Lisp implementations. Although formally an ANSI standard, the implementation, sale, use, and influence of ANSI Common Lisp has been and continues to be seen worldwide.
* [[ACL2]] or "A Computational Logic for Applicative Common Lisp", an applicative (side-effect free) variant of Common LISP. ACL2 is both a programming language which can model computer systems, and a tool to help proving properties of those models.
* [[Clojure]], a recent dialect of Lisp which compiles to the [[Java virtual machine]] and has a particular focus on [[Concurrency (computer science)|concurrency]].
* [[Game Oriented Assembly Lisp]] (or GOAL) is a video game programming language developed by [[Andy Gavin]] at [[Naughty Dog]]. It was written using Allegro Common Lisp and used in the development of the entire [[Jak and Daxter|Jak and Daxter series of games]] developed by Naughty Dog.

===2000 to present===
After having declined somewhat in the 1990s, Lisp has experienced a resurgence of interest after 2000. Most new activity has been focused around implementations of [[Common Lisp]], [[Scheme (programming language)|Scheme]], [[Emacs Lisp]], [[Clojure]], and [[Racket (programming language)|Racket]], and includes development of new portable libraries and applications.

Many new Lisp programmers were inspired by writers such as [[Paul Graham (computer programmer)|Paul Graham]] and [[Eric S. Raymond]] to pursue a language others considered antiquated. New Lisp programmers often describe the language as an eye-opening experience and claim to be substantially more productive than in other languages.<ref name="sKh98">{{cite web |title=The Road To Lisp Survey |url=http://wiki.alu.org/The_Road_To_Lisp_Survey |access-date=2006-10-13 |archive-url=https://web.archive.org/web/20061004031130/http://wiki.alu.org/The_Road_To_Lisp_Survey |archive-date=2006-10-04}}</ref> This increase in awareness may be contrasted to the "[[AI winter]]" and Lisp's brief gain in the mid-1990s.<ref name="nb7MB">{{cite web |url=http://www.faqs.org/docs/artu/ch14s05.html |title=Trends for the Future |publisher=Faqs.org |access-date=2013-11-15 |archive-date=2013-06-03 |archive-url=https://web.archive.org/web/20130603002452/http://www.faqs.org/docs/artu/ch14s05.html}}</ref>

{{As of|2010}}, there were eleven actively maintained Common Lisp implementations.<ref name="sWbGt">{{cite web|last=Weinreb|first=Daniel|title=Common Lisp Implementations: A Survey|url=http://common-lisp.net/~dlw/LispSurvey.html|access-date=4 April 2012|archive-url=https://web.archive.org/web/20120421181340/http://common-lisp.net/~dlw/LispSurvey.html|archive-date=2012-04-21}}</ref>

The [[open-source-software movement|open source]] community has created new supporting infrastructure: [[CLiki]] is a wiki that collects Common Lisp related information, the [[Common Lisp directory]] lists resources, #lisp is a popular IRC channel and allows the sharing and commenting of code snippets (with support by [[lisppaste]], an [[IRC bot]] written in Lisp), [[Planet Lisp]]<ref>{{cite web|url=https://planet.lisp.org/|title=Planet Lisp|access-date=2023-10-12}}</ref> collects the contents of various Lisp-related blogs, on [[LispForum]]<ref>{{cite web|url=https://lispforum.com|title=LispForum|access-date=2023-10-12}}</ref> users discuss Lisp topics, [[Lispjobs]]<ref>{{cite web|url=https://lispjobs.wordpress.com/|title=Lispjobs|access-date=2023-10-12}}</ref> is a service for announcing job offers and there is a weekly news service, ''[[Weekly Lisp News]]''. ''Common-lisp.net'' is a hosting site for open source Common Lisp projects. [[Quicklisp]]<ref>{{cite web|url=https://www.quicklisp.org|title=Quicklisp|access-date=2023-10-12}}</ref> is a library manager for Common Lisp.

Fifty years of Lisp (1958–2008) was celebrated at LISP50@OOPSLA.<ref name="Q9GcA">{{cite web|url=http://www.lisp50.org/ |title=LISP50@OOPSLA |publisher=Lisp50.org |access-date=2013-11-15}}</ref> There are regular local user meetings in Boston, Vancouver, and Hamburg. Other events include the European Common Lisp Meeting, the European Lisp Symposium and an International Lisp Conference.

The Scheme community actively maintains [[Scheme (programming language)#Implementations|over twenty implementations]]. Several significant new implementations (Chicken, Gambit, Gauche, Ikarus, Larceny, Ypsilon) have been developed in the 2000s (decade). The Revised<sup>5</sup> Report on the Algorithmic Language Scheme<ref name="92GaL">[http://www.schemers.org/Documents/Standards/R5RS/ Documents: Standards: R5RS]. schemers.org (2012-01-11). Retrieved on 2013-07-17.</ref> standard of Scheme was widely accepted in the Scheme community. The [[Scheme Requests for Implementation]] process has created a lot of quasi-standard libraries and extensions for Scheme. User communities of individual Scheme implementations continue to grow. A new language standardization process was started in 2003 and led to the R<sup>6</sup>RS Scheme standard in 2007. Academic use of Scheme for teaching computer science seems to have declined somewhat. Some universities are no longer using Scheme in their computer science introductory courses;<ref name="yVta1">{{cite news|url=http://cemerick.com/2009/03/24/why-mit-now-uses-python-instead-of-scheme-for-its-undergraduate-cs-program/|title=Why MIT now uses python instead of scheme for its undergraduate CS program|date=March 24, 2009|work=cemerick.com|access-date=November 10, 2013|archive-date=September 17, 2010|archive-url=https://web.archive.org/web/20100917102705/http://cemerick.com/2009/03/24/why-mit-now-uses-python-instead-of-scheme-for-its-undergraduate-cs-program/}}</ref><ref name="XOiAA">{{cite news|url=http://mitadmissions.org/blogs/entry/the_end_of_an_era_1|title=The End of an Era|first=Evan|last=Broder|date=January 8, 2008|work=mitadmissions.org|access-date=November 10, 2013}}</ref> MIT now uses [[Python (programming language)|Python]] instead of Scheme for its undergraduate [[computer science]] program and MITx massive open online course.<ref name="MITEECS-Python">{{cite web |title=MIT EECS Undergraduate Programs |url=https://www.eecs.mit.edu/academics-admissions/undergraduate-programs |website=www.eecs.mit.edu |publisher=MIT Electrical Engineering & Computer Science |access-date=31 December 2018}}</ref><ref name="MITx-Phyton">{{cite web |title=MITx introductory Python course hits 1.2 million enrollments |url=https://www.eecs.mit.edu/news-events/announcements/mitx-introductory-python-course-hits-12-million-enrollments |website=MIT EECS |publisher=MIT Electrical Engineering & Computer Science |access-date=31 December 2018}}</ref>

There are several new dialects of Lisp: [[Arc (programming language)|Arc]], [[Hy (programming language)|Hy]], [[Nu (programming language)|Nu]], [[Liskell]], and [[LFE (programming language)|LFE]] (Lisp Flavored Erlang). The parser for [[Julia (programming language)|Julia]] is implemented in Femtolisp, a dialect of [[Scheme (programming language)|Scheme]] (Julia is inspired by Scheme, which in turn is a Lisp dialect).

In October 2019, [[Paul Graham (programmer)|Paul Graham]] released [http://paulgraham.com/bel.html a specification for Bel], "a new dialect of Lisp."

==Major dialects==
[[Common Lisp]] and [[Scheme (programming language)|Scheme]] represent two major streams of Lisp development. These languages embody significantly different design choices.

[[Common Lisp]] is a successor to [[Maclisp]]. The primary influences were [[Lisp Machine Lisp]], Maclisp, [[NIL (programming language)|NIL]], [[S-1 Lisp]], [[Spice Lisp]], and Scheme.<ref name="uMuJD">Chapter 1.1.2, History, ANSI CL Standard</ref> It has many of the features of Lisp Machine Lisp (a large Lisp dialect used to program [[Lisp Machine]]s), but was designed to be efficiently implementable on any personal computer or workstation. Common Lisp is a general-purpose programming language and thus has a large language standard including many built-in data types, functions, macros and other language elements, and an object system ([[Common Lisp Object System]]). Common Lisp also borrowed certain features from Scheme such as [[lexical scoping]] and [[lexical closure]]s. Common Lisp implementations are available for targeting different platforms such as the [[LLVM]],<ref name="hEWIZ">[https://www.cliki.net/Clasp] Clasp is a Common Lisp implementation that interoperates with C++ and uses LLVM for [[just-in-time compilation]] (JIT) to native code.</ref> the [[Java virtual machine]],<ref name="vBfvI">[https://common-lisp.net/project/armedbear/] "Armed Bear Common Lisp (ABCL) is a full implementation of the Common Lisp language featuring both an interpreter and a compiler, running in the JVM"</ref>
x86-64, PowerPC, Alpha, ARM, Motorola 68000, and MIPS,<ref name="za6Q8">[https://common-lisp.net/~dlw/LispSurvey.html] {{Webarchive|url=https://web.archive.org/web/20180622083812/https://common-lisp.net/~dlw/LispSurvey.html|date=2018-06-22}} Common Lisp Implementations: A Survey</ref> and operating systems such as Windows, macOS, Linux, Solaris, FreeBSD, NetBSD, OpenBSD, Dragonfly BSD, and Heroku.<ref name="QX6kG">[https://www.cliki.net/Common+Lisp+implementation] Comparison of actively developed Common Lisp implementations</ref>

Scheme is a statically scoped and properly tail-recursive dialect of the Lisp programming language invented by [[Guy L. Steele, Jr.]] and [[Gerald Jay Sussman]]. It was designed to have exceptionally clear and simple semantics and few different ways to form expressions. Designed about a decade earlier than Common Lisp, [[Scheme (programming language)|Scheme]] is a more minimalist design. It has a much smaller set of standard features but with certain implementation features (such as [[tail-call optimization]] and full [[continuation]]s) not specified in Common Lisp. A wide variety of programming paradigms, including imperative, functional, and message passing styles, find convenient expression in Scheme. Scheme continues to evolve with a series of standards (Revised<sup>n</sup> Report on the Algorithmic Language Scheme) and a series of [[Scheme Requests for Implementation]].

[[Clojure]] is a dialect of Lisp that targets mainly the [[Java virtual machine]], and the [[Common Language Runtime]] (CLR), the [[Python (programming language)|Python]] VM, the Ruby VM [[YARV]], and compiling to [[JavaScript]]. It is designed to be a pragmatic general-purpose language. Clojure draws considerable influences from [[Haskell]] and places a very strong emphasis on immutability.<ref name="clojure-immutability">[http://www.infoq.com/articles/in-depth-look-clojure-collections An In-Depth Look at Clojure Collections], Retrieved 2012-06-24</ref> Clojure provides access to Java frameworks and libraries, with optional type hints and [[type inference]], so that calls to Java can avoid reflection and enable fast primitive operations. Clojure is not designed to be backwards compatible with other Lisp dialects.<ref name="f6C82">{{cite web |title=Clojure rational |url=https://clojure.org/about/rationale |access-date=27 August 2019 |quote=Clojure is a Lisp not constrained by backwards compatibility}}</ref>

Further, Lisp dialects are used as [[scripting language]]s in many applications, with the best-known being [[Emacs Lisp]] in the [[Emacs]] editor, [[AutoLISP]] and later [[Visual Lisp]] in [[AutoCAD]], Nyquist in [[Audacity (audio editor)|Audacity]], and Scheme in [[LilyPond]]. The potential small size of a useful Scheme interpreter makes it particularly popular for embedded scripting. Examples include [[SIOD]] and [[TinyScheme]], both of which have been successfully embedded in the [[GIMP]] image processor under the generic name "Script-fu".<ref name="script-fu">[http://www.gimp.org/docs/script-fu-update.html Script-fu In GIMP 2.4], Retrieved 2009-10-29</ref> LIBREP, a Lisp interpreter by John Harper originally based on the [[Emacs Lisp]] language, has been embedded in the [[Sawfish (window manager)|Sawfish]] [[window manager]].<ref name="librep">[http://sawfish.wikia.com/wiki/Librep librep] at Sawfish Wikia, retrieved 2009-10-29</ref>

===Standardized dialects===

Lisp has officially standardized dialects: [[Scheme (programming language)#R6RS|R6RS Scheme]], [[Scheme (programming language)#R7RS|R7RS Scheme]], IEEE Scheme,<ref name="LQgpj">{{cite web |url=https://standards.ieee.org/ieee/1178/1787/ |website=IEEE 1178-1990 - IEEE Standard for the Scheme Programming Language |access-date=27 August 2019 |title=IEEE Scheme}}</ref> [[ANSI Common Lisp]] and ISO [[ISLISP]].

==Language innovations==
[[Paul Graham (programmer)|Paul Graham]] identifies nine important aspects of Lisp that distinguished it from existing languages like [[Fortran]]:<ref>{{Cite web |title=What Made Lisp Different |date=May 2002 |url=http://paulgraham.com/diff.html |author=Paul Graham}}</ref>
* [[Conditional (computer programming)|Conditionals]] not limited to [[goto]]
* [[First-class function]]s
* [[Recursion]]
* Treating variables uniformly as [[Pointer (computer programming)|pointers]], leaving types to values
* [[Garbage collection (computer science)|Garbage collection]]
* Programs made entirely of [[Expression (computer science)|expressions]] with no [[Statement (computer science)|statements]]
* The [[Symbol (programming)|symbol]] data type, distinct from the [[String (computer science)|string]] data type
* Notation for code made of trees of symbols (using many [[parentheses]])
* Full language available at [[load time]], [[compile time]], and [[Runtime (program lifecycle phase)|run time]]

Lisp was the first language where the structure of program code is represented faithfully and directly in a standard data structure—a quality much later dubbed "[[homoiconicity]]". Thus, Lisp functions can be manipulated, altered or even created within a Lisp program without lower-level manipulations. This is generally considered one of the main advantages of the language with regard to its expressive power, and makes the language suitable for syntactic macros and [[meta-circular evaluator|meta-circular evaluation]].

A conditional using an ''[[if–then–else]]'' syntax was invented by McCarthy for a chess program written in [[Fortran]]. He proposed its inclusion in [[ALGOL]], but it was not made part of the [[Algol 58]] specification. For Lisp, McCarthy used the more general ''cond''-structure.<ref name="bUXap">{{cite web|url=http://www-formal.stanford.edu/jmc/history/lisp/node2.html|title=LISP prehistory - Summer 1956 through Summer 1958.|quote=I invented conditional expressions in connection with a set of chess legal move routines I wrote in FORTRAN for the IBM 704 at M.I.T. during 1957–58&nbsp;... A paper defining conditional expressions and proposing their use in Algol was sent to the Communications of the ACM but was arbitrarily demoted to a letter to the editor, because it was very short.}}</ref> [[Algol 60]] took up ''if–then–else'' and popularized it.

Lisp deeply influenced [[Alan Kay]], the leader of the research team that developed [[Smalltalk]] at [[Xerox PARC]]; and in turn Lisp was influenced by Smalltalk, with later dialects adopting object-oriented programming features (inheritance classes, encapsulating instances, message passing, etc.) in the 1970s. The [[Flavors (programming language)|Flavors]] object system introduced the concept of [[multiple inheritance]] and the [[mixin]]. The [[Common Lisp Object System]] provides multiple inheritance, multimethods with [[multiple dispatch]], and first-class [[generic functions]], yielding a flexible and powerful form of [[dynamic dispatch]]. It has served as the template for many subsequent Lisp (including [[Scheme (programming language)|Scheme]]) object systems, which are often implemented via a [[Metaobject#Metaobject Protocol|metaobject protocol]], a [[Reflective programming|reflective]] [[Meta-circular evaluator|meta-circular design]] in which the object system is defined in terms of itself: Lisp was only the second language after Smalltalk (and is still one of the very few languages) to possess such a metaobject system. Many years later, Alan Kay suggested that as a result of the confluence of these features, only Smalltalk and Lisp could be regarded as properly conceived object-oriented programming systems.<ref name="4I08d">{{cite web|date=2003-07-23|url=http://userpage.fu-berlin.de/~ram/pub/pub_jf47ht81Ht/doc_kay_oop_en|title=Meaning of 'Object-Oriented Programming' According to Dr. Alan Kay|quote=I didn't understand the monster LISP idea of tangible metalanguage then, but got kind of close with ideas about extensible languages&nbsp;... The second phase of this was to finally understand LISP and then using this understanding to make much nicer and smaller and more powerful and more late bound understructures&nbsp;... OOP to me means only messaging, local retention and protection and hiding of state-process, and extreme late-binding of all things. It can be done in Smalltalk and in LISP. There are possibly other systems in which this is possible, but I'm not aware of them.}}</ref>

Lisp introduced the concept of [[Garbage collection (computer science)|automatic garbage collection]], in which the system walks the [[Heap (memory management)|heap]] looking for unused memory. Progress in modern sophisticated garbage collection algorithms such as generational garbage collection was stimulated by its use in Lisp.<ref name="dpvwj">{{citation |last1=Lieberman |first1=Henry |last2=Hewitt |first2=Carl |title=A Real-Time Garbage Collector Based on the Lifetimes of Objects |url=http://web.media.mit.edu/~lieber/Lieberary/GC/Realtime/Realtime.html |journal=Communications of the ACM |volume=26 |issue=6 |date=June 1983 |pages=419–429 |doi=10.1145/358141.358147|hdl=1721.1/6335 |citeseerx=10.1.1.4.8633 |s2cid=14161480}}</ref>

[[Edsger W. Dijkstra]] in his 1972 [[Turing Award]] lecture said,
{{Blockquote|With a few very basic principles at its foundation, it [LISP] has shown a remarkable stability. Besides that, LISP has been the carrier for a considerable number of in a sense our most sophisticated computer applications. LISP has jokingly been described as "the most intelligent way to misuse a computer". I think that description a great compliment because it transmits the full flavour of liberation: it has assisted a number of our most gifted fellow humans in thinking previously impossible thoughts.<ref name="v8uNE">{{citation|url=http://www.cs.utexas.edu/~EWD/transcriptions/EWD03xx/EWD340.html|author=Edsger W. Dijkstra|year=1972|title=The Humble Programmer (EWD 340)}} (ACM Turing Award lecture).</ref>}}

Largely because of its resource requirements with respect to early computing hardware (including early microprocessors), Lisp did not become as popular outside of the [[AI]] community as [[Fortran]] and the [[ALGOL]]-descended [[C (programming language)|C]] language. Because of its suitability to complex and dynamic applications, Lisp enjoyed some resurgence of popular interest in the 2010s.<ref name="chI3V">{{cite web|url=https://www.linkedin.com/pulse/look-clojure-lisp-resurgence-todd-towles|title=A Look at Clojure and the Lisp Resurgence}}</ref>

==Syntax and semantics==
:''This article's examples are written in [[Common Lisp]] (though most are also valid in [[Scheme (programming language)|Scheme]]).''

===Symbolic expressions (S-expressions)===
Lisp is an [[expression oriented language]]. Unlike most other languages, no distinction is made between "expressions" and [[Statement (programming)|"statements"]];{{dubious|date=April 2013}}<!-- (progn ...), (setq ...). There is no syntactic distinction, but sequential evaluation is there. --> all code and data are written as expressions. When an expression is ''evaluated'', it produces a value (possibly multiple values), which can then be embedded into other expressions. Each value can be any data type.

McCarthy's 1958 paper introduced two types of syntax: ''Symbolic expressions'' ([[S-expression]]s, sexps), which mirror the internal representation of code and data; and ''Meta expressions'' ([[M-expression]]s), which express functions of S-expressions. M-expressions never found favor, and almost all Lisps today use S-expressions to manipulate both code and data.

The use of parentheses is Lisp's most immediately obvious difference from other programming language families. As a result, students have long given Lisp nicknames such as ''Lost In Stupid Parentheses'', or ''Lots of Irritating Superfluous Parentheses''.<ref name="LEVIN2">{{cite web |title=The Jargon File - Lisp |url=http://www.catb.org/~esr/jargon/html/L/LISP.html |access-date=2006-10-13}}</ref><!-- Add NO more nicknames. People can check the Jargon File for them. --> However, the S-expression syntax is also responsible for much of Lisp's power: the syntax is simple and consistent, which facilitates manipulation by computer. However, the syntax of Lisp is not limited to traditional parentheses notation. It can be extended to include alternative notations. For example, XMLisp is a Common Lisp extension that employs the [[Metaobject#Metaobject protocol|metaobject protocol]] to integrate S-expressions with the Extensible Markup Language ([[XML]]).

The reliance on expressions gives the language great flexibility. Because Lisp [[function (programming)|functions]] are written as lists, they can be processed exactly like data. This allows easy writing of programs which manipulate other programs ([[metaprogramming]]). Many Lisp dialects exploit this feature using macro systems, which enables extension of the language almost without limit.

===Lists===
A Lisp list is written with its elements separated by [[Whitespace character|whitespace]], and surrounded by parentheses. For example, {{Lisp2|(1 2 foo)}} is a list whose elements are the three ''atoms'' {{Lisp2|1}}, {{Lisp2|2}}, and [[foo|{{#tag:syntaxhighlight|foo|lang=Lisp|inline=1}}]]. These values are implicitly typed: they are respectively two integers and a Lisp-specific data type called a "symbol", and do not have to be declared as such.

The empty list {{Lisp2|()}} is also represented as the special atom {{Lisp2|nil}}. This is the only entity in Lisp which is both an atom and a list.

Expressions are written as lists, using [[Polish notation|prefix notation]]. The first element in the list is the name of a function, the name of a macro, a lambda expression or the name of a "special operator" (see below). The remainder of the list are the arguments. For example, the function {{Lisp2|list}} returns its arguments as a list, so the expression
<syntaxhighlight lang="Lisp">
 (list 1 2 (quote foo))
</syntaxhighlight>
evaluates to the list {{Lisp2|(1 2 foo)}}. The "quote" before the {{Lisp2|foo}} in the preceding example is a "special operator" which returns its argument without evaluating it. Any unquoted expressions are recursively evaluated before the enclosing expression is evaluated. For example,
<syntaxhighlight lang="Lisp">
 (list 1 2 (list 3 4))
</syntaxhighlight>
evaluates to the list {{Lisp2|(1 2 (3 4))}}. The third argument is a list; lists can be nested.

===Operators===
Arithmetic operators are treated similarly. The expression
<syntaxhighlight lang="Lisp">
 (+ 1 2 3 4)
</syntaxhighlight>
evaluates to 10. The equivalent under [[infix notation]] would be "{{Lisp2|1 + 2 + 3 + 4}}".

Lisp has no notion of operators as implemented in [[ALGOL]]-derived languages. Arithmetic operators in Lisp are [[variadic function]]s (or ''n-ary''), able to take any number of arguments. A C-style '++' increment operator is sometimes implemented under the name <code>incf</code> giving syntax
<syntaxhighlight lang="Lisp">
 (incf x)
</syntaxhighlight>
equivalent to <code>(setq x (+ x 1))</code>, returning the new value of <code>x</code>.

"Special operators" (sometimes called "special forms") provide Lisp's control structure. For example, the special operator {{Lisp2|if}} takes three arguments. If the first argument is non-nil, it evaluates to the second argument; otherwise, it evaluates to the third argument. Thus, the expression
<syntaxhighlight lang="Lisp">
 (if nil
     (list 1 2 "foo")
     (list 3 4 "bar"))
</syntaxhighlight>
evaluates to {{Lisp2|(3 4 "bar")}}. Of course, this would be more useful if a non-trivial expression had been substituted in place of {{Lisp2|nil}}.

Lisp also provides logical operators '''and''', '''or''' and '''not'''. The '''and''' and '''or''' operators do [[short-circuit evaluation]] and will return their first nil and non-nil argument respectively.
<syntaxhighlight lang="Lisp">
 (or (and "zero" nil "never") "James" 'task 'time)
</syntaxhighlight>
will evaluate to "James".

===Lambda expressions and function definition===
Another special operator, {{Lisp2|lambda}}, is used to bind variables to values which are then evaluated within an expression. This operator is also used to create functions: the arguments to {{Lisp2|lambda}} are a list of arguments, and the expression or expressions to which the function evaluates (the returned value is the value of the last expression that is evaluated). The expression
<syntaxhighlight lang="Lisp">
 (lambda (arg) (+ arg 1))
</syntaxhighlight>
evaluates to a function that, when applied, takes one argument, binds it to {{Lisp2|arg}} and returns the number one greater than that argument. Lambda expressions are treated no differently from named functions; they are invoked the same way. Therefore, the expression
<syntaxhighlight lang="Lisp">
 ((lambda (arg) (+ arg 1)) 5)
</syntaxhighlight>
evaluates to {{Lisp2|6}}. Here, we're doing a function application: we execute the [[anonymous function]] by passing to it the value 5.

Named functions are created by storing a lambda expression in a symbol using the defun macro.
<syntaxhighlight lang="Lisp">
 (defun foo (a b c d) (+ a b c d))
</syntaxhighlight>

{{Lisp2|(defun f (a) b...)}} defines a new function named {{Lisp2|f}} in the global environment. It is conceptually similar to the expression:

<syntaxhighlight lang="Lisp">
 (setf (fdefinition 'f) #'(lambda (a) (block f b...)))
</syntaxhighlight>

where {{Lisp2|setf}} is a macro used to set the value of the first argument {{Lisp2|fdefinition 'f}} to a new function object. {{Lisp2|fdefinition}} is a global function definition for the function named {{Lisp2|f}}. {{Lisp2|#'}} is an abbreviation for {{Lisp2|function}} special operator, returning a function object.

===Atoms===
In the original '''LISP''' there were two fundamental [[data type]]s: atoms and lists. A list was a finite ordered sequence of elements, where each element is either an atom or a list, and an atom was a [[number]] or a symbol. A symbol was essentially a unique named item, written as an [[alphanumeric]] string in [[source code]], and used either as a variable name or as a data item in [[symbolic processing]]. For example, the list {{Lisp2|(FOO (BAR 1) 2)}} contains three elements: the symbol {{Lisp2|FOO}}, the list {{Lisp2|(BAR 1)}}, and the number 2.

The essential difference between atoms and lists was that atoms were immutable and unique. Two atoms that appeared in different places in source code but were written in exactly the same way represented the same object,{{Citation needed|date=November 2008}} whereas each list was a separate object that could be altered independently of other lists and could be distinguished from other lists by comparison operators.

As more data types were introduced in later Lisp dialects, and [[programming style]]s evolved, the concept of an atom lost importance.{{Citation needed|date=November 2008}} Many dialects still retained the predicate ''atom'' for [[legacy compatibility]],{{Citation needed|date=November 2008}} defining it true for any object which is not a cons.

===Conses and lists===
{{Main|Cons}}
[[File:Cons-cells.svg|thumb|right|300px|Box-and-[[pointer (computer programming)|pointer]] diagram for the list (42 69 613)]]
A Lisp list is implemented as a [[singly linked list]].<ref name="SebestaLanguages">{{cite book |last1=Sebesta |first1=Robert W. |title=Concepts of Programming Languages |chapter="2.4 Functional Programming: LISP";"6.9 List Types";"15.4 The First Functional Programming Language: LISP" |date=2012 |publisher=Addison-Wesley |location=Boston, MA, US |isbn=978-0-13-139531-2 |pages=47–52;281–284;677–680 |edition=10th |url=https://www.pearson.com/us/higher-education/product/Sebesta-Concepts-of-Programming-Languages-10th-Edition/9780131395312.html |language=en |format=print}}</ref> Each cell of this list is called a ''cons'' (in Scheme, a ''pair'') and is composed of two [[pointer (computer programming)|pointers]], called the ''car'' and ''cdr''. These are respectively equivalent to the {{Lisp2|data}} and {{Lisp2|next}} fields discussed in the article ''[[linked list]]''.

Of the many data structures that can be built out of cons cells, one of the most basic is called a ''proper list''. A proper list is either the special {{Lisp2|nil}} (empty list) symbol, or a cons in which the {{Lisp2|car}} points to a datum (which may be another cons structure, such as a list), and the {{Lisp2|cdr}} points to another proper list.

If a given cons is taken to be the head of a linked list, then its car points to the first element of the list, and its cdr points to the rest of the list. For this reason, the {{Lisp2|car}} and {{Lisp2|cdr}} functions are also called {{Lisp2|first}} and {{Lisp2|rest}} when referring to conses which are part of a linked list (rather than, say, a tree).

Thus, a Lisp list is not an atomic object, as an instance of a container class in C++ or Java would be. A list is nothing more than an aggregate of linked conses. A variable that refers to a given list is simply a pointer to the first cons in the list. Traversal of a list can be done by ''cdring down'' the list; that is, taking successive cdrs to visit each cons of the list; or by using any of several [[higher-order function]]s to map a function over a list.

Because conses and lists are so universal in Lisp systems, it is a common misconception that they are Lisp's only data structures. In fact, all but the most simplistic Lisps have other data structures, such as vectors ([[Array data type|arrays]]), [[hash table]]s, structures, and so forth.

====S-expressions represent lists====
Parenthesized S-expressions represent linked list structures. There are several ways to represent the same list as an S-expression. A cons can be written in ''dotted-pair notation'' as {{Lisp2|(a . b)}}, where {{Lisp2|a}} is the car and {{Lisp2|b}} the cdr. A longer proper list might be written {{Lisp2|(a . (b . (c . (d . nil))))}} in dotted-pair notation. This is conventionally abbreviated as {{Lisp2|(a b c d)}} in ''list notation''. An improper list<ref name="r3sL3">NB: a so-called "dotted list" is only one kind of "improper list". The other kind is the "circular list" where the cons cells form a loop. Typically this is represented using #n=(...) to represent the target cons cell that will have multiple references, and #n# is used to refer to this cons. For instance, (#1=(a b) . #1#) would normally be printed as ((a b) a b) (without circular structure printing enabled), but makes the reuse of the cons cell clear. #1=(a . #1#) cannot normally be printed as it is circular, although (a...) is sometimes displayed, the CDR of the cons cell defined by #1= is itself.</ref> may be written in a combination of the two – as {{Lisp2|(a b c . d)}} for the list of three conses whose last cdr is {{Lisp2|d}} (i.e., the list {{Lisp2|(a . (b . (c . d)))}} in fully specified form).

====List-processing procedures====
Lisp provides many built-in procedures for accessing and controlling lists. Lists can be created directly with the {{Lisp2|list}} procedure, which takes any number of arguments, and returns the list of these arguments.
<syntaxhighlight lang="Lisp">
 (list 1 2 'a 3)
 ;Output: (1 2 a 3)
</syntaxhighlight>
<syntaxhighlight lang="Lisp">
 (list 1 '(2 3) 4)
 ;Output: (1 (2 3) 4)
</syntaxhighlight>
Because of the way that lists are constructed from [[cons pair]]s, the {{Lisp2|cons}} procedure can be used to add an element to the front of a list. The {{Lisp2|cons}} procedure is asymmetric in how it handles list arguments, because of how lists are constructed.
<syntaxhighlight lang="Lisp">
 (cons 1 '(2 3))
 ;Output: (1 2 3)
</syntaxhighlight>
<syntaxhighlight lang="Lisp">
 (cons '(1 2) '(3 4))
 ;Output: ((1 2) 3 4)
</syntaxhighlight>
The {{Lisp2|append}} procedure appends two (or more) lists to one another. Because Lisp lists are linked lists, appending two lists has [[Big O notation|asymptotic time complexity]] <math>O(n)</math>
<syntaxhighlight lang="Lisp">
 (append '(1 2) '(3 4))
 ;Output: (1 2 3 4)
</syntaxhighlight>
<syntaxhighlight lang="Lisp">
 (append '(1 2 3) '() '(a) '(5 6))
 ;Output: (1 2 3 a 5 6)
</syntaxhighlight>

====Shared structure====
Lisp lists, being simple linked lists, can share structure with one another. That is to say, two lists can have the same ''tail'', or final sequence of conses. For instance, after the execution of the following Common Lisp code:
<syntaxhighlight lang="Lisp">
(setf foo (list 'a 'b 'c))
(setf bar (cons 'x (cdr foo)))
</syntaxhighlight>
the lists {{Lisp2|foo}} and {{Lisp2|bar}} are {{Lisp2|(a b c)}} and {{Lisp2|(x b c)}} respectively. However, the tail {{Lisp2|(b c)}} is the same structure in both lists. It is not a copy; the cons cells pointing to {{Lisp2|b}} and {{Lisp2|c}} are in the same memory locations for both lists.

Sharing structure rather than copying can give a dramatic performance improvement. However, this technique can interact in undesired ways with functions that alter lists passed to them as arguments. Altering one list, such as by replacing the {{Lisp2|c}} with a {{Lisp2|goose}}, will affect the other:
<syntaxhighlight lang="Lisp">
 (setf (third foo) 'goose)
</syntaxhighlight>
This changes {{Lisp2|foo}} to {{Lisp2|(a b goose)}}, but thereby also changes {{Lisp2|bar}} to {{Lisp2|(x b goose)}} – a possibly unexpected result. This can be a source of bugs, and functions which alter their arguments are documented as ''destructive'' for this very reason.

Aficionados of [[functional programming]] avoid destructive functions. In the Scheme dialect, which favors the functional style, the names of destructive functions are marked with a cautionary exclamation point, or "bang"—such as {{Lisp2|set-car!}} (read ''set car bang''), which replaces the car of a cons. In the Common Lisp dialect, destructive functions are commonplace; the equivalent of {{Lisp2|set-car!}} is named {{Lisp2|rplaca}} for "replace car". This function is rarely seen, however, as Common Lisp includes a special facility, {{Lisp2|setf}}, to make it easier to define and use destructive functions. A frequent style in Common Lisp is to write code functionally (without destructive calls) when prototyping, then to add destructive calls as an optimization where it is safe to do so.

===Self-evaluating forms and quoting===
Lisp evaluates expressions which are entered by the user. Symbols and lists evaluate to some other (usually, simpler) expression – for instance, a symbol evaluates to the value of the variable it names; {{Lisp2|(+ 2 3)}} evaluates to {{Lisp2|5}}. However, most other forms evaluate to themselves: if entering {{Lisp2|5}} into Lisp, it returns {{Lisp2|5}}.

Any expression can also be marked to prevent it from being evaluated (as is necessary for symbols and lists). This is the role of the {{Lisp2|quote}} special operator, or its abbreviation {{Lisp2|'}} (one quotation mark). For instance, usually if entering the symbol {{Lisp2|foo}}, it returns the value of the corresponding variable (or an error, if there is no such variable). To refer to the literal symbol, enter {{Lisp2|(quote foo)}} or, usually, {{Lisp2|'foo}}.

{{anchor|Backquote}}Both Common Lisp and Scheme also support the ''backquote'' operator (termed ''[[quasiquote]]'' in Scheme), entered with the {{Lisp2|`}} character ([[Backtick]]). This is almost the same as the plain quote, except it allows expressions to be evaluated and their values interpolated into a quoted list with the comma {{Lisp2|,}} ''unquote'' and comma-at {{Lisp2|,@}} ''splice'' operators. If the variable {{Lisp2|snue}} has the value {{Lisp2|(bar baz)}} then {{Lisp2|`(foo ,snue)}} evaluates to {{Lisp2|(foo (bar baz))}}, while {{Lisp2|`(foo ,@snue)}} evaluates to {{Lisp2|(foo bar baz)}}. The backquote is most often used in defining macro expansions.<ref name="cTQAG">{{cite web|url=http://www.cs.washington.edu/education/courses/cse341/04wi/lectures/14-scheme-quote.html |title=CSE 341: Scheme: Quote, Quasiquote, and Metaprogramming |publisher=University of Washington Computer Science & Engineering |date=Winter 2004 |access-date=2013-11-15}}</ref><ref name="waVLs">{{cite web|archive-date=2013-06-03 |archive-url=https://web.archive.org/web/20130603114956/http://repository.readscheme.org/ftp/papers/pepm99/bawden.pdf |first1=Alan |last1=Bawden |title=Quasiquotation in Lisp |url=http://repository.readscheme.org/ftp/papers/pepm99/bawden.pdf |url-status=dead}}</ref>

Self-evaluating forms and quoted forms are Lisp's equivalent of literals. It may be possible to modify the values of (mutable) literals in program code. For instance, if a function returns a quoted form, and the code that calls the function modifies the form, this may alter the behavior of the function on subsequent invocations.

<syntaxhighlight lang="lisp">
(defun should-be-constant ()
  '(one two three))

(let ((stuff (should-be-constant)))
  (setf (third stuff) 'bizarre))   ; bad!

(should-be-constant)   ; returns (one two bizarre)
</syntaxhighlight>

Modifying a quoted form like this is generally considered bad style, and is defined by ANSI Common Lisp as erroneous (resulting in "undefined" behavior in compiled files, because the file-compiler can coalesce similar constants, put them in write-protected memory, etc.).

Lisp's formalization of quotation has been noted by [[Douglas Hofstadter]] (in ''[[Gödel, Escher, Bach]]'') and others as an example of the [[philosophy|philosophical]] idea of [[self-reference]].

===Scope and closure===
The Lisp family splits over the use of [[dynamic scoping|dynamic]] or [[static scoping|static]] (a.k.a. lexical) [[scope (programming)|scope]]. Clojure, Common Lisp and Scheme make use of static scoping by default, while [[newLISP]], [[Picolisp]] and the embedded languages in [[Emacs]] and [[AutoCAD]] use dynamic scoping. Since version 24.1, Emacs uses both dynamic and lexical scoping.

===List structure of program code; exploitation by macros and compilers===
A fundamental distinction between Lisp and other languages is that in Lisp, the textual representation of a program is simply a human-readable description of the same internal data structures (linked lists, symbols, number, characters, etc.) as would be used by the underlying Lisp system.

Lisp uses this to implement a very powerful macro system. Like other macro languages such as the one defined by the [[C preprocessor]] (the macro preprocessor for the [[C (programming language)|C]], [[Objective-C]] and [[C++]] programming languages), a macro returns code that can then be compiled. However, unlike C preprocessor macros, the macros are Lisp functions and so can exploit the full power of Lisp.

Further, because Lisp code has the same structure as lists, macros can be built with any of the list-processing functions in the language. In short, anything that Lisp can do to a data structure, Lisp macros can do to code. In contrast, in most other languages, the parser's output is purely internal to the language implementation and cannot be manipulated by the programmer.

This feature makes it easy to develop ''efficient'' languages within languages. For example, the Common Lisp Object System can be implemented cleanly as a language extension using macros. This means that if an application needs a different inheritance mechanism, it can use a different object system. This is in stark contrast to most other languages; for example, Java does not support multiple inheritance and there is no reasonable way to add it.

In simplistic Lisp implementations, this list structure is directly [[interpreter (computing)|interpreted]] to run the program; a function is literally a piece of list structure which is traversed by the interpreter in executing it. However, most substantial Lisp systems also include a compiler. The compiler translates list structure into machine code or [[bytecode]] for execution. This code can run as fast as code compiled in conventional languages such as C.

Macros expand before the compilation step, and thus offer some interesting options. If a program needs a precomputed table, then a macro might create the table at compile time, so the compiler need only output the table and need not call code to create the table at run time. Some Lisp implementations even have a mechanism, <code>eval-when</code>, that allows code to be present during compile time (when a macro would need it), but not present in the emitted module.<ref name="0iFgm">"[https://www.gnu.org/software/emacs/manual/html_node/cl/Time-of-Evaluation.html Time of Evaluation (Common Lisp Extensions)]". GNU. Retrieved on 2013-07-17.</ref>

===Evaluation and the read–eval–print loop===
Lisp languages are often used with an interactive [[command line]], which may be combined with an [[integrated development environment]] (IDE). The user types in expressions at the command line, or directs the IDE to transmit them to the Lisp system. Lisp ''reads'' the entered expressions, ''evaluates'' them, and ''prints'' the result. For this reason, the Lisp command line is called a ''[[read–eval–print loop]]'' ([[REPL]]).

The basic operation of the REPL is as follows. This is a simplistic description which omits many elements of a real Lisp, such as quoting and macros.

The {{Lisp2|read}} function accepts textual S-expressions as input, and parses them into an internal data structure. For instance, if you type the text {{Lisp2|(+ 1 2)}} at the prompt, {{Lisp2|read}} translates this into a linked list with three elements: the symbol {{Lisp2|+}}, the number 1, and the number 2. It so happens that this list is also a valid piece of Lisp code; that is, it can be evaluated. This is because the car of the list names a function—the addition operation.

A {{Lisp2|foo}} will be read as a single symbol. {{Lisp2|123}} will be read as the number one hundred and twenty-three. {{Lisp2|"123"}} will be read as the string "123".

The {{Lisp2|eval}} function evaluates the data, returning zero or more other Lisp data as a result. Evaluation does not have to mean interpretation; some Lisp systems compile every expression to native machine code. It is simple, however, to describe evaluation as interpretation: To evaluate a list whose car names a function, {{Lisp2|eval}} first evaluates each of the arguments given in its cdr, then applies the function to the arguments. In this case, the function is addition, and applying it to the argument list {{Lisp2|(1 2)}} yields the answer {{Lisp2|3}}. This is the result of the evaluation.

The symbol {{Lisp2|foo}} evaluates to the value of the symbol foo. Data like the string "123" evaluates to the same string. The list {{Lisp2|(quote (1 2 3))}} evaluates to the list (1 2 3).

It is the job of the {{Lisp2|print}} function to represent output to the user. For a simple result such as {{Lisp2|3}} this is trivial. An expression which evaluated to a piece of list structure would require that {{Lisp2|print}} traverse the list and print it out as an S-expression.

To implement a Lisp REPL, it is necessary only to implement these three functions and an infinite-loop function. (Naturally, the implementation of {{Lisp2|eval}} will be complex, since it must also implement all special operators like {{Lisp2|if}} or {{Lisp2|lambda}}.) This done, a basic REPL is one line of code: {{Lisp2|(loop (print (eval (read))))}}.

The Lisp REPL typically also provides input editing, an input history, error handling and an interface to the debugger.

Lisp is usually evaluated [[eager evaluation|eagerly]]. In [[Common Lisp]], arguments are evaluated in [[applicative order]] ('leftmost innermost'), while in [[Scheme programming language|Scheme]] order of arguments is undefined, leaving room for optimization by a compiler.

===Control structures===
Lisp originally had very few control structures, but many more were added during the language's evolution. (Lisp's original conditional operator, {{Lisp2|cond}}, is the precursor to later {{Lisp2|if-then-else}} structures.)

Programmers in the Scheme dialect often express loops using [[tail recursion]]. Scheme's commonality in academic computer science has led some students to believe that tail recursion is the only, or the most common, way to write iterations in Lisp, but this is incorrect. All oft-seen Lisp dialects have imperative-style iteration constructs, from Scheme's {{Lisp2|do}} loop to [[Common Lisp]]'s complex {{Lisp2|loop}} expressions. Moreover, the key issue that makes this an objective rather than subjective matter is that Scheme makes specific requirements for the handling of [[tail call]]s, and thus the reason that the use of tail recursion is generally encouraged for Scheme is that the practice is expressly supported by the language definition. By contrast, ANSI Common Lisp does not require<ref name="lGnFp">[http://www.lispworks.com/documentation/HyperSpec/Body/03_bbc.htm 3.2.2.3 Semantic Constraints] in [http://www.lispworks.com/documentation/HyperSpec/Front/index.htm ''Common Lisp HyperSpec'']</ref> the optimization commonly termed a tail call elimination. Thus, the fact that tail recursive style as a casual replacement for the use of more traditional [[iteration]] constructs (such as {{Lisp2|do}}, {{Lisp2|dolist}} or {{Lisp2|loop}}) is discouraged<ref name="VY38C">4.3. Control Abstraction (Recursion vs. Iteration) in [http://www.cs.umd.edu/~nau/cmsc421/norvig-lisp-style.pdf Tutorial on Good Lisp Programming Style] by [[Kent Pitman]] and [[Peter Norvig]], August, 1993.</ref> in Common Lisp is not just a matter of stylistic preference, but potentially one of efficiency (since an apparent tail call in Common Lisp may not compile as a simple [[Branch (computer science)|jump]]) and program correctness (since tail recursion may increase stack use in Common Lisp, risking [[stack overflow]]).

Some Lisp control structures are ''special operators'', equivalent to other languages' syntactic keywords. Expressions using these operators have the same surface appearance as function calls, but differ in that the arguments are not necessarily evaluated—or, in the case of an iteration expression, may be evaluated more than once.

In contrast to most other major programming languages, Lisp allows implementing control structures using the language. Several control structures are implemented as Lisp macros, and can even be macro-expanded by the programmer who wants to know how they work.

Both Common Lisp and Scheme have operators for non-local control flow. The differences in these operators are some of the deepest differences between the two dialects. Scheme supports ''re-entrant [[continuation]]s'' using the {{Lisp2|call/cc}} procedure, which allows a program to save (and later restore) a particular place in execution. Common Lisp does not support re-entrant continuations, but does support several ways of handling escape continuations.

Often, the same algorithm can be expressed in Lisp in either an imperative or a functional style. As noted above, Scheme tends to favor the functional style, using tail recursion and continuations to express control flow. However, imperative style is still quite possible. The style preferred by many Common Lisp programmers may seem more familiar to programmers used to structured languages such as C, while that preferred by Schemers more closely resembles pure-functional languages such as [[Haskell]].

Because of Lisp's early heritage in list processing, it has a wide array of higher-order functions relating to iteration over sequences. In many cases where an explicit loop would be needed in other languages (like a {{Lisp2|for}} loop in C) in Lisp the same task can be accomplished with a higher-order function. (The same is true of many functional programming languages.)

A good example is a function which in Scheme is called {{Lisp2|map}} and in Common Lisp is called {{Lisp2|mapcar}}. Given a function and one or more lists, {{Lisp2|mapcar}} applies the function successively to the lists' elements in order, collecting the results in a new list:
<syntaxhighlight lang="Lisp">
 (mapcar #'+ '(1 2 3 4 5) '(10 20 30 40 50))
</syntaxhighlight>
This applies the {{Lisp2|+}} function to each corresponding pair of list elements, yielding the result {{Lisp2|(11 22 33 44 55)}}.

== Examples ==

Here are examples of Common Lisp code.

The basic "[[Hello, World!]]" program:
<syntaxhighlight lang="Lisp">
(print "Hello, World!")
</syntaxhighlight>

Lisp syntax lends itself naturally to recursion. Mathematical problems such as the enumeration of recursively defined sets are simple to express in this notation. For example, to evaluate a number's [[factorial]]:
<syntaxhighlight lang="Lisp">
(defun factorial (n)
    (if (zerop n) 1
        (* n (factorial (1- n)))))
</syntaxhighlight>

An alternative implementation takes less stack space than the previous version if the underlying Lisp system optimizes [[tail recursion]]:
<syntaxhighlight lang="Lisp">
(defun factorial (n &optional (acc 1))
    (if (zerop n) acc
        (factorial (1- n) (* acc n))))
</syntaxhighlight>

Contrast the examples above with an iterative version which uses [[Common Lisp]]'s {{Lisp2|loop}} macro:
<syntaxhighlight lang="Lisp">
(defun factorial (n)
    (loop for i from 1 to n
        for fac = 1 then (* fac i)
        finally (return fac)))
</syntaxhighlight>

The following function reverses a list. (Lisp's built-in ''reverse'' function does the same thing.)
<syntaxhighlight lang="Lisp">
(defun -reverse (list)
    (let ((return-value))
      (dolist (e list) (push e return-value))
      return-value))
</syntaxhighlight>

==Object systems==
Various object systems and models have been built on top of, alongside, or into Lisp, including
* The [[Common Lisp Object System]], CLOS, is an integral part of ANSI Common Lisp. CLOS descended from New Flavors and CommonLOOPS. ANSI Common Lisp was the first standardized object-oriented programming language (1994, ANSI X3J13).
* ObjectLisp<ref name="NRrCu">pg 17 of Bobrow 1986</ref> or [[Object Lisp]], used by [[Lisp Machines Incorporated]] and early versions of Macintosh Common Lisp
* LOOPS (Lisp Object-Oriented Programming System) and the later [[CommonLoops]]
* [[Flavors (computer science)|Flavors]], built at [[Massachusetts Institute of Technology|MIT]], and its descendant New Flavors (developed by [[Symbolics]]).
* KR (short for Knowledge Representation), a [[Constraint satisfaction|constraint]]s-based object system developed to aid the writing of Garnet, a GUI library for [[Common Lisp]].
* [[Knowledge Engineering Environment]] (KEE) used an object system named UNITS and integrated it with an [[inference engine]]<ref name="YxD5o">Veitch, p 108, 1988</ref> and a [[Reason maintenance|truth maintenance]] system (ATMS).

==Operating systems==
Several [[operating system]]s, including [[language-based system]]s, are based on Lisp (use Lisp features, conventions, methods, data structures, etc.), or are written in Lisp,<ref>{{Cite news |last=Proven |first=Liam |date=29 March 2022 |url=https://www.theregister.com/2022/03/29/non_c_operating_systems/ |title=The wild world of non-C operating systems |work=[[The Register]] |access-date=2024-04-04}}</ref> including:

[[Genera (operating system)|Genera]], renamed Open Genera,<ref>{{Cite web |author=<!-- Unstated --> |date=7 January 2020 |url=https://archive.org/details/OpenGenera |title=Symbolics Open Genera 2.0 |website=[[GitHub]] Internet Archive |access-date=2022-02-02}}</ref> by [[Symbolics]]; Medley, written in Interlisp, originally a family of graphical operating systems that ran on [[Xerox]]'s later [[Xerox Star|Star]] [[workstation]]s;<ref>{{Cite web |author=<!-- Unstated --> |date=15 March 2022 |url=https://interlisp.org/ |title=Interlisp.org Project |website=Interlisp.org |access-date=2022-02-02}}</ref><ref>{{Cite web |author=<!-- Unstated --> |date=March 2022 |url=https://github.com/Interlisp/medley |title=Interlisp Medley |website=[[GitHub]] |access-date=2022-02-02}}</ref> Mezzano;<ref>{{Cite web |author=froggey |date=1 August 2021 |url=https://github.com/froggey/Mezzano |title=Mezzano |website=[[GitHub]] |access-date=2022-02-02}}</ref> Interim;<ref>{{Cite web |last=Hartmann |first=Lukas F. |date=10 September 2015 |url=http://interim-os.com/ |title=Interim |website=Interim-os |access-date=2022-02-02}}</ref><ref>{{Cite web |last=Hartmann |first=Lukas F. |date=11 June 2021 |url=https://github.com/mntmn/interim |title=Interim |website=[[GitHub]] |access-date=2022-02-02}}</ref> ChrysaLisp,<ref>{{Cite web |last=Hinsley |first=Chris |date=23 February 2022 |url=https://github.com/vygr/ChrysaLisp |title=ChrysaLisp |website=[[GitHub]] |access-date=2022-02-02}}</ref> by developers of Tao Systems' TAOS;<ref>{{Cite web |last=Smith |first=Tony |date=21 August 2013 |url=https://www.theregister.com/2013/08/21/unsung_heroes_dr_chris_shelton/?page=5 |title=UK micro pioneer Chris Shelton: The mind behind the Nascom 1 |website=[[The Register]] |access-date=2022-02-02}}</ref> and also the [[GNU Guix#Guix System (operating system)|Guix System]] for GNU/Linux.

==See also==
* [[Self-modifying code]]

==Footnotes==
{{notefoot}}

==References==
{{Reflist|1=30em}}

==Further reading==
{{Refbegin}}
* {{cite web
 |last=McCarthy
 |first=John
 |date=1979-02-12
 |title=The implementation of Lisp
 |work=History of Lisp
 |publisher=Stanford University
 |url=http://www-formal.stanford.edu/jmc/history/lisp/node3.html
 |access-date=2008-10-17
}}
* {{Cite conference
 |first=Guy L.
 |last=Steele, Jr.
 |author2=Richard P. Gabriel
 |year=1993
 |title=The evolution of Lisp
 |conference=The second ACM SIGPLAN conference on History of programming languages
 |pages=231–270
 |publisher=ACM
 |location=New York, NY
 |url=http://www.dreamsongs.com/NewFiles/HOPL2-Uncut.pdf
 |isbn=0-89791-570-4
 |access-date=2008-10-17
 |archive-date=2006-10-12
 |archive-url=https://web.archive.org/web/20061012010042/http://www.dreamsongs.com/NewFiles/HOPL2-Uncut.pdf
}}
* {{Cite book
 |first=Jim
 |last=Veitch
 |editor-last=Salus
 |editor-first=Peter H.
 |year=1998
 |contribution=A history and description of CLOS
 |title=Handbook of programming languages
 |volume=IV, Functional and logic programming languages
 |edition=1st
 |pages=[https://archive.org/details/handbookofprogra0000unse/page/107 107–158]
 |place=Indianapolis, IN
 |publisher=Macmillan Technical Publishing
 |url=https://archive.org/details/handbookofprogra0000unse/page/107
 |isbn=1-57870-011-6
}}
* {{Cite book
 |title=[[Structure and Interpretation of Computer Programs]]
 |first1=Harold
 |last1=Abelson
 |author-link=Harold Abelson
 |first2=Gerald Jay
 |last2=Sussman
 |author2-link=Gerald Jay Sussman
 |first3=Julie
 |last3=Sussman
 |author3-link=Julie Sussman
 |year=1996
 |edition=2nd
 |publisher=MIT Press
 |isbn=0-262-01153-0
}}
* [https://www.gnu.org/gnu/rms-lisp.html My Lisp Experiences and the Development of GNU Emacs], [[transcription (linguistics)|transcript]] of [[Richard Stallman]]'s speech, 28 October 2002, at the [[International Lisp Conference]]
* {{Cite book
 |first=Paul
 |last=Graham
 |author-link=Paul Graham (computer programmer)
 |year=2004
 |title=[[Hackers & Painters|Hackers & Painters. Big Ideas from the Computer Age]]
 |publisher=O'Reilly
 |isbn=0-596-00662-4
}}
* {{Cite book
 |editor-last=Berkeley
 |editor-first=Edmund C.
 |editor-link=Edmund Berkeley
 |editor2-last=Bobrow
 |editor2-first=Daniel G.
 |editor2-link=Daniel G. Bobrow
 |date=March 1964
 |title=The Programming Language LISP: Its Operation and Applications
 |url=http://www.softwarepreservation.org/projects/LISP/book/III_LispBook_Apr66.pdf
 |publisher=MIT Press
 |location=Cambridge, Massachusetts
}}
** Article largely based on the ''LISP - A Simple Introduction'' chapter: {{cite journal |last1=Berkeley |first1=Edmund C. |title=The Programming Language Lisp: An Introduction and Appraisal |journal=Computers and Automation |date=September 1964 |pages=[https://archive.org/details/bitsavers_computersA_6908895/page/n15 16]-23 |url=https://archive.org/details/bitsavers_computersA_6908895}}
* {{Cite book
 |last=Weissman
 |first=Clark
 |title=LISP 1.5 Primer
 |year=1967
 |url=http://www.softwarepreservation.org/projects/LISP/book/Weismann_LISP1.5_Primer_1967.pdf
 |publisher=Dickenson Publishing Company Inc.
 |location=Belmont, California
}}
{{Refend}}

==External links==
{{Sister project links|wikt=Lisp|commons=Category:Lisp (programming language)|n=no|q=Lisp programming language|b=Subject:Lisp programming language|v=Topic:Lisp|s=Lambda Papers}}
'''History'''
* [http://www-formal.stanford.edu/jmc/history/lisp/lisp.html History of Lisp] – [[John McCarthy (computer scientist)|John McCarthy]]'s history of 12 February 1979
* [https://web.archive.org/web/20050617031004/http://www8.informatik.uni-erlangen.de/html/lisp-enter.html Lisp History] – Herbert Stoyan's history compiled from the documents (acknowledged by McCarthy as more complete than his own, see: [http://www-formal.stanford.edu/jmc/history/ McCarthy's history links])
* [http://www.softwarepreservation.org/projects/LISP/ History of LISP at the Computer History Museum]
* {{Cite AV media |last=Bell |first=Adam Gordon |date=2 May 2022 |url=https://corecursive.com/lisp-in-space-with-ron-garret/ |title=LISP in Space, with Ron Garret |type=podcast, transcript, photos |language=en |website=CoRecursive}} about the use of LISP software on [[List of NASA robots|NASA robots]].
* {{Cite news |last=Cassel |first=David |date=22 May 2022 |title=NASA Programmer Remembers Debugging Lisp in Deep Space |url=https://thenewstack.io/nasa-programmer-remembers-debugging-lisp-in-deep-space/ |website=The New Stack}}

'''Associations and meetings'''
* [http://www.alu.org/ Association of Lisp Users]
* [http://www.weitz.de/eclm2013/ European Common Lisp Meeting]
* [http://european-lisp-symposium.org/ European Lisp Symposium]
* [http://www.international-lisp-conference.org/ International Lisp Conference]

'''Books and tutorials'''
* ''[http://www.lisperati.com/casting.html Casting SPELs in Lisp]'', a comic-book style introductory tutorial
* ''[http://paulgraham.com/onlisptext.html On Lisp]'', a free book by [[Paul Graham (computer programmer)|Paul Graham]]
* ''[http://www.gigamonkeys.com/book/ Practical Common Lisp]'', freeware edition by Peter Seibel
* [http://leanpub.com/lispweb Lisp for the web]
* [http://landoflisp.com/ Land of Lisp]
* [http://letoverlambda.com/ Let over Lambda]

'''Interviews'''
* [http://purl.umn.edu/107476 Oral history interview with John McCarthy] at [[Charles Babbage Institute]], University of Minnesota, Minneapolis. McCarthy discusses his role in the development of time-sharing at the Massachusetts Institute of Technology. He also describes his work in artificial intelligence (AI) funded by the Advanced Research Projects Agency, including logic-based AI (LISP) and robotics.
* [http://www.se-radio.net/2008/01/episode-84-dick-gabriel-on-lisp/ Interview] with [[Richard P. Gabriel]] (Podcast)

'''Resources'''
* [http://www.cliki.net/ CLiki: the Common Lisp wiki]
* [https://web.archive.org/web/20160311102031/http://www.cl-user.net/asp/erw/sdataQIvH87hu8NU%24DM%3D%3D/sdataQo5Y-1Mh9urk The Common Lisp Directory] (via the [[Wayback Machine]]; archived from [https://web.archive.org/web/20080905110332/http://cl-user.net/ the original])
* [http://www.faqs.org/faqs/lisp-faq/ Lisp FAQ Index]
* [http://paste.lisp.org/ lisppaste]
* [http://planet.lisp.org/ Planet Lisp]
* [http://lispnews.wordpress.com/ Weekly Lisp News]
* [http://newlisp.org/ newLISP - A modern, general-purpose scripting language]
* [https://discu.eu/weekly/lisp/ Lisp Weekly]

{{Lisp programming language}}
{{John McCarthy}}
{{Programming languages}}
{{Authority control}}

{{DEFAULTSORT:Lisp Programming Language}}
[[Category:Lisp (programming language)| ]]
[[Category:Academic programming languages]]
[[Category:American inventions]]
[[Category:Articles with example Lisp (programming language) code]]
[[Category:Dynamically typed programming languages]]
[[Category:Extensible syntax programming languages]]
[[Category:Functional languages]]
[[Category:Lisp programming language family| ]]
[[Category:Programming languages]]
[[Category:Programming languages created in 1958]]