Common Lisp
Common Lisp, commonly abbreviated CL, is a dialect of Lisp, standardised by ANSI X3.226-1994. Developed to standardize the divergent variants of Lisp which predated it, it is not an implementation but rather a language specification to which most Lisp implementations conform.Common Lisp is a general-purpose programming language, in contrast to Lisp variants such as Emacs Lisp and AutoLISP which are embedded extension languages in particular products. Unlike many earlier Lisps, but like Scheme, Common Lisp uses lexical scoping for variables.
Common Lisp is a multi-paradigm programming language that:
- Supports programming techniques such as imperative, functional and object-oriented programming.
- Is dynamically typed, but with optional type declarations that can improve efficiency or safety.
- Is extensible through standard features such as macros and reader macros.
| Table of contents |
|
2 Data types 3 Comparison with other Lisps 4 Implementations 5 Applications 6 External links |
The Common Lisp character type is not limited to ASCII characters -- unsurprising, as Lisp predates ASCII. Some modern implementations allow Unicode characters. [1]
The symbol type is common to Lisp languages, but largely unknown outside them. A symbol is a unique, named data object. Symbols in Lisp are similar to identifiers in other languages, in that they are used as variables to hold values; however, they are more general and can be used for themselves as well. Normally, when a symbol is evaluated, its value as a variable is returned. Exceptions exist: keyword symbols such as :foo evaluate to themselves, and Boolean values in Common Lisp are represented by the reserved symbols T and NIL.
As in any other Lisp, lists in Common Lisp are composed of conses, sometimes called cons cells or pairs. A cons is a data structure of two pointers, called its car and cdr. A list is a linked chain of conses wherein each cons's cdr points to the next element, and the last cdr points to the NIL value. Conses can also easily be used to implement trees and other complex data structures.
Hash tables store associations between data objects. Any object may be used as key or value. Hash tables, like arrays, are automatically resized as needed.
Packages are collections of symbols, used chiefly to separate the parts of a program into namespaces. A package may export some symbols, marking them as part of a public interface.
Structures, akin to C structs and Pascal records, represent arbitrary complex data structures with any number and type of fields (called slots).
The Common Lisp library relies heavily on such higher-order functions. For example, the
While a function definition (a
Macros allow Lisp programmers to create new syntactic forms in the language. For instance, this macro provides the
Some Lisp systems, such as Scheme, avoid variable capture by using macro syntaxes -- so-called "hygienic macros" -- which do not allow it. In Common Lisp, one can avoid unwanted capture by using gensyms -- guaranteed-unique symbols which can be used in a macroexpansion without threat of capture.
Most of the Lisp systems whose designs contributed to Common Lisp -- such as Zetalisp and Franz Lisp -- used only dynamically-scoped variables. Scheme introduced lexically-scoped variables to Lisp, which were widely recognized as a good idea and adopted into CL. However, CL supports dynamically-scoped variables as well, they must be explicitly declared as "special".
Common Lisp is sometimes termed a Lisp-2 and Scheme a Lisp-1, referring to CL's use of separate namespaces for functions and variables. (In fact, CL has many namespaces, such as those for go tags, block names, and
In addition, implementations tend to come with divergent sets of library packages, which provide functionality not covered in the standard. Some of these features have been rolled back into the standard, such as CLOS and the LOOP construct; others remain implementation-specific. Unfortunately, many valuable facilities for the modern programmer -- such as TCP/IP networking -- remain unstandardized. However, open-source packages have been created to support such features in a portable way, most notably the Common Lisp Open Code Collection project.
Common Lisp has been designed to be implemented by incremental compilers. Standard declarations to optimize compilation (such as function inlining) are proposed in the language specification. Most Common Lisp implementations compile functions to native machine code. Others compile to bytecode, which reduces speed but eases binary-code portability. The misconception that Lisp is a purely-interpreted language is most likely due to the fact that Common Lisp environments provide an interactive prompt and that functions are compiled one-by-one, in an incremental way.
Some Unix-based implementations, such as CLISP, can be used as script interpreters; that is, invoked by the system transparently in the way that a Perl or Unix shell interpreter is.
Freely redistributable implementations include:
Despite the big expectations of the standard committee (CL was sometimes advertised as a possible replacement for C), Common Lisp remained a niche programming language, mostly used in academia and/or specific application areas often related to Artificial Intelligence.
However, there are famous sucess stories that at least show the big potential of the language in an industrial setting. To advertise their favorite language, most CLispers take the example of the famous Yahoo Store! web-commerce site, originally developped in Common Lisp.
There also exist successful open-source applications written in Common Lisp, such as:
Syntax
Common Lisp is a Lisp; it uses S-expressions to denote both code and data structure. Function and macro calls are written as lists, with the name of the function first, as in these examples:(+ 2 2) ; adds 2 and 2, yielding 4
(setq pi 3.1415) ; sets the variable "pi" equal to 3.1415
; Define a function that squares a number
(defun square (x) (* x x))
; Execute the function
(square 3) ; Returns "9"
Data types
Common Lisp has a plethora of data types, more than many languages.Scalar types
Number types include integers, ratios, floating-point numbers, and complex numbers. Common Lisp uses bignums to represent numerical values of arbitrary size and precision. The ratio type represents fractions exactly, a facility not available in many languages. Common Lisp automatically coerces numeric values among these types as appropriate.Data structures
Sequence types in Common Lisp include arrays, vectors, bit-vectors, and strings. Common Lisp supports multidimensional arrays, and can dynamically resize arrays as needed. Multidimensional arrays can be used for matrix mathematics.Functions
In Common Lisp, the type of functions is a data type. For instance, it is possible to write functions that take other functions as arguments or return functions as well. This makes it possible to describe very general operations. sort function takes a comparison operator as an argument. This can be used not only to sort any type of data, but also to sort data structures according to a key.(sort (list 5 2 6 3 1 4) #'>)
: Sorts the list using the > function as the comparison operator.
; Returns (6 5 4 3 2 1).
(sort (list '(9 a) '(3 b) '(4 c))
#'(lambda (x y) (< (car x) (car y))))
; Sorts the list according to the first element (car) of each sub-list.
; Returns ((3 b) (4 c) (9 a)).
Unlike Scheme, Common Lisp uses separate namespaces for defined functions and for variables. While this design choice was extremely disputed, the rationale is that since functions and variables are different things treated differently by the implementations, they should also be treated differently by the programmer. While this is not recommended, it means that it is possible to name a variable list, or even if, without shadowing a globally named function. However, as a result it is necessary to use the prefix #' when referring to (not using) a function. defun form) is a list, functions are not generally internally represented as lists. Most Common Lisp systems compile functions individually to bytecode or machine code.Other types
Other data types in Common Lisp include:
Common Lisp also includes a toolkit for object-oriented programming, the Common Lisp Object System or CLOS.Macros
A macro in Lisp superficially resembles a function. However, rather than representing an expression which is evaluated, it represents a transformation of the program text within the macro call.until loop form, which may be familiar from languages such as Perl:(defmacro until (test &rest body)
`(do ()
(,test)
,@body))
This differs from a function in that it can repeatedly evaluate its arguments. A function's arguments are evaluated only once, before the function is called; a macro controls its arguments' evaluation or other use in the macro-expansion.Variable capture
Common Lisp macros are capable of variable capture, a situation in which symbols in the macro-expansion body coincide with those in the calling context. Variable capture is sometimes a desired effect: it allows the programmer to create macros wherein various symbols have special meaning. However, it can also introduce unexpected and unusual errors.Comparison with other Lisps
Common Lisp is most frequently compared with, and contrasted to, Scheme -- if only because they are the two most popular Lisp dialects. Scheme antedates CL, and comes not only from the same Lisp tradition but from some of the same engineers -- Guy L. Steele, who with Gerald Jay Sussman designed Scheme, chaired the standards committee for Common Lisp.loop keywords.) There is a long-standing controversy between CL and Scheme advocates over the tradeoffs involved in multiple namespaces. In Scheme, it is (broadly) necessary to avoid giving variables names which clash with functions; Scheme functions frequently have arguments named lis, lst, or lyst so as not to conflict with the system function list. However, in CL it is necessary to explicitly refer to the function namespace when passing a function as an argument -- which is also a common occurrence, as in the sort example above.Implementations
Common Lisp is defined by a specification (like Ada and C) rather than by a single implementation (like Perl). There are many implementations, and the standard spells out areas in which they may validly differ.List of implementations
There are also commercial implementations available from Franz, Xanalys, Digitool, Corman and Scieneer.Applications
This non-exhaustive list illustrates the idea that Common Lisp is primarily used when (technically) difficult problems are adressed. Moreover, many CL applications implement "a language-in-the-language" approach, for which program-as-data manipulation as provided by the language (through s-expressio representation and support for macros) is particularly adapted.External links
, known as "CLtL2". Guy Steele's text on the Common Lisp system, originally written before the ANSI standard but revised to address it.