Editing Common Lisp (section)

==Comparison with other Lisps==
<!-- needs lots -->
Common Lisp is most frequently compared with, and contrasted to, [[Scheme (programming language)|Scheme]]—if only because they are the two most popular Lisp dialects. Scheme predates CL, and comes not only from the same Lisp tradition but from some of the same engineers—[[Guy Steele]], with whom [[Gerald Jay Sussman]] designed Scheme, chaired the standards committee for Common Lisp.

Common Lisp is a general-purpose programming language, in contrast to Lisp variants such as [[Emacs Lisp]] and [[AutoLISP]] which are [[extension languages]] embedded in particular products (GNU Emacs and AutoCAD, respectively). Unlike many earlier Lisps, Common Lisp (like [[Scheme (programming language)|Scheme]]) uses lexical variable [[scope (programming)|scope]] by default for both interpreted and compiled code.

Most of the Lisp systems whose designs contributed to Common Lisp—such as [[ZetaLisp]] and Franz Lisp—used dynamically [[scope (programming)|scoped]] variables in their interpreters and lexically scoped variables in their compilers. Scheme introduced the sole use of lexically scoped variables to Lisp; an inspiration from [[ALGOL 68]]. CL supports dynamically scoped variables as well, but they must be explicitly declared as "special". There are no differences in scoping between ANSI CL interpreters and compilers.

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 <code>loop</code> 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 that clash with functions; Scheme functions frequently have arguments named <code>lis</code>, <code>lst</code>, or <code>lyst</code> so as not to conflict with the system function <code>list</code>. 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 <code>sort</code> example above.

CL also differs from Scheme in its handling of Boolean values. Scheme uses the special values #t and #f to represent truth and falsity. CL follows the older Lisp convention of using the symbols T and NIL, with NIL standing also for the empty list. In CL, ''any'' non-NIL value is treated as true by conditionals, such as <code>if</code>, whereas in Scheme all non-#f values are treated as true. These conventions allow some operators in both languages to serve both as predicates (answering a Boolean-valued question) and as returning a useful value for further computation, but in Scheme the value '() which is equivalent to NIL in Common Lisp evaluates to true in a Boolean expression.

Lastly, the Scheme standards documents require [[tail recursion|tail-call optimization]], which the CL standard does not. Most CL implementations do offer tail-call optimization, although often only when the programmer uses an optimization directive. Nonetheless, common CL coding style does not favor the ubiquitous use of recursion that Scheme style prefers—what a Scheme programmer would express with tail recursion, a CL user would usually express with an iterative expression in <code>do</code>, <code>dolist</code>, <code>loop</code>, or (more recently) with the <code>iterate</code> package.