Lisp (programming language)

From Wikipedia for FEVERv2
Jump to navigation Jump to search

"LISP" redirects here. Lisp (programming language)_sentence_0

For the Internet protocol, see Locator/Identifier Separation Protocol. Lisp (programming language)_sentence_1

For the Japanese girl group, see Lisp (group). Lisp (programming language)_sentence_2

For the speech impediment, see Lisp. Lisp (programming language)_sentence_3

Lisp (programming language)_table_infobox_0

LispLisp (programming language)_table_caption_0
ParadigmLisp (programming language)_header_cell_0_0_0 Multi-paradigm: functional, procedural, reflective, metaLisp (programming language)_cell_0_0_1
Designed byLisp (programming language)_header_cell_0_1_0 John McCarthyLisp (programming language)_cell_0_1_1
DeveloperLisp (programming language)_header_cell_0_2_0 Steve Russell, Timothy P. Hart, and Mike LevinLisp (programming language)_cell_0_2_1
First appearedLisp (programming language)_header_cell_0_3_0 1958; 62 years ago (1958)Lisp (programming language)_cell_0_3_1
Typing disciplineLisp (programming language)_header_cell_0_4_0 Dynamic, strongLisp (programming language)_cell_0_4_1
DialectsLisp (programming language)_header_cell_0_5_0
Influenced byLisp (programming language)_header_cell_0_6_0
InfluencedLisp (programming language)_header_cell_0_7_0

Lisp (historically LISP) is a family of programming languages with a long history and a distinctive, fully parenthesized prefix notation. Lisp (programming language)_sentence_4

Originally specified in 1958, Lisp is the second-oldest high-level programming language in widespread use today. Lisp (programming language)_sentence_5

Only Fortran is older, by one year. Lisp (programming language)_sentence_6

Lisp has changed since its early days, and many dialects have existed over its history. Lisp (programming language)_sentence_7

Today, the best-known general-purpose Lisp dialects are Racket, Common Lisp, Scheme and Clojure. Lisp (programming language)_sentence_8

Lisp was originally created as a practical mathematical notation for computer programs, influenced by (though not originally derived from ) the notation of Alonzo Church's lambda calculus. Lisp (programming language)_sentence_9

It quickly became the favored programming language for artificial intelligence (AI) research. Lisp (programming language)_sentence_10

As one of the earliest programming languages, Lisp pioneered many ideas in computer science, including tree data structures, automatic storage management, dynamic typing, conditionals, higher-order functions, recursion, the self-hosting compiler, and the read–eval–print loop. Lisp (programming language)_sentence_11

The name LISP derives from "LISt Processor". Lisp (programming language)_sentence_12

Linked lists are one of Lisp's major data structures, and Lisp source code is made of lists. Lisp (programming language)_sentence_13

Thus, Lisp programs can manipulate source code as a data structure, giving rise to the macro systems that allow programmers to create new syntax or new domain-specific languages embedded in Lisp. Lisp (programming language)_sentence_14

The interchangeability of code and data gives Lisp its instantly recognizable syntax. Lisp (programming language)_sentence_15

All program code is written as s-expressions, or parenthesized lists. Lisp (programming language)_sentence_16

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 f that takes three arguments would be called as (f arg1 arg2 arg3). Lisp (programming language)_sentence_17

History Lisp (programming language)_section_0

John McCarthy developed Lisp in 1958 while he was at the Massachusetts Institute of Technology (MIT). Lisp (programming language)_sentence_18

McCarthy published its design in a paper in Communications of the ACM in 1960, entitled "Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I". Lisp (programming language)_sentence_19

He showed that with a few simple operators and a notation for anonymous functions borrowed from Church, one can build a Turing-complete language for algorithms. Lisp (programming language)_sentence_20

Information Processing Language was the first AI language, from 1955 or 1956, and already included many of the concepts, such as list-processing and recursion, which came to be used in Lisp. Lisp (programming language)_sentence_21

McCarthy's original notation used bracketed "M-expressions" that would be translated into S-expressions. Lisp (programming language)_sentence_22

As an example, the M-expression car[cons[A,B]] is equivalent to the S-expression (car (cons A B)). Lisp (programming language)_sentence_23

Once Lisp was implemented, programmers rapidly chose to use S-expressions, and M-expressions were abandoned. Lisp (programming language)_sentence_24

M-expressions surfaced again with short-lived attempts of MLisp by Horace Enea and CGOL by Vaughan Pratt. Lisp (programming language)_sentence_25

Lisp was first implemented by Steve Russell on an IBM 704 computer using punched cards. Lisp (programming language)_sentence_26

Russell had read McCarthy's paper and realized (to McCarthy's surprise) that the Lisp eval function could be implemented in machine code. Lisp (programming language)_sentence_27

The result was a working Lisp interpreter which could be used to run Lisp programs, or more properly, "evaluate Lisp expressions". Lisp (programming language)_sentence_28

Two assembly language macros for the IBM 704 became the primitive operations for decomposing lists: car (Contents of the Address part of Register number) and cdr (Contents of the Decrement part of Register number), where "register" is used to refer to registers of the computer's central processing unit (CPU). Lisp (programming language)_sentence_29

Lisp dialects still use car and cdr (/kɑːr/ and /ˈkʊdər/) for the operations that return the first item in a list and the rest of the list, respectively. Lisp (programming language)_sentence_30

The first complete Lisp compiler, written in Lisp, was implemented in 1962 by Tim Hart and Mike Levin at MIT. Lisp (programming language)_sentence_31

This compiler introduced the Lisp model of incremental compilation, in which compiled and interpreted functions can intermix freely. Lisp (programming language)_sentence_32

The language used in Hart and Levin's memo is much closer to modern Lisp style than McCarthy's earlier code. Lisp (programming language)_sentence_33

The first garbage collection routines were developed by MIT graduate student Daniel Edwards. Lisp (programming language)_sentence_34

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. Lisp (programming language)_sentence_35

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). Lisp (programming language)_sentence_36

In 1994, ANSI published the Common Lisp standard, "ANSI X3.226-1994 Information Technology Programming Language Common Lisp". Lisp (programming language)_sentence_37

Timeline Lisp (programming language)_section_1

Connection to artificial intelligence Lisp (programming language)_section_2

Since inception, Lisp was closely connected with the artificial intelligence research community, especially on PDP-10 systems. Lisp (programming language)_sentence_38

Lisp was used as the implementation of the programming language Micro Planner, which was used in the famous AI system SHRDLU. Lisp (programming language)_sentence_39

In the 1970s, as AI research spawned commercial offshoots, the performance of existing Lisp systems became a growing issue. Lisp (programming language)_sentence_40

Genealogy and variants Lisp (programming language)_section_3

Over its sixty-year history, Lisp has spawned many variations on the core theme of an S-expression language. Lisp (programming language)_sentence_41

Moreover, each given dialect may have several implementations—for instance, there are more than a dozen implementations of Common Lisp. Lisp (programming language)_sentence_42

Differences between dialects may be quite visible—for instance, Common Lisp uses the keyword defun to name a function, but Scheme uses define. Lisp (programming language)_sentence_43

Within a dialect that is standardized, however, conforming implementations support the same core language, but with different extensions and libraries. Lisp (programming language)_sentence_44

Historically significant dialects Lisp (programming language)_section_4

Lisp (programming language)_unordered_list_0

  • LISP 1 – First implementation.Lisp (programming language)_item_0_0
  • LISP 1.5 – 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.Lisp (programming language)_item_0_1
  • Stanford LISP 1.6 – This was 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.Lisp (programming language)_item_0_2
  • MACLISP – 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 related neither to Apple's Macintosh nor to McCarthy.Lisp (programming language)_item_0_3
  • Interlisp – developed at BBN Technologies for PDP-10 systems running the 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 6502-based Atari 8-bit family computer line. For quite some time, Maclisp and InterLisp were strong competitors.Lisp (programming language)_item_0_4
  • 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.Lisp (programming language)_item_0_5
  • XLISP, which AutoLISP was based on.Lisp (programming language)_item_0_6
  • Standard Lisp and Portable Standard Lisp were widely used and ported, especially with the Computer Algebra System REDUCE.Lisp (programming language)_item_0_7
  • ZetaLisp, also termed Lisp Machine Lisp – used on the Lisp machines, direct descendant of Maclisp. ZetaLisp had a big influence on Common Lisp.Lisp (programming language)_item_0_8
  • LeLisp is a French Lisp dialect. One of the first Interface Builders (called SOS Interface) was written in LeLisp.Lisp (programming language)_item_0_9
  • Scheme (1975).Lisp (programming language)_item_0_10
  • Common Lisp (1984), as described by Common Lisp the Language – a consolidation of several divergent attempts (ZetaLisp, Spice Lisp, NIL, and S-1 Lisp) to create successor dialects 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 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).Lisp (programming language)_item_0_11
  • Dylan was in its first version a mix of Scheme with the Common Lisp Object System.Lisp (programming language)_item_0_12
  • EuLisp – attempt to develop a new efficient and cleaned-up Lisp.Lisp (programming language)_item_0_13
  • ISLISP – attempt to develop a new efficient and cleaned-up Lisp. Standardized as ISO/IEC 13816:1997 and later revised as ISO/IEC 13816:2007: Information technology – Programming languages, their environments and system software interfaces – Programming language ISLISP.Lisp (programming language)_item_0_14
  • IEEE Scheme – IEEE standard, 1178–1990 (R1995)Lisp (programming language)_item_0_15
  • ANSI Common Lisp – an American National Standards Institute (ANSI) standard for Common Lisp, created by subcommittee X3J13, chartered to begin with Common Lisp: The Language as a base document and to work through a public consensus process to find solutions to shared issues of portability of programs and 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.Lisp (programming language)_item_0_16
  • 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.Lisp (programming language)_item_0_17
  • Clojure, a recent dialect of Lisp which compiles to the Java virtual machine and has a particular focus on concurrency.Lisp (programming language)_item_0_18
  • Game Oriented Assembly Lisp (or GOAL) is a video game programming language developed by Andy Gavin and the Jak and Daxter team at Naughty Dog. It was written using Allegro Common Lisp and used in the development of the entire Jak and Daxter series of games.Lisp (programming language)_item_0_19

2000 to present Lisp (programming language)_section_5

After having declined somewhat in the 1990s, Lisp has experienced a resurgence of interest after 2000. Lisp (programming language)_sentence_45

Most new activity has been focused around implementations of Common Lisp, Scheme, Emacs Lisp, Clojure, and Racket, and includes development of new portable libraries and applications. Lisp (programming language)_sentence_46

Many new Lisp programmers were inspired by writers such as Paul Graham and Eric S. Raymond to pursue a language others considered antiquated. Lisp (programming language)_sentence_47

New Lisp programmers often describe the language as an eye-opening experience and claim to be substantially more productive than in other languages. Lisp (programming language)_sentence_48

This increase in awareness may be contrasted to the "AI winter" and Lisp's brief gain in the mid-1990s. Lisp (programming language)_sentence_49

Dan Weinreb lists in his survey of Common Lisp implementations eleven actively maintained Common Lisp implementations. Lisp (programming language)_sentence_50

Scieneer Common Lisp is a new commercial implementation forked from CMUCL with a first release in 2002. Lisp (programming language)_sentence_51

The 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 collects the contents of various Lisp-related blogs, on LispForum users discuss Lisp topics, Lispjobs is a service for announcing job offers and there is a weekly news service, Weekly Lisp News. Lisp (programming language)_sentence_52

Common-lisp.net is a hosting site for open source Common Lisp projects. Lisp (programming language)_sentence_53

Quicklisp is a library manager for Common Lisp. Lisp (programming language)_sentence_54

Fifty years of Lisp (1958–2008) was celebrated at LISP50@OOPSLA. Lisp (programming language)_sentence_55

There are regular local user meetings in Boston, Vancouver, and Hamburg. Lisp (programming language)_sentence_56

Other events include the European Common Lisp Meeting, the European Lisp Symposium and an International Lisp Conference. Lisp (programming language)_sentence_57

The Scheme community actively maintains over twenty implementations. Lisp (programming language)_sentence_58

Several significant new implementations (Chicken, Gambit, Gauche, Ikarus, Larceny, Ypsilon) have been developed in the 2000s (decade). Lisp (programming language)_sentence_59

The Revised Report on the Algorithmic Language Scheme standard of Scheme was widely accepted in the Scheme community. Lisp (programming language)_sentence_60

The Scheme Requests for Implementation process has created a lot of quasi standard libraries and extensions for Scheme. Lisp (programming language)_sentence_61

User communities of individual Scheme implementations continue to grow. Lisp (programming language)_sentence_62

A new language standardization process was started in 2003 and led to the RRS Scheme standard in 2007. Lisp (programming language)_sentence_63

Academic use of Scheme for teaching computer science seems to have declined somewhat. Lisp (programming language)_sentence_64

Some universities are no longer using Scheme in their computer science introductory courses; MIT now uses Python instead of Scheme for its undergraduate computer science program and MITx massive open online course. Lisp (programming language)_sentence_65

There are several new dialects of Lisp: Arc, Hy, Nu, Liskell, and LFE (Lisp Flavored Erlang). Lisp (programming language)_sentence_66

The parser for Julia is implemented in Femtolisp, a dialect of Scheme (Julia is inspired by Scheme, which in turn is a Lisp dialect). Lisp (programming language)_sentence_67

In October 2019, Paul Graham released , "a new dialect of Lisp." Lisp (programming language)_sentence_68

Major dialects Lisp (programming language)_section_6

Common Lisp and Scheme represent two major streams of Lisp development. Lisp (programming language)_sentence_69

These languages embody significantly different design choices. Lisp (programming language)_sentence_70

Common Lisp is a successor to Maclisp. Lisp (programming language)_sentence_71

The primary influences were Lisp Machine Lisp, Maclisp, NIL, S-1 Lisp, Spice Lisp, and Scheme. Lisp (programming language)_sentence_72

It has many of the features of Lisp Machine Lisp (a large Lisp dialect used to program Lisp Machines), but was designed to be efficiently implementable on any personal computer or workstation. Lisp (programming language)_sentence_73

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). Lisp (programming language)_sentence_74

Common Lisp also borrowed certain features from Scheme such as lexical scoping and lexical closures. Lisp (programming language)_sentence_75

Common Lisp implementations are available for targeting different platforms such as the LLVM, the Java virtual machine, x86-64, PowerPC, Alpha, ARM, Motorola 68000, and MIPS, and operating systems such as Windows, macOS, Linux, Solaris, FreeBSD, NetBSD, OpenBSD, Dragonfly BSD, and Heroku. Lisp (programming language)_sentence_76

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. Lisp (programming language)_sentence_77

It was designed to have exceptionally clear and simple semantics and few different ways to form expressions. Lisp (programming language)_sentence_78

Designed about a decade earlier than Common Lisp, Scheme is a more minimalist design. Lisp (programming language)_sentence_79

It has a much smaller set of standard features but with certain implementation features (such as tail-call optimization and full continuations) not specified in Common Lisp. Lisp (programming language)_sentence_80

A wide variety of programming paradigms, including imperative, functional, and message passing styles, find convenient expression in Scheme. Lisp (programming language)_sentence_81

Scheme continues to evolve with a series of standards (Revised Report on the Algorithmic Language Scheme) and a series of Scheme Requests for Implementation. Lisp (programming language)_sentence_82

Clojure is a recent dialect of Lisp that targets mainly the Java virtual machine, and the Common Language Runtime (CLR), the Python VM, the Ruby VM YARV, and compiling to JavaScript. Lisp (programming language)_sentence_83

It is designed to be a pragmatic general-purpose language. Lisp (programming language)_sentence_84

Clojure draws considerable influences from Haskell and places a very strong emphasis on immutability. Lisp (programming language)_sentence_85

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. Lisp (programming language)_sentence_86

Clojure is not designed to be backwards compatible with other Lisp dialects. Lisp (programming language)_sentence_87

Further, Lisp dialects are used as scripting languages in many applications, with the best-known being Emacs Lisp in the Emacs editor, AutoLISP and later Visual Lisp in AutoCAD, Nyquist in Audacity, Scheme in LilyPond. Lisp (programming language)_sentence_88

The potential small size of a useful Scheme interpreter makes it particularly popular for embedded scripting. Lisp (programming language)_sentence_89

Examples include SIOD and TinyScheme, both of which have been successfully embedded in the GIMP image processor under the generic name "Script-fu". Lisp (programming language)_sentence_90

LIBREP, a Lisp interpreter by John Harper originally based on the Emacs Lisp language, has been embedded in the Sawfish window manager. Lisp (programming language)_sentence_91

Standardized dialects Lisp (programming language)_section_7

Lisp has officially standardized dialects: R6RS Scheme, R7RS Scheme, IEEE Scheme, ANSI Common Lisp and ISO ISLISP. Lisp (programming language)_sentence_92

Language innovations Lisp (programming language)_section_8

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". Lisp (programming language)_sentence_93

Thus, Lisp functions can be manipulated, altered or even created within a Lisp program without lower-level manipulations. Lisp (programming language)_sentence_94

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 metacircular evaluation. Lisp (programming language)_sentence_95

A conditional using an if–then–else syntax was invented by McCarthy in a Fortran context. Lisp (programming language)_sentence_96

He proposed its inclusion in ALGOL, but it was not made part of the Algol 58 specification. Lisp (programming language)_sentence_97

For Lisp, McCarthy used the more general cond-structure. Lisp (programming language)_sentence_98

Algol 60 took up if–then–else and popularized it. Lisp (programming language)_sentence_99

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. Lisp (programming language)_sentence_100

The Flavors object system introduced the concept of multiple inheritance and the mixin. Lisp (programming language)_sentence_101

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. Lisp (programming language)_sentence_102

It has served as the template for many subsequent Lisp (including Scheme) object systems, which are often implemented via a metaobject protocol, a reflective metacircular 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. Lisp (programming language)_sentence_103

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. Lisp (programming language)_sentence_104

Lisp introduced the concept of automatic garbage collection, in which the system walks the heap looking for unused memory. Lisp (programming language)_sentence_105

Progress in modern sophisticated garbage collection algorithms such as generational garbage collection was stimulated by its use in Lisp. Lisp (programming language)_sentence_106

Edsger W. Dijkstra in his 1972 Turing Award lecture said, Lisp (programming language)_sentence_107

Lisp (programming language)_description_list_1

  • "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."Lisp (programming language)_item_1_20

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 language. Lisp (programming language)_sentence_108

Because of its suitability to complex and dynamic applications, Lisp is enjoying some resurgence of popular interest in the 2010s. Lisp (programming language)_sentence_109

Syntax and semantics Lisp (programming language)_section_9

Lisp (programming language)_description_list_2

  • Note: This article's examples are written in Common Lisp (though most are also valid in Scheme).Lisp (programming language)_item_2_21

Symbolic expressions (S-expressions) Lisp (programming language)_section_10

Lisp is an expression oriented language. Lisp (programming language)_sentence_110

Unlike most other languages, no distinction is made between "expressions" and "statements"; all code and data are written as expressions. Lisp (programming language)_sentence_111

When an expression is evaluated, it produces a value (in Common Lisp, possibly multiple values), which can then be embedded into other expressions. Lisp (programming language)_sentence_112

Each value can be any data type. Lisp (programming language)_sentence_113

McCarthy's 1958 paper introduced two types of syntax: Symbolic expressions (S-expressions, sexps), which mirror the internal representation of code and data; and Meta expressions (M-expressions), which express functions of S-expressions. Lisp (programming language)_sentence_114

M-expressions never found favor, and almost all Lisps today use S-expressions to manipulate both code and data. Lisp (programming language)_sentence_115

The use of parentheses is Lisp's most immediately obvious difference from other programming language families. Lisp (programming language)_sentence_116

As a result, students have long given Lisp nicknames such as Lost In Stupid Parentheses, or Lots of Irritating Superfluous Parentheses. Lisp (programming language)_sentence_117

However, the S-expression syntax is also responsible for much of Lisp's power: the syntax is extremely regular, which facilitates manipulation by computer. Lisp (programming language)_sentence_118

However, the syntax of Lisp is not limited to traditional parentheses notation. Lisp (programming language)_sentence_119

It can be extended to include alternative notations. Lisp (programming language)_sentence_120

For example, XMLisp is a Common Lisp extension that employs the metaobject protocol to integrate S-expressions with the Extensible Markup Language (XML). Lisp (programming language)_sentence_121

The reliance on expressions gives the language great flexibility. Lisp (programming language)_sentence_122

Because Lisp functions are written as lists, they can be processed exactly like data. Lisp (programming language)_sentence_123

This allows easy writing of programs which manipulate other programs (metaprogramming). Lisp (programming language)_sentence_124

Many Lisp dialects exploit this feature using macro systems, which enables extension of the language almost without limit. Lisp (programming language)_sentence_125

Lists Lisp (programming language)_section_11

A Lisp list is written with its elements separated by whitespace, and surrounded by parentheses. Lisp (programming language)_sentence_126

For example, (1 2 foo) is a list whose elements are the three atoms 1, 2, and foo. Lisp (programming language)_sentence_127

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. Lisp (programming language)_sentence_128

The empty list () is also represented as the special atom nil. Lisp (programming language)_sentence_129

This is the only entity in Lisp which is both an atom and a list. Lisp (programming language)_sentence_130

Expressions are written as lists, using prefix notation. Lisp (programming language)_sentence_131

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). Lisp (programming language)_sentence_132

The remainder of the list are the arguments. Lisp (programming language)_sentence_133

For example, the function list returns its arguments as a list, so the expression Lisp (programming language)_sentence_134

evaluates to the list (1 2 foo). Lisp (programming language)_sentence_135

The "quote" before the foo in the preceding example is a "special operator" which returns its argument without evaluating it. Lisp (programming language)_sentence_136

Any unquoted expressions are recursively evaluated before the enclosing expression is evaluated. Lisp (programming language)_sentence_137

For example, Lisp (programming language)_sentence_138

evaluates to the list (1 2 (3 4)). Lisp (programming language)_sentence_139

Note that the third argument is a list; lists can be nested. Lisp (programming language)_sentence_140

Operators Lisp (programming language)_section_12

Arithmetic operators are treated similarly. Lisp (programming language)_sentence_141

The expression Lisp (programming language)_sentence_142

evaluates to 10. Lisp (programming language)_sentence_143

The equivalent under infix notation would be "1 + 2 + 3 + 4". Lisp (programming language)_sentence_144

Lisp has no notion of operators as implemented in Algol-derived languages. Lisp (programming language)_sentence_145

Arithmetic operators in Lisp are variadic functions (or n-ary), able to take any number of arguments. Lisp (programming language)_sentence_146

A C-style '++' increment operator is sometimes implemented under the name incf giving syntax Lisp (programming language)_sentence_147

equivalent to (setq x (+ x 1)), returning the new value of x. Lisp (programming language)_sentence_148

"Special operators" (sometimes called "special forms") provide Lisp's control structure. Lisp (programming language)_sentence_149

For example, the special operator if takes three arguments. Lisp (programming language)_sentence_150

If the first argument is non-nil, it evaluates to the second argument; otherwise, it evaluates to the third argument. Lisp (programming language)_sentence_151

Thus, the expression Lisp (programming language)_sentence_152

evaluates to (3 4 "bar"). Lisp (programming language)_sentence_153

Of course, this would be more useful if a non-trivial expression had been substituted in place of nil. Lisp (programming language)_sentence_154

Lisp also provides logical operators and, or and not. Lisp (programming language)_sentence_155

The and and or operators do short circuit evaluation and will return their first nil and non-nil argument respectively. Lisp (programming language)_sentence_156

will evaluate to "James". Lisp (programming language)_sentence_157

Lambda expressions and function definition Lisp (programming language)_section_13

Another special operator, lambda, is used to bind variables to values which are then evaluated within an expression. Lisp (programming language)_sentence_158

This operator is also used to create functions: the arguments to 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). Lisp (programming language)_sentence_159

The expression Lisp (programming language)_sentence_160

evaluates to a function that, when applied, takes one argument, binds it to arg and returns the number one greater than that argument. Lisp (programming language)_sentence_161

Lambda expressions are treated no differently from named functions; they are invoked the same way. Lisp (programming language)_sentence_162

Therefore, the expression Lisp (programming language)_sentence_163

evaluates to 6. Lisp (programming language)_sentence_164

Here, we're doing a function application: we execute the anonymous function by passing to it the value 5. Lisp (programming language)_sentence_165

Named functions are created by storing a lambda expression in a symbol using the defun macro. Lisp (programming language)_sentence_166

(defun f (a) b...) defines a new function named f in the global environment. Lisp (programming language)_sentence_167

It is conceptually similar to the expression: Lisp (programming language)_sentence_168

where setf is a macro used to set the value of the first argument fdefinition 'f to a new function object. Lisp (programming language)_sentence_169

fdefinition is a global function definition for the function named f. #' is an abbreviation for function special operator, returning a function object. Lisp (programming language)_sentence_170

Atoms Lisp (programming language)_section_14

In the original LISP there were two fundamental data types: atoms and lists. Lisp (programming language)_sentence_171

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. Lisp (programming language)_sentence_172

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. Lisp (programming language)_sentence_173

For example, the list (FOO (BAR 1) 2) contains three elements: the symbol FOO, the list (BAR 1), and the number 2. Lisp (programming language)_sentence_174

The essential difference between atoms and lists was that atoms were immutable and unique. Lisp (programming language)_sentence_175

Two atoms that appeared in different places in source code but were written in exactly the same way represented the same object, 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. Lisp (programming language)_sentence_176

As more data types were introduced in later Lisp dialects, and programming styles evolved, the concept of an atom lost importance. Lisp (programming language)_sentence_177

Many dialects still retained the predicate atom for legacy compatibility, defining it true for any object which is not a cons. Lisp (programming language)_sentence_178

Conses and lists Lisp (programming language)_section_15

Main article: Cons Lisp (programming language)_sentence_179

A Lisp list is implemented as a singly linked list. Lisp (programming language)_sentence_180

Each cell of this list is called a cons (in Scheme, a pair), and is composed of two pointers, called the car and cdr. Lisp (programming language)_sentence_181

These are respectively equivalent to the data and next fields discussed in the article linked list. Lisp (programming language)_sentence_182

Of the many data structures that can be built out of cons cells, one of the most basic is called a proper list. Lisp (programming language)_sentence_183

A proper list is either the special nil (empty list) symbol, or a cons in which the car points to a datum (which may be another cons structure, such as a list), and the cdr points to another proper list. Lisp (programming language)_sentence_184

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. Lisp (programming language)_sentence_185

For this reason, the car and cdr functions are also called first and rest when referring to conses which are part of a linked list (rather than, say, a tree). Lisp (programming language)_sentence_186

Thus, a Lisp list is not an atomic object, as an instance of a container class in C++ or Java would be. Lisp (programming language)_sentence_187

A list is nothing more than an aggregate of linked conses. Lisp (programming language)_sentence_188

A variable which refers to a given list is simply a pointer to the first cons in the list. Lisp (programming language)_sentence_189

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 functions to map a function over a list. Lisp (programming language)_sentence_190

Because conses and lists are so universal in Lisp systems, it is a common misconception that they are Lisp's only data structures. Lisp (programming language)_sentence_191

In fact, all but the most simplistic Lisps have other data structures, such as vectors (arrays), hash tables, structures, and so forth. Lisp (programming language)_sentence_192

S-expressions represent lists Lisp (programming language)_section_16

Parenthesized S-expressions represent linked list structures. Lisp (programming language)_sentence_193

There are several ways to represent the same list as an S-expression. Lisp (programming language)_sentence_194

A cons can be written in dotted-pair notation as (a . Lisp (programming language)_sentence_195

b), where a is the car and b the cdr. Lisp (programming language)_sentence_196

A longer proper list might be written (a . Lisp (programming language)_sentence_197

(b . Lisp (programming language)_sentence_198

(c . Lisp (programming language)_sentence_199

(d . Lisp (programming language)_sentence_200

nil)))) in dotted-pair notation. Lisp (programming language)_sentence_201

This is conventionally abbreviated as (a b c d) in list notation. Lisp (programming language)_sentence_202

An improper list may be written in a combination of the two – as (a b c . Lisp (programming language)_sentence_203

d) for the list of three conses whose last cdr is d (i.e., the list (a . Lisp (programming language)_sentence_204

(b . Lisp (programming language)_sentence_205

(c . Lisp (programming language)_sentence_206

d))) in fully specified form). Lisp (programming language)_sentence_207

List-processing procedures Lisp (programming language)_section_17

Lisp provides many built-in procedures for accessing and controlling lists. Lisp (programming language)_sentence_208

Lists can be created directly with the list procedure, which takes any number of arguments, and returns the list of these arguments. Lisp (programming language)_sentence_209

Because of the way that lists are constructed from cons pairs, the cons procedure can be used to add an element to the front of a list. Lisp (programming language)_sentence_210

Note that the cons procedure is asymmetric in how it handles list arguments, because of how lists are constructed. Lisp (programming language)_sentence_211

Shared structure Lisp (programming language)_section_18

Lisp lists, being simple linked lists, can share structure with one another. Lisp (programming language)_sentence_212

That is to say, two lists can have the same tail, or final sequence of conses. Lisp (programming language)_sentence_213

For instance, after the execution of the following Common Lisp code: Lisp (programming language)_sentence_214

the lists foo and bar are (a b c) and (x b c) respectively. Lisp (programming language)_sentence_215

However, the tail (b c) is the same structure in both lists. Lisp (programming language)_sentence_216

It is not a copy; the cons cells pointing to b and c are in the same memory locations for both lists. Lisp (programming language)_sentence_217

Sharing structure rather than copying can give a dramatic performance improvement. Lisp (programming language)_sentence_218

However, this technique can interact in undesired ways with functions that alter lists passed to them as arguments. Lisp (programming language)_sentence_219

Altering one list, such as by replacing the c with a goose, will affect the other: Lisp (programming language)_sentence_220

This changes foo to (a b goose), but thereby also changes bar to (x b goose) – a possibly unexpected result. Lisp (programming language)_sentence_221

This can be a source of bugs, and functions which alter their arguments are documented as destructive for this very reason. Lisp (programming language)_sentence_222

Aficionados of functional programming avoid destructive functions. Lisp (programming language)_sentence_223

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 set-car! Lisp (programming language)_sentence_224

(read set car bang), which replaces the car of a cons. Lisp (programming language)_sentence_225

In the Common Lisp dialect, destructive functions are commonplace; the equivalent of set-car! Lisp (programming language)_sentence_226

is named rplaca for "replace car." Lisp (programming language)_sentence_227

This function is rarely seen however as Common Lisp includes a special facility, setf, to make it easier to define and use destructive functions. Lisp (programming language)_sentence_228

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. Lisp (programming language)_sentence_229

Self-evaluating forms and quoting Lisp (programming language)_section_19

Lisp evaluates expressions which are entered by the user. Lisp (programming language)_sentence_230

Symbols and lists evaluate to some other (usually, simpler) expression – for instance, a symbol evaluates to the value of the variable it names; (+ 2 3) evaluates to 5. Lisp (programming language)_sentence_231

However, most other forms evaluate to themselves: if entering 5 into Lisp, it returns 5. Lisp (programming language)_sentence_232

Any expression can also be marked to prevent it from being evaluated (as is necessary for symbols and lists). Lisp (programming language)_sentence_233

This is the role of the quote special operator, or its abbreviation ' (one quotation mark). Lisp (programming language)_sentence_234

For instance, usually if entering the symbol foo, it returns the value of the corresponding variable (or an error, if there is no such variable). Lisp (programming language)_sentence_235

To refer to the literal symbol, enter (quote foo) or, usually, 'foo. Lisp (programming language)_sentence_236

Both Common Lisp and Scheme also support the backquote operator (termed quasiquote in Scheme), entered with the ` character (grave accent). Lisp (programming language)_sentence_237

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 , unquote and comma-at ,@ splice operators. Lisp (programming language)_sentence_238

If the variable snue has the value (bar baz) then `(foo ,snue) evaluates to (foo (bar baz)), while `(foo ,@snue) evaluates to (foo bar baz). Lisp (programming language)_sentence_239

The backquote is most often used in defining macro expansions. Lisp (programming language)_sentence_240

Self-evaluating forms and quoted forms are Lisp's equivalent of literals. Lisp (programming language)_sentence_241

It may be possible to modify the values of (mutable) literals in program code. Lisp (programming language)_sentence_242

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. Lisp (programming language)_sentence_243

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 (programming language)_sentence_244

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

Scope and closure Lisp (programming language)_section_20

The Lisp family splits over the use of dynamic or static (a.k.a. lexical) scope. Lisp (programming language)_sentence_246

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. Lisp (programming language)_sentence_247

Since version 24.1, Emacs uses both dynamic and lexical scoping. Lisp (programming language)_sentence_248

List structure of program code; exploitation by macros and compilers Lisp (programming language)_section_21

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 (programming language)_sentence_249

Lisp uses this to implement a very powerful macro system. Lisp (programming language)_sentence_250

Like other macro languages such as C, a macro returns code that can then be compiled. Lisp (programming language)_sentence_251

However, unlike C macros, the macros are Lisp functions and so can exploit the full power of Lisp. Lisp (programming language)_sentence_252

Further, because Lisp code has the same structure as lists, macros can be built with any of the list-processing functions in the language. Lisp (programming language)_sentence_253

In short, anything that Lisp can do to a data structure, Lisp macros can do to code. Lisp (programming language)_sentence_254

In contrast, in most other languages, the parser's output is purely internal to the language implementation and cannot be manipulated by the programmer. Lisp (programming language)_sentence_255

This feature makes it easy to develop efficient languages within languages. Lisp (programming language)_sentence_256

For example, the Common Lisp Object System can be implemented cleanly as a language extension using macros. Lisp (programming language)_sentence_257

This means that if an application needs a different inheritance mechanism, it can use a different object system. Lisp (programming language)_sentence_258

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. Lisp (programming language)_sentence_259

In simplistic Lisp implementations, this list structure is directly interpreted to run the program; a function is literally a piece of list structure which is traversed by the interpreter in executing it. Lisp (programming language)_sentence_260

However, most substantial Lisp systems also include a compiler. Lisp (programming language)_sentence_261

The compiler translates list structure into machine code or bytecode for execution. Lisp (programming language)_sentence_262

This code can run as fast as code compiled in conventional languages such as C. Lisp (programming language)_sentence_263

Macros expand before the compilation step, and thus offer some interesting options. Lisp (programming language)_sentence_264

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. Lisp (programming language)_sentence_265

Some Lisp implementations even have a mechanism, eval-when, that allows code to be present during compile time (when a macro would need it), but not present in the emitted module. Lisp (programming language)_sentence_266

Evaluation and the read–eval–print loop Lisp (programming language)_section_22

Lisp languages are often used with an interactive command line, which may be combined with an integrated development environment (IDE). Lisp (programming language)_sentence_267

The user types in expressions at the command line, or directs the IDE to transmit them to the Lisp system. Lisp (programming language)_sentence_268

Lisp reads the entered expressions, evaluates them, and prints the result. Lisp (programming language)_sentence_269

For this reason, the Lisp command line is called a read–eval–print loop (REPL). Lisp (programming language)_sentence_270

The basic operation of the REPL is as follows. Lisp (programming language)_sentence_271

This is a simplistic description which omits many elements of a real Lisp, such as quoting and macros. Lisp (programming language)_sentence_272

The read function accepts textual S-expressions as input, and parses them into an internal data structure. Lisp (programming language)_sentence_273

For instance, if you type the text (+ 1 2) at the prompt, read translates this into a linked list with three elements: the symbol +, the number 1, and the number 2. Lisp (programming language)_sentence_274

It so happens that this list is also a valid piece of Lisp code; that is, it can be evaluated. Lisp (programming language)_sentence_275

This is because the car of the list names a function—the addition operation. Lisp (programming language)_sentence_276

Note that a foo will be read as a single symbol. Lisp (programming language)_sentence_277

123 will be read as the number one hundred and twenty-three. Lisp (programming language)_sentence_278

"123" will be read as the string "123". Lisp (programming language)_sentence_279

The eval function evaluates the data, returning zero or more other Lisp data as a result. Lisp (programming language)_sentence_280

Evaluation does not have to mean interpretation; some Lisp systems compile every expression to native machine code. Lisp (programming language)_sentence_281

It is simple, however, to describe evaluation as interpretation: To evaluate a list whose car names a function, eval first evaluates each of the arguments given in its cdr, then applies the function to the arguments. Lisp (programming language)_sentence_282

In this case, the function is addition, and applying it to the argument list (1 2) yields the answer 3. Lisp (programming language)_sentence_283

This is the result of the evaluation. Lisp (programming language)_sentence_284

The symbol foo evaluates to the value of the symbol foo. Lisp (programming language)_sentence_285

Data like the string "123" evaluates to the same string. Lisp (programming language)_sentence_286

The list (quote (1 2 3)) evaluates to the list (1 2 3). Lisp (programming language)_sentence_287

It is the job of the print function to represent output to the user. Lisp (programming language)_sentence_288

For a simple result such as 3 this is trivial. Lisp (programming language)_sentence_289

An expression which evaluated to a piece of list structure would require that print traverse the list and print it out as an S-expression. Lisp (programming language)_sentence_290

To implement a Lisp REPL, it is necessary only to implement these three functions and an infinite-loop function. Lisp (programming language)_sentence_291

(Naturally, the implementation of eval will be complex, since it must also implement all special operators like if or lambda.) Lisp (programming language)_sentence_292

This done, a basic REPL is one line of code: (loop (print (eval (read)))). Lisp (programming language)_sentence_293

The Lisp REPL typically also provides input editing, an input history, error handling and an interface to the debugger. Lisp (programming language)_sentence_294

Lisp is usually evaluated eagerly. Lisp (programming language)_sentence_295

In Common Lisp, arguments are evaluated in applicative order ('leftmost innermost'), while in Scheme order of arguments is undefined, leaving room for optimization by a compiler. Lisp (programming language)_sentence_296

Control structures Lisp (programming language)_section_23

Lisp originally had very few control structures, but many more were added during the language's evolution. Lisp (programming language)_sentence_297

(Lisp's original conditional operator, cond, is the precursor to later if-then-else structures.) Lisp (programming language)_sentence_298

Programmers in the Scheme dialect often express loops using tail recursion. Lisp (programming language)_sentence_299

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. Lisp (programming language)_sentence_300

All oft-seen Lisp dialects have imperative-style iteration constructs, from Scheme's do loop to Common Lisp's complex loop expressions. Lisp (programming language)_sentence_301

Moreover, the key issue that makes this an objective rather than subjective matter is that Scheme makes specific requirements for the handling of tail calls, 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. Lisp (programming language)_sentence_302

By contrast, ANSI Common Lisp does not require the optimization commonly termed a tail call elimination. Lisp (programming language)_sentence_303

Thus, the fact that tail recursive style as a casual replacement for the use of more traditional iteration constructs (such as do, dolist or loop) is discouraged 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 jump) and program correctness (since tail recursion may increase stack use in Common Lisp, risking stack overflow). Lisp (programming language)_sentence_304

Some Lisp control structures are special operators, equivalent to other languages' syntactic keywords. Lisp (programming language)_sentence_305

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. Lisp (programming language)_sentence_306

In contrast to most other major programming languages, Lisp allows implementing control structures using the language. Lisp (programming language)_sentence_307

Several control structures are implemented as Lisp macros, and can even be macro-expanded by the programmer who wants to know how they work. Lisp (programming language)_sentence_308

Both Common Lisp and Scheme have operators for non-local control flow. Lisp (programming language)_sentence_309

The differences in these operators are some of the deepest differences between the two dialects. Lisp (programming language)_sentence_310

Scheme supports re-entrant continuations using the call/cc procedure, which allows a program to save (and later restore) a particular place in execution. Lisp (programming language)_sentence_311

Common Lisp does not support re-entrant continuations, but does support several ways of handling escape continuations. Lisp (programming language)_sentence_312

Often, the same algorithm can be expressed in Lisp in either an imperative or a functional style. Lisp (programming language)_sentence_313

As noted above, Scheme tends to favor the functional style, using tail recursion and continuations to express control flow. Lisp (programming language)_sentence_314

However, imperative style is still quite possible. Lisp (programming language)_sentence_315

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. Lisp (programming language)_sentence_316

Because of Lisp's early heritage in list processing, it has a wide array of higher-order functions relating to iteration over sequences. Lisp (programming language)_sentence_317

In many cases where an explicit loop would be needed in other languages (like a for loop in C) in Lisp the same task can be accomplished with a higher-order function. Lisp (programming language)_sentence_318

(The same is true of many functional programming languages.) Lisp (programming language)_sentence_319

A good example is a function which in Scheme is called map and in Common Lisp is called mapcar. Lisp (programming language)_sentence_320

Given a function and one or more lists, mapcar applies the function successively to the lists' elements in order, collecting the results in a new list: Lisp (programming language)_sentence_321

This applies the + function to each corresponding pair of list elements, yielding the result (11 22 33 44 55). Lisp (programming language)_sentence_322

Examples Lisp (programming language)_section_24

Here are examples of Common Lisp code. Lisp (programming language)_sentence_323

The basic "Hello, World!" Lisp (programming language)_sentence_324

program: Lisp (programming language)_sentence_325

Lisp syntax lends itself naturally to recursion. Lisp (programming language)_sentence_326

Mathematical problems such as the enumeration of recursively defined sets are simple to express in this notation. Lisp (programming language)_sentence_327

For example, to evaluate a number's factorial: Lisp (programming language)_sentence_328

An alternative implementation takes less stack space than the previous version if the underlying Lisp system optimizes tail recursion: Lisp (programming language)_sentence_329

Contrast the examples above with an iterative version which uses Common Lisp's loop macro: Lisp (programming language)_sentence_330

The following function reverses a list. Lisp (programming language)_sentence_331

(Lisp's built-in reverse function does the same thing.) Lisp (programming language)_sentence_332

Object systems Lisp (programming language)_section_25

Various object systems and models have been built on top of, alongside, or into Lisp, including: Lisp (programming language)_sentence_333

Lisp (programming language)_unordered_list_3

  • 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).Lisp (programming language)_item_3_22
  • ObjectLisp or Object Lisp, used by Lisp Machines Incorporated and early versions of Macintosh Common LispLisp (programming language)_item_3_23
  • LOOPS (Lisp Object-Oriented Programming System) and the later CommonLOOPSLisp (programming language)_item_3_24
  • Flavors, built at MIT, and its descendant New Flavors (developed by Symbolics).Lisp (programming language)_item_3_25
  • KR (short for Knowledge Representation), a constraints-based object system developed to aid the writing of Garnet, a GUI library for Common Lisp.Lisp (programming language)_item_3_26
  • Knowledge Engineering Environment (KEE) used an object system called UNITS and integrated it with an inference engine and a truth maintenance system (ATMS).Lisp (programming language)_item_3_27

See also Lisp (programming language)_section_26

Lisp (programming language)_unordered_list_4


Credits to the contents of this page go to the authors of the corresponding Wikipedia page: en.wikipedia.org/wiki/Lisp (programming language).