135 forms available:
*
**
+
-
/
<
<=
=
>
>=
abs
and
apply
atom?
bang
body
butlast
capitalize
car
cdr
colon
comma
comment
comp
complement
concat
concat2
cond
cons
constantly
dec
def
defmacro
defn
doc
dotimes
downcase
drop
enumerate
error
errors
eval
even?
every
exclaim
exit
filter
flatten
foreach
forms
fuse
gensym
help
identity
if
if-not
inc
interpose
is
isqrt
juxt
lambda
last
len
let
let*
list
list*
list?
load
loop
macroexpand-1
map
mapcat
max
min
neg?
not
not=
nth
number?
odd?
or
partial
period
pos?
print
printl
println
progn
punctuate
punctuate-atom
quote
randalpha
randchoice
randigits
randint
range
readlist
reduce
rem
remove
repeat
repeatedly
reverse
screen-clear
screen-end
screen-get-key
screen-size
screen-start
screen-write
second
set!
shell
shuffle
sleep
some
sort
sort-by
source
split
swallow
syntax-quote
take
test
tosentence
true?
try
upcase
version
when
when-not
while
with-screen
zero?
Multiply 0 or more numbers
Type: native function
Arity: 0+
Args: (() . xs)
> (* 1 2 3)
;;=>
6
> (*)
;;=>
1
Exponentiation operator
Type: function
Arity: 2
Args: (n m)
> (** 1 0)
;;=>
1
> (** 2 4)
;;=>
16
> (** 10 10)
;;=>
10000000000
Add 0 or more numbers
Type: native function
Arity: 0+
Args: (() . xs)
> (+ 1 2 3)
;;=>
6
> (+)
;;=>
0
Subtract 0 or more numbers from the first argument
Type: native function
Arity: 1+
Args: (x . xs)
> (- 1 1)
;;=>
0
> (- 5 2 1)
;;=>
2
> (- 99)
;;=>
-99
Divide the first argument by the rest
Type: native function
Arity: 2+
Args: (numerator denominator1 . more)
> (/ 1 2)
;;=>
0
> (/ 12 2 3)
;;=>
2
> (/ 1 0)
;;=>
ERROR: ((builtin function /) (division by zero))
Return t if the arguments are in strictly increasing order, () otherwise
Type: native function
Arity: 1+
Args: (x . xs)
> (< 1 2)
;;=>
t
> (< 1 1)
;;=>
()
> (< 1)
;;=>
t
> (apply < (range 100))
;;=>
t
Return t if the arguments are in increasing or equal order, () otherwise
Type: native function
Arity: 1+
Args: (x . xs)
> (<= 1 2)
;;=>
t
> (<= 1 1)
;;=>
t
> (<= 1)
;;=>
t
Return t if the arguments are equal, () otherwise
Type: native function
Arity: 1+
Args: (x . xs)
> (= 1 1)
;;=>
t
> (= 1 2)
;;=>
()
> (apply = (repeat 10 t))
;;=>
t
Return t if the arguments are in strictly decreasing order, () otherwise
Type: native function
Arity: 1+
Args: (x . xs)
> (> 1 2)
;;=>
()
> (> 1 1)
;;=>
()
> (> 1)
;;=>
t
Return t if the arguments are in decreasing or equal order, () otherwise
Type: native function
Arity: 1+
Args: (x . xs)
> (>= 1 2)
;;=>
()
> (>= 1 1)
;;=>
t
Return absolute value of x
Type: function
Arity: 1
Args: (x)
> (abs 1)
;;=>
1
> (abs -100)
;;=>
100
Boolean and
Type: special form
Arity: 0+
Args: (() . xs)
(and)
;;=>
true
> (and t t)
;;=>
true
> (and t t ())
;;=>
()
> (and () (/ 1 0))
;;=>
()
Apply a function to a list of arguments
Type: native function
Arity: 2
Args: (f args)
> (apply + (repeat 10 1))
;;=>
10
> (apply * (cdr (range 10)))
;;=>
362880
Return t if the argument is an atom, () otherwise
Type: native function
Arity: 1
Args: (x)
> (atom? 1)
;;=>
()
> (atom? (quote one))
;;=>
t
Add an exclamation point at end of atom
Type: function
Arity: 1
Args: (a)
> (bang (quote Bang))
;;=>
Bang!
Return the body of a lambda function
Type: native function
Arity: 1
Args: (f)
> (body (lambda (x) (+ x 1)))
;;=>
((+ x 1))
Return everything but the last element
Type: function
Arity: 1
Args: (l)
> (butlast ())
;;=>
()
> (butlast (range 3))
;;=>
(0 1)
Return the atom argument, capitalized
Type: function
Arity: 1
Args: (a)
> (capitalize (quote hello))
;;=>
Hello
Return the first element of a list
Type: native function
Arity: 1
Args: (x)
> (car (quote (one two)))
;;=>
one
> (car ())
;;=>
()
Return a list with the first element removed
Type: native function
Arity: 1
Args: (x)
> (cdr (quote (one two)))
;;=>
(two)
> (cdr ())
;;=>
()
Add a colon at end of atom
Type: function
Arity: 1
Args: (a)
> (colon (quote remember-this))
;;=>
remember-this:
Add a comma at end of atom
Type: function
Arity: 1
Args: (a)
> (comma (quote hello))
;;=>
hello,
Ignore the expressions in the block
Type: macro
Arity: 0+
Args: (() . body)
> (comment twas brillig, and the slithy toves did gyre and gimble in the wabe)
;;=>
()
Function composition -- return a function which applies a series of functions in reverse order
Type: function
Arity: 0+
Args: (() . fs)
> ((comp) (quote hello))
;;=>
hello
> ((comp split) (quote hello))
;;=>
(h e l l o)
> ((comp len split) (quote hello))
;;=>
5
> ((comp (partial apply +) (partial map len) (partial map split)) (quote (hello world)))
;;=>
10
Return the logical complement of the supplied function
Type: function
Arity: 1
Args: (f)
> ((complement even?) 1)
;;=>
t
> (map (complement odd?) (range 5))
;;=>
(t () t () t)
Concatenenate any number of lists
Type: function
Arity: 0+
Args: (() . lists)
> (concat (range 3) (quote (wow)) (reverse (range 3)))
;;=>
(0 1 2 wow 2 1 0)
Concatenate two lists
Type: function
Arity: 2
Args: (a b)
> (concat2 () ())
;;=>
()
> (concat2 (quote (1 2)) (quote (3 4)))
;;=>
(1 2 3 4)
Fundamental branching construct
Type: special form
Arity: 0+
Args: (() . pairs)
> (cond)
;;=> ()
> (cond (t 1) (t 2) (t 3))
;;=> 1
> (cond (() 1) (t 2))
;;=> 2
Add an element to the front of a (possibly empty) list
Type: native function
Arity: 2
Args: (x xs)
> (cons 1 (quote (one two)))
;;=>
(1 one two)
> (cons 1 ())
;;=>
(1)
> (cons 1 2)
;;=>
(1 . 2)
Given a value, return a function which always returns that value
Type: function
Arity: 1
Args: (x)
> (map (constantly t) (range 10))
;;=>
(t t t t t t t t t t)
Return the supplied integer argument, minus one
Type: function
Arity: 1
Args: (n)
> (dec 2)
;;=>
1
> (dec -1)
;;=>
-2
Set a value
Type: special form
Arity: 2
Args: (name value)
> (def a 1)
;;=>
1
> a
;;=>
1
Create and name a macro
Type: special form
Arity: 2+
Args: (name args . body)
> (defmacro ignore-car (l)
(doc (ignore first element of list,
treat rest as normal expression)
(examples
(ignore-car (adorable + 1 2 3))
(ignore-car (deplorable - 4 4))))
(cdr l))
;;=>
()
> (ignore-car (hilarious * 2 3 4))
;;=>
24
Create and name a function
Type: special form
Arity: 2+
Args: (name args . body)
> (defn add (x y) (+ x y))
;;=>
()
> (add 1 2)
;;=>
3
> (defn add (x y)
(doc (add two numbers)
(examples
(add 1 2)))
(+ x y))
;;=>
()
> (doc add)
;;=>
((add two numbers) (examples (add 1 2)))
Return the doclist for a function
Type: native function
Arity: 1
Args: (x)
> (doc (lambda (x) (doc (does stuff) (and other stuff)) (+ x 1)))
;;=>
((does stuff) (and other stuff))
Execute body for each value in a list
Type: macro
Arity: 1+
Args: (n . body)
Return a new atom with all characters in lower case
Type: native function
Arity: 1
Args: (x)
> (downcase (quote Hello))
;;=>
hello
> (downcase (quote HELLO))
;;=>
hello
Drop n items from a list, then return the rest
Type: function
Arity: 2
Args: (n l)
> (drop 3 (range 10))
;;=>
(3 4 5 6 7 8 9)
Returning list of (i, x) pairs where i is the index (from zero) and x is the original element from l
Type: function
Arity: 1
Args: (l)
> (enumerate (quote (a b c)))
;;=>
((0 a) (1 b) (2 c))
Raise an error
Type: special form
Arity: 1
Args: (l)
> (defn ensure-list (x)
(when-not (list? x)
(error '(ensure-list argument not a list!))))
;;=>
()
> (ensure-list 3)
;;=>
ERROR in '(ensure-list 3)':
(ensure-list argument not a list!)
Error checking, for tests
Type: special form
Arity: 1+
Args: (expected . body)
> (errors '(is not a function)
(1))
;;=>
()
> (errors '(is not a function)
(+))
;;=>
ERROR in '(errors (quote (is not a function)) (+))':
error not found in ((quote (is not a function)) (+))
Evaluate an expression
Type: native function
Arity: 1
Args: (x)
> (eval (quote (one two)))
;;=>
ERROR: ((builtin function eval) (evaluating function object) (unknown symbol: one))
> (eval (quote (+ 1 2)))
;;=>
3
Return true if the supplied integer argument is even
Type: function
Arity: 1
Args: (n)
> (map even? (range 5))
;;=>
(t () t () t)
Return t if f applied to every element in l is truthy, else ()
Type: function
Arity: 2
Args: (f l)
> (every odd? (quote (1 3 5)))
;;=>
t
> (every odd? (quote (1 2 3 5)))
;;=>
()
Return l as a sentence... emphasized!
Type: function
Arity: 1
Args: (l)
> (exclaim (quote (well, hello)))
;;=>
(Well, hello!)
> (exclaim (quote (help)))
;;=>
(Help!)
> (exclaim (quote (begone, fiend)))
;;=>
(Begone, fiend!)
Exit the program
Type: native function
Arity: 0
Args: ()
Keep only values for which function f is true
Type: function
Arity: 2
Args: (f l)
> (filter odd? (range 5))
;;=>
(1 3)
Return a (possibly nested) list, flattened
Type: function
Arity: 1
Args: (l)
> (flatten (quote (this is a (really (nested) list))))
;;=>
(this is a really nested list)
Execute body for each value in a list
Type: macro
Arity: 2+
Args: (x xs . body)
Return available operators, as a list
Type: native function
Arity: 0
Args: ()
Fuse a list of numbers or atoms into a single atom
Type: native function
Arity: 1
Args: (x)
> (fuse (quote (A B C)))
;;=>
ABC
> (fuse (reverse (range 10)))
;;=>
9876543210
Return a new symbol
Type: native function
Arity: 0+
Args: (() . more)
Print a help message
Type: native function
Arity: 0
Args: ()
Return the argument
Type: function
Arity: 1
Args: (x)
Simple conditional with two branches
Type: macro
Arity: 3
Args: (condition then else)
> (if t 111 333)
;;=>
111
> (if () (quote abc) (quote def))
;;=>
def
Simple (inverted) conditional with two branches
Type: macro
Arity: 3
Args: (condition then else)
> (if-not (odd? 3) (quote (help, they broke three)) (quote (three is odd)))
;;=>
(three is odd)
Return the supplied integer argument, plus one
Type: function
Arity: 1
Args: (n)
Interpose x between all elements of l
Type: function
Arity: 2
Args: (x l)
> (interpose BANG (range 5))
;;=>
(0 ! 1 ! 2 ! 3 ! 4)
Assert a condition is truthy, or show failing code
Type: macro
Arity: 1
Args: (condition)
> (is t)
;;=>
()
> (is (car (cons () (quote (this one should fail)))))
;;=>
ERROR: ((assertion failed: (car (cons () (quote (this one should fail))))))
Integer square root
Type: native function
Arity: 1
Args: (x)
> (isqrt 4)
;;=>
2
> (isqrt 5)
;;=>
2
Create a function which combines multiple operations into a single list of results
Type: function
Arity: 0+
Args: (() . fs)
> ((juxt inc dec) 0)
;;=>
(1 -1)
> (map (juxt inc dec) (range 3))
;;=>
((1 -1) (2 0) (3 1))
> (map (juxt even? odd? zero?) (quote (-2 -1 0 1 2)))
;;=>
((t () ()) (() t ()) (t () t) (() t ()) (t () ()))
> (map (juxt) (range 3))
;;=>
(() () ())
Create a function
Type: special form
Arity: 1+
Args: (args . more)
> ((lambda () t))
;;=>
t
> ((lambda (x) (+ 5 x)) 5)
;;=>
10
> ((lambda my-length (x)
(if-not x
0
(+ 1 (my-length (cdr x)))))
(range 20))
;;=>
20
Return the last item in a list
Type: function
Arity: 1
Args: (l)
> (last (range 10))
;;=>
9
> (last (split (quote ATOM!)))
;;=>
!
Return the length of a list
Type: native function
Arity: 1
Args: (x)
> (len (range 10))
;;=>
10
Create a local scope with bindings
Type: special form
Arity: 1+
Args: (binding-pairs . body)
> (let ((a 1)
(b 2))
(+ a b))
;;=>
3
Let form with ability to refer to previously-bound pairs in the binding list
Type: macro
Arity: 1+
Args: (pairs . body)
> (let* ((a 1) (b (inc a))) (+ a b))
;;=>
3
Return a list of the given arguments
Type: native function
Arity: 0+
Args: (() . xs)
> (list 1 2 3)
;;=>
(1 2 3)
> (list)
;;=>
()
Create a list by consing everything but the last arg onto the last
Type: function
Arity: 0+
Args: (() . args)
> (list* 1 2 (quote (3)))
;;=>
(1 2 3)
> (list* 1 2 (quote (3 4)))
;;=>
(1 2 3 4)
> (list*)
;;=>
()
Return t if the argument is a list, () otherwise
Type: native function
Arity: 1
Args: (x)
> (list? (range 10))
;;=>
t
> (list? 1)
;;=>
()
Load and execute a file
Type: native function
Arity: 1
Args: (filename)
Loop forever
Type: special form
Arity: 1+
Args: ()
> (loop
(printl '(Help me, I am looping forever!))
(sleep 1000))
;; Prints =>
Help me, I am looping forever!
Help me, I am looping forever!
Help me, I am looping forever!
...
Expand a macro
Type: native function
Arity: 1
Args: (x)
> (macroexpand-1 (quote (+ x 1)))
;;=>
(+ x 1)
> (macroexpand-1 (quote (if () 1 2)))
;;=>
(cond (() 1) (t 2))
Apply the supplied function to every element in the supplied list
Type: function
Arity: 2
Args: (f l)
> (map odd? (range 5))
;;=>
(() t () t ())
> (map true? (quote (foo t () t 3)))
;;=>
(() t () t ())
Map a function onto a list and concatenate results
Type: function
Arity: 2
Args: (f l)
> (map list (range 5))
;;=>
((0) (1) (2) (3) (4))
> (mapcat list (range 5))
;;=>
(0 1 2 3 4)
> (map range (range 5))
;;=>
(() (0) (0 1) (0 1 2) (0 1 2 3))
> (mapcat range (range 5))
;;=>
(0 0 1 0 1 2 0 1 2 3)
Find maximum of one or more numbers
Type: function
Arity: 0+
Args: (() . args)
> (max -5)
;;=>
-5
> (max 2 3)
;;=>
3
> (apply max (range 10))
;;=>
9
Find minimum of one or more numbers
Type: function
Arity: 0+
Args: (() . args)
> (min -5)
;;=>
-5
> (min 2 3)
;;=>
2
> (apply min (range 10))
;;=>
0
Return true iff the supplied integer argument is less than zero
Type: function
Arity: 1
Args: (n)
> (map neg? (map (lambda (x) (- x 5)) (range 10)))
;;=>
(t t t t t () () () () ())
Return t if the argument is nil, () otherwise
Type: native function
Arity: 1
Args: (x)
> (not ())
;;=>
t
> (not t)
;;=>
()
> (not (range 10))
;;=>
()
Complement of = function
Type: function
Arity: 0+
Args: (() . terms)
> (not= 1 2)
;;=>
t
> (not= (quote a) (quote a))
;;=>
()
Find the nth value of a list, starting from zero
Type: function
Arity: 2
Args: (n l)
> (nth 3 (quote (one two three four five)))
;;=>
four
> (nth 1000 (range 2))
;;=>
()
Return true if the argument is a number, else ()
Type: native function
Arity: 1
Args: (x)
> (number? 1)
;;=>
t
> (number? t)
;;=>
()
> (number? +)
;;=>
()
Return true if the supplied integer argument is odd
Type: function
Arity: 1
Args: (n)
> (map even? (range 5))
;;=>
(t () t () t)
Boolean or
Type: special form
Arity: 0+
Args: (() . xs)
> (or)
;; => false
> (or t t)
;; => true
> (or t t ())
;; => t
Partial function application
Type: function
Arity: 1+
Args: (f . args)
> ((partial + 1) 1)
;;=>
2
> ((partial + 2 3) 4 5)
;;=>
14
Add a period at end of atom
Type: function
Arity: 1
Args: (a)
> (period (quote Woot))
;;=>
Woot.
Return true iff the supplied integer argument is greater than zero
Type: function
Arity: 1
Args: (n)
> (map pos? (map (lambda (x) (- x 5)) (range 10)))
;;=>
(() () () () () () t t t t)
Print the arguments
Type: native function
Arity: 0+
Args: (() . xs)
Print a list argument, without parentheses
Type: native function
Arity: 1
Args: (x)
Print the arguments and a newline
Type: native function
Arity: 0+
Args: (() . xs)
Execute multiple statements, returning the last
Type: macro
Arity: 0+
Args: (() . body)
> (progn)
;;=>
()
> (progn 1 2 3)
;;=>
3
Return x capitalized, with punctuation determined by the supplied function
Type: function
Arity: 2
Args: (f x)
Add a punctuation mark at end of atom
Type: function
Arity: 2
Args: (a mark)
> (punctuate-atom (quote list) (quote *))
;;=>
list*
> (punctuate-atom (quote list) COLON)
;;=>
list:
Quote an expression
Type: special form
Arity: 1
Args: (x)
> (quote foo)
foo
> (quote (1 2 3))
(1 2 3)
> '(1 2 3)
(1 2 3)
Return a list of random (English/Latin/unaccented) lower-case alphabetic characters
Type: function
Arity: 1
Args: (n)
Return an element at random from the supplied list
Type: function
Arity: 1
Args: (l)
Return a random integer between 0 and the argument minus 1
Type: function
Arity: 1
Args: (n)
Return a random integer between 0 and the argument minus 1
Type: native function
Arity: 1
Args: (x)
List of integers from 0 to n
Type: function
Arity: 1
Args: (n)
> (range 10)
;;=>
(0 1 2 3 4 5 6 7 8 9)
> (len (range 100))
;;=>
100
Read a list from stdin
Type: native function
Arity: 0
Args: ()
Successively apply a function against a list of arguments
Type: function
Arity: 2+
Args: (f x . args)
> (reduce * (cdr (range 10)))
;;=>
362880
> (reduce (lambda (acc x) (cons x acc)) () (range 10))
;;=>
(9 8 7 6 5 4 3 2 1 0)
Return remainder when second arg divides first
Type: native function
Arity: 2
Args: (x y)
> (rem 5 2)
;;=>
1
> (rem 4 2)
;;=>
0
> (rem 1 0)
;;=>
ERROR: ((builtin function rem) (division by zero))
Keep only values for which function f is false / the empty list
Type: function
Arity: 2
Args: (f l)
> (remove odd? (range 5))
;;=>
(0 2 4)
Return a list of length n whose elements are all x
Type: function
Arity: 2
Args: (n x)
> (repeat 5 (quote repetitive))
;;=>
(repetitive repetitive repetitive repetitive repetitive)
Return a list of length n whose elements are made from calling f repeatedly
Type: function
Arity: 2
Args: (n f)
> (repeatedly 3 (lambda () (range 5)))
;;=>
((0 1 2 3 4) (0 1 2 3 4) (0 1 2 3 4))
Reverse a list
Type: function
Arity: 1
Args: (l)
> (= (quote (c b a)) (reverse (quote (a b c))))
;;=>
t
Clear the screen
Type: native function
Arity: 0
Args: ()
Stop screen for text UIs, return to console mode
Type: native function
Arity: 0
Args: ()
Return a keystroke as an atom
Type: native function
Arity: 0
Args: ()
Return the screen size: width, height
Type: native function
Arity: 0
Args: ()
Start screen for text UIs
Type: native function
Arity: 0
Args: ()
Write a string to the screen
Type: native function
Arity: 3
Args: (x y list)
Return the second element of a list, or () if not enough elements
Type: function
Arity: 1
Args: (l)
> (second ())
;;=>
()
> (second (quote (a)))
;;=>
()
> (second (quote (a b)))
;;=>
b
> (second (quote (1 2 3)))
;;=>
2
Update a value in an existing binding
Type: special form
Arity: 2
Args: (name value)
> (def a 1)
;;=>
1
> a
;;=>
1
> (set! a 2)
;;=>
2
> a
;;=>
2
Run a shell subprocess, and return stdout, stderr, and exit code
Type: native function
Arity: 1
Args: (cmd)
Return a (quickly!) shuffled list
Type: native function
Arity: 1
Args: (xs)
Sleep for the given number of milliseconds
Type: native function
Arity: 1
Args: (ms)
Return f applied to first element for which that result is truthy, else ()
Type: function
Arity: 2
Args: (f l)
> (some even? (quote (1 3 5 7 9 11 13)))
;;=>
()
> (some even? (quote (1 3 5 7 9 1000 11 13)))
;;=>
t
Sort a list
Type: native function
Arity: 1
Args: (xs)
> (sort (quote (3 2 1)))
;;=>
(1 2 3)
> (sort (quote ()))
;;=>
()
> (sort (quote (c b a)))
;;=>
(a b c)
Sort a list by a function
Type: native function
Arity: 2
Args: (f xs)
> (sort-by first (quote ((3) (2) (1))))
;;=>
((1) (2) (3))
> (sort-by first (quote ()))
;;=>
()
> (sort-by second (quote ((quux 333) (zip 222) (afar 111))))
;;=>
((afar 111) (zip 222) (quux 333))
Show source for a function
Type: native function
Arity: 1
Args: (form)
> (source map)
;;=>
(lambda (f l) (when l (cons (f (car l)) (map f (cdr l)))))
> (source +)
;;=>
ERROR: ((builtin function source) (cannot get source of builtin function <builtin: +>))
Split an atom or number into a list of single-digit numbers or single-character atoms
Type: native function
Arity: 1
Args: (x)
> (split 123)
;;=>
(1 2 3)
> (split (quote abc))
;;=>
(a b c)
Swallow errors thrown in body, return t if any occur
Type: special form
Arity: 0+
Args: (() . body)
> (swallow
(error '(boom)))
;;=>
t
> (swallow 1 2 3)
;;=>
()
Syntax-quote an expression
Type: special form
Arity: 1
Args: (x)
> (syntax-quote foo)
foo
> (syntax-quote (1 2 3 4))
(1 2 3 4)
> (syntax-quote (1 (unquote (+ 1 1)) (splicing-unquote (list 3 4))))
(1 2 3 4)
> `(1 ~(+ 1 1) ~@(list 3 4))
(1 2 3 4)
Take up to n items from the supplied list
Type: function
Arity: 2
Args: (n l)
> (take 3 (range 10))
;;=>
(0 1 2)
Run tests
Type: special form
Arity: 0+
Args: (() . body)
Return l as a sentence... capitalized, with a period at the end
Type: function
Arity: 1
Args: (l)
> (tosentence (quote (to be, or not to be, that is the question)))
;;=>
(To be, or not to be, that is the question.)
Return t if the argument is t
Type: function
Arity: 1
Args: (x)
> (true? 3)
;;=>
()
> (true? t)
;;=>
t
Try to evaluate body, catch errors and handle them
Type: special form
Arity: 0+
Args: (() . body)
> (try (error '(boom)))
;;=>
ERROR:
((boom))
> (try
(error '(boom))
(catch e
(printl e)))
;;=>
(boom)
> (try (/ 1 0) (catch e (len e)))
2
>
Return the uppercase version of the given atom
Type: native function
Arity: 1
Args: (x)
> (upcase (quote abc))
;;=>
ABC
Return the version of the interpreter
Type: native function
Arity: 0
Args: ()
> (version)
;;=>
(0 0 56 dirty)
Simple conditional with single branch
Type: macro
Arity: 1+
Args: (condition . body)
> (when () (/ 1 0))
;;=>
()
> (when t (quote (the sun rises in the east)))
;;=>
(the sun rises in the east)
Complement of the when macro
Type: macro
Arity: 1+
Args: (condition . body)
> (when-not () (quote (do all the things)))
;;=>
(do all the things)
> (when-not t (error (quote (oh no mister bill))))
;;=>
()
Loop for as long as condition is true
Type: macro
Arity: 1+
Args: (condition . body)
> (while () (launch-missiles))
;;=>
()
Prepare for and clean up after screen operations
Type: macro
Arity: 0+
Args: (() . body)
Return true iff the supplied argument is zero
Type: function
Arity: 1
Args: (n)
> (zero? (quote zero))
;;=>
()
> (zero? (- 1 1))
;;=>
t