SBCL 1.0.1

Version of implementation Steel Bank Common Lisp of programming language Lisp

A version of SBCL compiler.

Examples:

Factorial - Lisp (22):

This example uses recursive factorial definition (which is natural for Lisp). Features:

• math operators: `(- n 1)` is prefix notation equivalent to `n-1` in infix notation;
• comparison operators: `(= n 0)` evaluates to `T` if n is zero, and to `nil` (used as false) otherwise;
• conditional operator `if`: Lisp expressions are evaluated using brackets, so they can be written in several lines;
• function definition using `defun`;
• Common Lisp macro `loop`;
• format specifiers in `format`: `~D` corresponds to printing an integer, and `~%` is end-of-line.
``````(defun factorial (n)
(if (= n 0)
1
(* n (factorial (- n 1))) ) )

(loop for i from 0 to 16
do (format t "~D! = ~D~%" i (factorial i)) )
``````

Fibonacci numbers - Lisp (23):

This example uses recursive definition of Fibonacci numbers and expands use of `loop` macro to `finally` clause (expression evaluated after the loop is done).

``````(defun fibonacci (n)
(if (< n 3)
1
(+ (fibonacci (- n 1)) (fibonacci (- n 2))) ) )

(loop for i from 1 to 16
do (format t "~D, " (fibonacci i))
finally (format t "...~%") )
``````

Factorial - Lisp (121):

In this example the inner loop with `collect` clause produces a list of numbers from 1 to `n`. After this operation `*` is applied to this list, and the product of the numbers is printed.

``````(loop for n from 0 to 16
do (format t "~D! = ~D~%" n
(apply '* (loop for i from 1 to n
collect i)) ) )
``````

Hello, World! - Lisp (21):

When executed in interactive mode, program output looks as follows:

Hello, World!
NIL

First line contains standard output, second — the result of expression evaluation (in this case there is none).

``````(format t "Hello, World!~%")
``````

Quadratic equation - Lisp (172):

Common Lisp provides complex numbers as datatype, printed as `#C(real imag)`. `write-to-string` converts a number into a string.

Note that for interactive evaluation it’s enough to add `(quadratic-roots-2 1 0 1)` to see the result of calculation, while for compiled execution you’ll have to wrap call of this function in printing command, like `(format t (quadratic-roots-2 1 0 1))`.

``````(defun quadratic-roots-2 (A B C)
(cond ((= A 0) (string "Not a quadratic equation."))
(t
(let ((D (- (* B B) (* 4 A C))))
(cond ((= D 0) (concatenate 'string "x = " (write-to-string (/ (+ (- B) (sqrt D)) (* 2 A)))))
(t
(values (concatenate 'string "x1 = " (write-to-string (/ (+ (- B) (sqrt D)) (* 2 A))))
(concatenate 'string "x2 = " (write-to-string (/ (- (- B) (sqrt D)) (* 2 A)))))))))))
``````

CamelCase - Lisp (277):

``````(defun camel-case (s)
(remove #\Space
(string-capitalize
(substitute #\Space nil s :key #'alpha-char-p))))