# Category:Common Lisp

**Common Lisp**

This

**programming language**may be used to instruct a computer to perform a task.

Execution method: | Compiled (machine code) |
---|---|

Garbage collected: | Yes |

Type safety: | Safe |

Type strength: | Strong |

Type checking: | Dynamic, Static |

See Also: |

**Common Lisp**, commonly abbreviated **CL**, is a dialect of the Lisp programming language, standardised by ANSI X3.226-1994. Developed as a common successor to Maclisp and Lisp Machine Lisp, it is not an implementation but a language specification.

Several implementations of the Common Lisp standard are available, including commercial products and open source software: Steel Bank Common Lisp (SBCL), forked from the earlier CMU Common Lisp (CMUCL), is the most actively maintained open source implementation. CLISP was also a common choice in the past and is used by some Lisp books such as *Land of Lisp* (2010) for their code examples, but as of 2022 development has slowed to a crawl. LispWorks is the commonly used commercial alternative to SBCL and offers advanced GUI options, but is quite expensive and may not be worth it if a developer mainly wants to program non-GUI applications.

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, Common Lisp (like Scheme) uses lexical variable scope.

A "*" (SBCL), ">" (CLISP), or "CL-USER> " prompt seen in front of some examples shows that the code was run in a Lisp read-eval-print loop, or REPL, running interactively in an environment such as SLIME.

## Citations[edit]

## Subcategories

This category has the following 3 subcategories, out of 3 total.

### @

- Common Lisp Implementations (6 P)
- Common Lisp User (67 P)

## Pages in category "Common Lisp"

The following 200 pages are in this category, out of 769 total.

(previous page) (next page)### A

- A* search algorithm
- A+B
- Abbreviations, automatic
- ABC problem
- Abstract type
- Abundant odd numbers
- Abundant, deficient and perfect number classifications
- Accumulator factory
- Ackermann function
- Active object
- Add a variable to a class instance at runtime
- Additive primes
- Address of a variable
- AKS test for primes
- Algebraic data types
- Align columns
- Aliquot sequence classifications
- Almkvist-Giullera formula for pi
- Almost prime
- Amb
- Amicable pairs
- Anagrams
- Anagrams/Deranged anagrams
- Angle difference between two bearings
- Angles (geometric), normalization and conversion
- Animate a pendulum
- Animation
- Anonymous recursion
- Anti-primes
- Append a record to the end of a text file
- Apply a callback to an array
- Apply a digital filter (direct form II transposed)
- Approximate equality
- Arbitrary-precision integers (included)
- Archimedean spiral
- Arithmetic evaluation
- Arithmetic-geometric mean
- Arithmetic-geometric mean/Calculate Pi
- Arithmetic/Complex
- Arithmetic/Integer
- Arithmetic/Rational
- Array concatenation
- Array length
- Arrays
- Aspect oriented programming
- Assertions
- Associative array/Creation
- Associative array/Iteration
- Associative array/Merging
- Atomic updates
- Attractive numbers
- Averages/Arithmetic mean
- Averages/Mean angle
- Averages/Mean time of day
- Averages/Median
- Averages/Mode
- Averages/Pythagorean means
- Averages/Root mean square
- Averages/Simple moving average
- AVL tree

### B

- Babbage problem
- Bacon cipher
- Balanced brackets
- Balanced ternary
- Barnsley fern
- Base64 decode data
- Base64 encode data
- Bell numbers
- Benford's law
- Bernoulli numbers
- Best shuffle
- Binary digits
- Binary search
- Binary strings
- Bioinformatics/Sequence mutation
- Biorhythms
- Bitcoin/public point to address
- Bitmap
- Bitmap/Bresenham's line algorithm
- Bitmap/Histogram
- Bitmap/Midpoint circle algorithm
- Bitmap/Read a PPM file
- Bitmap/Write a PPM file
- Bitwise IO
- Bitwise operations
- Boolean values
- Brace expansion
- Break OO privacy
- Brownian tree
- Bulls and cows
- Bulls and cows/Player

### C

- Caesar cipher
- Calculating the value of e
- Calendar
- Calendar - for "REAL" programmers
- Call a foreign-language function
- Call a function
- Call a function in a shared library
- Call an object method
- Canonicalize CIDR
- Cartesian product of two or more lists
- Case-sensitivity of identifiers
- Casting out nines
- Catalan numbers
- Catalan numbers/Pascal's triangle
- Catamorphism
- Chaos game
- Character codes
- Chat server
- Check input device is a terminal
- Check output device is a terminal
- Check that file exists
- Cheryl's birthday
- Chinese remainder theorem
- Chinese zodiac
- Cholesky decomposition
- Classes
- Closest-pair problem
- Closures/Value capture
- Collections
- Color of a screen pixel
- Color quantization
- Colour bars/Display
- Colour pinstripe/Display
- Combinations
- Combinations and permutations
- Combinations with repetitions
- Comma quibbling
- Command-line arguments
- Comments
- Compare a list of strings
- Compare length of two strings
- Compile-time calculation
- Compiler/lexical analyzer
- Compiler/syntax analyzer
- Compiler/virtual machine interpreter
- Compound data type
- Concurrent computing
- Conditional structures
- Conjugate transpose
- Constrained genericity
- Constrained random points on a circle
- Continued fraction
- Continued fraction/Arithmetic/Construct from rational number
- Continued fraction/Arithmetic/G(matrix ng, continued fraction n)
- Continued fraction/Arithmetic/G(matrix ng, continued fraction n1, continued fraction n2)
- Convert decimal number to rational
- Convert seconds to compound duration
- Convex hull
- Conway's Game of Life
- Copy a string
- Copy stdin to stdout
- Count how many vowels and consonants occur in a string
- Count in factors
- Count in octal
- Count occurrences of a substring
- Count the coins
- Cramer's rule
- CRC-32
- Create a file
- Create a two-dimensional array at runtime
- Create an HTML table
- CSV data manipulation
- CSV to HTML translation
- Cuban primes
- Cumulative standard deviation
- Currying
- CUSIP
- Cut a rectangle

### D

- Date format
- Day of the week
- Deal cards for FreeCell
- Deconvolution/1D
- Deepcopy
- Define a primitive data type
- Delegates
- Delete a file
- Detect division by zero
- Determinant and permanent
- Determine if a string has all the same characters
- Determine if a string has all unique characters
- Determine if a string is numeric
- Dice game probabilities
- Digital root
- Digital root/Multiplicative digital root
- Dijkstra's algorithm
- Dinesman's multiple-dwelling problem
- Dining philosophers
- DNS query
- Documentation

- Execution method/Compiled/Machine code
- Garbage collection/Yes
- Typing/Safe
- Typing/Strong
- Typing/Checking/Dynamic
- Typing/Checking/Static
- Programming Languages
- Implementations
- Lisp Implementations
- Lisp related
- Programming paradigm/Functional
- Programming paradigm/Procedural
- Programming paradigm/Object-oriented
- Programming paradigm/Reflective