# 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 (66 P)

## Pages in category "Common Lisp"

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

(previous page) (next page)### D

### E

- Echo server
- Egyptian division
- Element-wise operations
- Elementary cellular automaton
- Emirp primes
- Empty directory
- Empty program
- Empty string
- Entropy
- Enumerations
- Environment variables
- Equilibrium index
- Ethiopian multiplication
- Euler method
- Euler's identity
- Euler's sum of powers conjecture
- Evaluate binomial coefficients
- Even or odd
- Evolutionary algorithm
- Exceptions
- Exceptions/Catch an exception thrown in a nested call
- Execute a Markov algorithm
- Execute a system command
- Execute Brain****
- Execute HQ9+
- Exponentiation operator
- Exponentiation order
- Extend your language
- Extract file extension

### F

- Factorial
- Factorions
- Factors of a Mersenne number
- Factors of an integer
- Farey sequence
- Fast Fourier transform
- FASTA format
- Fermat numbers
- Fibonacci n-step number sequences
- Fibonacci sequence
- Fibonacci word
- File input/output
- File modification time
- File size
- Filter
- Find Chess960 starting position identifier
- Find common directory path
- Find if a point is within a triangle
- Find limit of recursion
- Find palindromic numbers in both binary and ternary bases
- Find the intersection of two lines
- Find the last Sunday of each month
- Find the missing permutation
- Find words which contains all the vowels
- First-class functions
- First-class functions/Use numbers analogously
- Five weekends
- FizzBuzz
- Flatten a list
- Floyd's triangle
- Floyd-Warshall algorithm
- Forest fire
- Fork
- Formal power series
- Formatted numeric output
- Forward difference
- Four bit adder
- Four is magic
- Fractal tree
- Fractran
- FTP
- Function composition
- Function definition
- Function frequency
- Function prototype

### G

- Gamma function
- Gapful numbers
- Gaussian elimination
- General FizzBuzz
- Generate Chess960 starting position
- Generate lower case ASCII alphabet
- Generator/Exponential
- Generic swap
- Get system command output
- Globally replace text in several files
- Gradient descent
- Gray code
- Grayscale image
- Greatest common divisor
- Greatest element of a list
- Greatest subsequential sum
- Greedy algorithm for Egyptian fractions
- Guess the number
- Guess the number/With feedback
- Guess the number/With feedback (player)
- GUI component interaction

### H

- Hailstone sequence
- Hamming numbers
- Handle a signal
- Happy numbers
- Harshad or Niven series
- Hash from two arrays
- Hash join
- Haversine formula
- Hello world/Graphical
- Hello world/Line printer
- Hello world/Newbie
- Hello world/Newline omission
- Hello world/Standard error
- Hello world/Text
- Hello world/Web server
- Here document
- Higher-order functions
- History variables
- Hofstadter Figure-Figure sequences
- Hofstadter Q sequence
- Hofstadter-Conway $10,000 sequence
- Holidays related to Easter
- Horner's rule for polynomial evaluation
- Host introspection
- Hostname
- HTTP
- HTTPS
- Huffman coding
- Hunt the Wumpus

### I

- I before E except after C
- IBAN
- Identity matrix
- Idiomatically determine all the lowercase and uppercase letters
- Image convolution
- Image noise
- Include a file
- Increment a numerical string
- Infinity
- Inheritance/Multiple
- Inheritance/Single
- Input loop
- Integer comparison
- Integer long division
- Integer sequence
- Interactive help
- Interactive programming (repl)
- Introspection
- Inverted index
- Inverted syntax
- Isqrt (integer square root) of X
- Iterated digits squaring

### K

### L

- Langton's ant
- Largest int from concatenated ints
- Last Friday of each month
- Last letter-first letter
- Leap year
- Least common multiple
- Left factorials
- Leonardo numbers
- Letter frequency
- Levenshtein distance
- Linear congruential generator
- List comprehensions
- Literals/Floating point
- Literals/Integer
- Literals/String
- Logical operations
- Long multiplication
- Long primes
- Long year
- Longest common subsequence
- Longest common substring
- Longest increasing subsequence
- Look-and-say sequence
- Loop over multiple arrays simultaneously
- Loops/Break
- Loops/Continue
- Loops/Do-while
- Loops/Downward for
- Loops/For
- Loops/For with a specified step
- Loops/Foreach
- Loops/Increment loop index within loop body
- Loops/Infinite

- 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