# Ludus prelude documentation
These functions are available in every Ludus script.
The documentation for any function can be found within Ludus by passing the function to `doc!`, 
e.g., running `doc! (add)` will send the documentation for `add` to the console.

## A few notes
**Naming conventions.** Functions whose name ends with a question mark, e.g., `eq?`, return booleans.
Functions whose name ends with an exclamation point, e.g., `make!`, change state in some way.
In other words, they _do things_ rather than _calculating values_. 
Functions whose name includes a slash either convert from one value to another, e.g. `deg/rad`,
or they are variations on a function, e.g. `div/0` as a variation on `div`.

**How entries are formatted.** Each entry has a brief (sometimes too brief!) description of what it does.
It is followed by the patterns for each of its function clauses.

[abs](#abs)    [add](#add)    [and](#and)    [angle](#angle)    [append](#append)    [assert!](#assert)    [assoc](#assoc)    [assoc?](#assoc)    [at](#at)    [atan/2](#atan/2)    [back!](#back)    [background!](#background)    [bg!](#bg)    [bgcolor](#bgcolor)    [bk!](#bk)    [bool](#bool)    [bool?](#bool)    [butlast](#butlast)    [ceil](#ceil)    [clear!](#clear)    [coll?](#coll)    [colors](#colors)    [concat](#concat)    [console](#console)    [cos](#cos)    [count](#count)    [dec](#dec)    [deg/rad](#deg/rad)    [deg/turn](#deg/turn)    [deref](#deref)    [dict](#dict)    [diff](#diff)    [dissoc](#dissoc)    [dist](#dist)    [div](#div)    [div/0](#div/0)    [div/safe](#div/safe)    [doc!](#doc)    [each!](#each)    [eq?](#eq)    [err](#err)    [err?](#err)    [even?](#even)    [false?](#false)    [fd!](#fd)    [first](#first)    [floor](#floor)    [flush!](#flush)    [fn?](#fn)    [fold](#fold)    [forward!](#forward)    [get](#get)    [goto!](#goto)    [gt?](#gt)    [gte?](#gte)    [heading](#heading)    [heading/vector](#heading/vector)    [home!](#home)    [inc](#inc)    [join](#join)    [keys](#keys)    [keyword?](#keyword)    [last](#last)    [left!](#left)    [list](#list)    [lt!](#lt)    [lt?](#lt)    [lte?](#lte)    [make!](#make)    [map](#map)    [mod](#mod)    [mult](#mult)    [neg](#neg)    [neg?](#neg)    [nil?](#nil)    [not](#not)    [odd?](#odd)    [ok](#ok)    [ok?](#ok)    [or](#or)    [ordered?](#ordered)    [p5_calls](#p5_calls)    [panic!](#panic)    [pc!](#pc)    [pd!](#pd)    [pencolor](#pencolor)    [pencolor!](#pencolor)    [pendown!](#pendown)    [pendown?](#pendown)    [penup!](#penup)    [penwidth](#penwidth)    [penwidth!](#penwidth)    [pi](#pi)    [pos?](#pos)    [position](#position)    [print!](#print)    [prn!](#prn)    [pu!](#pu)    [pw!](#pw)    [rad/deg](#rad/deg)    [rad/turn](#rad/turn)    [random](#random)    [range](#range)    [render_turtle!](#render_turtle)    [report!](#report)    [reset_turtle!](#reset_turtle)    [rest](#rest)    [right!](#right)    [round](#round)    [rt!](#rt)    [second](#second)    [set](#set)    [show](#show)    [sin](#sin)    [slice](#slice)    [some](#some)    [some?](#some)    [square](#square)    [string](#string)    [string?](#string)    [sub](#sub)    [sum_of_squares](#sum_of_squares)    [tan](#tan)    [tau](#tau)    [turn/deg](#turn/deg)    [turn/rad](#turn/rad)    [turtle_commands](#turtle_commands)    [turtle_state](#turtle_state)    [turtle_states](#turtle_states)    [type](#type)    [unwrap!](#unwrap)    [unwrap_or](#unwrap_or)    [update](#update)    [update!](#update)    [values](#values)    [zero?](#zero)
## Function documentation
### abs
Returns the absolute value of a number.
```
(0)
(n)
```

### add
Adds numbers or vectors.
```
()
(x as :number)
(x as :number, y as :number)
(x, y, ...zs)
((x1, y1), (x2, y2))
```

### and
Returns true if all values passed in are truthy.
```
()
(x)
(x, y)
(x, y, ...zs)
```

### angle
Calculates the angle between two vectors.
```
(v1, v2)
```

### append
Adds an element to a list or set.
```
()
(xs as :list)
(xs as :list, x)
(xs as :set)
(xs as :set, x)
```

### assert!
Asserts a condition: returns the value if the value is truthy, panics if the value is falsy. Takes an optional message.
```
(value)
(value, message)
```

### assoc
Takes a dict, key, and value, and returns a new dict with the key set to value.
```
()
(dict as :dict)
(dict as :dict, key as :keyword, value)
(dict as :dict, (key as :keyword, value))
```

### assoc?
Returns true if a value is an associative collection: a dict, struct, or namespace.
```
(assoc as :dict)
(assoc as :struct)
(assoc as :ns)
(_)
```

### at
Returns the element at index n of a list or tuple. Zero-indexed: the first element is at index 0.
```
(xs as :list, n as :number)
(xs as :tuple, n as :number)
```

### atan/2
Returns an angle from a slope. Takes an optional keyword argument to specify units. Takes either two numbers or a vector tuple.
```
(x as :number, y as :number)
(x, y, :turns)
(x, y, :radians)
(x, y, :degrees)
((x, y))
((x, y), units as :keyword)
```

### back!
Moves the turtle backward by a number of steps. Alias: bk!
```
(steps as :number)
```

### background!
Sets the background color behind the turtle and path. Alias: bg!
```
(gray as :number)
((r as :number, g as :number, b as :number))
((r as :number, g as :number, b as :number, a as :number))
```

### bg!
Sets the background color behind the turtle and path. Alias: bg!
```
(gray as :number)
((r as :number, g as :number, b as :number))
((r as :number, g as :number, b as :number, a as :number))
```

### bgcolor
No documentation available.


### bk!
Moves the turtle backward by a number of steps. Alias: bk!
```
(steps as :number)
```

### bool
Returns false if a value is nil or false, otherwise returns true.
```
(nil)
(false)
(_)
```

### bool?
Returns true if a value is of type :boolean.
```
(false)
(true)
(_)
```

### butlast
Returns a list, omitting the last element.
```
(xs as :list)
```

### ceil
Truncates a number towards positive infinity. With negative numbers, it returns the integer part. With positive numbers, returns the next more-positive integer.
```
(n as :number)
```

### clear!
Clears the canvas and sends the turtle home.
```
()
```

### coll?
Returns true if a value is a collection: dict, struct, list, tuple, or set.
```
(coll as :dict)
(coll as :struct)
(coll as :list)
(coll as :tuple)
(coll as :set)
(coll as :ns)
(_)
```

### colors
No documentation available.


### concat
Combines two lists, strings, or sets.
```
(x as :string, y as :string)
(xs as :list, ys as :list)
(xs as :set, ys as :set)
(xs, ys, ...zs)
```

### console
No documentation available.


### cos
Returns the cosine of an angle. Default angle measure is turns. An optional keyword argument specifies the units of the angle passed in.
```
(a as :number)
(a as :number, :turns)
(a as :number, :degrees)
(a as :number, :radians)
```

### count
Returns the number of elements in a collection (including string).
```
(xs as :list)
(xs as :tuple)
(xs as :dict)
(xs as :string)
(xs as :set)
(xs as :struct)
```

### dec
Decrements a number.
```
(x as :number)
```

### deg/rad
Converts an angle in degrees to an angle in radians.
```
(a as :number)
```

### deg/turn
Converts an angle in degrees to an angle in turns.
```
(a as :number)
```

### deref
Resolves a ref into a value.
```
(r as :ref)
```

### dict
Takes a struct or ns, and returns it as a dict. Or, takes a list or tuple of (key, value) tuples and returns it as a dict. Returns dicts unharmed.
```
(struct as :struct)
(ns_ as :ns)
(dict as :dict)
(list as :list)
(tup as :tuple)
```

### diff
Takes two associate data structures and returns a dict describing their differences. Does this shallowly, offering diffs only for keys in the original dict.
```
(d1 as :dict, d2 as :dict)
```

### dissoc
Takes a dict and a key, and returns a new dict with the key and associated value omitted.
```
(dict as :dict)
(dict as :dict, key as :keyword)
```

### dist
Returns the distance from the origin to a point described by (x, y).
```
(x as :number, y as :number)
((x, y))
```

### div
Divides numbers. Panics on division by zero.
```
(x as :number)
(_, 0)
(x as :number, y as :number)
(x, y, ...zs)
```

### div/0
Divides numbers. Returns 0 on division by zero.
```
(x as :number)
(_, 0)
(x as :number, y as :number)
(x, y, ...zs)
```

### div/safe
Divides a number. Returns a result tuple.
```
(x as :number)
(_, 0)
(x, y)
(x, y, ...zs)
```

### doc!
Prints the documentation of a function to the console.
```
(f as :fn)
(_)
```

### each!
Takes a list and applies a function, presumably with side effects, to each element in the list. Returns nil.
```
(f! as :fn, [])
(f! as :fn, [x])
(f! as :fn, [...xs])
```

### eq?
Returns true if all arguments have the same value.
```
(x)
(x, y)
(x, y, ...zs)
```

### err
Takes a value and wraps it in an :err result tuple, presumably as an error message.
```
(msg)
```

### err?
Takes a value and returns true if it is an :err result tuple.
```
((:err, _))
(_)
```

### even?
Returns true if a value is an even number, otherwise returns false.
```
(x as :number)
(_)
```

### false?
Returns true if a value is false, otherwise returns false. Useful to distinguish between false and nil.
```
(false)
(_)
```

### fd!
Moves the turtle forward by a number of steps. Alias: fd!
```
(steps as :number)
```

### first
Returns the first element of a list or tuple.
```
(xs)
```

### floor
Truncates a number towards negative infinity. With positive numbers, it returns the integer part. With negative numbers, returns the next more-negative integer.
```
(n as :number)
```

### flush!
Clears the console, and returns the messages.
```
()
```

### fn?
Returns true if an argument is a function.
```
(f as :fn)
(_)
```

### fold
Folds a list.
```
(f as :fn, xs as :list)
(f as :fn, xs as :list, root)
```

### forward!
Moves the turtle forward by a number of steps. Alias: fd!
```
(steps as :number)
```

### get
Takes a dict or struct, key, and optional default value; returns the value at key. If the value is not found, returns nil or the default value. Returns nil or default if the first argument is not a dict or struct.
```
(key as :keyword)
(key as :keyword, coll)
(key as :keyword, coll, default)
```

### goto!
Sends the turtle to (x, y) coordinates. If the pen is down, the turtle will draw a path to its new location.
```
(x as :number, y as :number)
((x, y))
```

### gt?
Returns true if numbers are in decreasing order.
```
(x as :number)
(x as :number, y as :number)
(x, y, ...zs)
```

### gte?
Returns true if numbers are in decreasing or flat order.
```
(x as :number)
(x as :number, y as :number)
(x, y, ...zs)
```

### heading
Returns the turtle's current heading.
```
()
```

### heading/vector
Takes a turtle heading, and returns a unit vector of that heading.
```
(heading)
```

### home!
Sends the turtle home: to the centre of the screen, pointing up. If the pen is down, the turtle will draw a path to home.
```
()
```

### inc
Increments a number.
```
(x as :number)
```

### join
Takes a list of strings, and joins them into a single string, interposing an optional separator.
```
([])
([str as :string])
(strs as :list)
([str, ...strs], separator as :string)
```

### keys
Takes an associative collection and returns a list of keys in that collection. Returns an empty list on anything other than a collection.
```
(coll)
```

### keyword?
Returns true if a value is a keyword, otherwise returns false.
```
(kw as :keyword)
(_)
```

### last
Returns the last element of a list or tuple.
```
(xs)
```

### left!
Rotates the turtle left, measured in turns. Alias: lt!
```
(turns as :number)
```

### list
Takes a value and returns it as a list. For values, it simply wraps them in a list. For collections, conversions are as follows. A tuple->list conversion preservers order and length. Unordered collections do not preserve order. Associative collections return lists of (key, value) tuples.
```
(x)
```

### lt!
Rotates the turtle left, measured in turns. Alias: lt!
```
(turns as :number)
```

### lt?
Returns true if numbers are in increasing order.
```
(x as :number)
(x as :number, y as :number)
(x, y, ...zs)
```

### lte?
Returns true if numbers are in increasing or flat order.
```
(x as :number)
(x as :number, y as :number)
(x, y, ...zs)
```

### make!
Sets the value of a ref.
```
(r as :ref, value)
```

### map
Maps over a list.
```
(f as :fn, xs)
(kw as :keyword, xs)
```

### mod
Returns the modulus of num and div. Truncates towards negative infinity.
```
(num as :number, y as :number)
```

### mult
Multiplies numbers or vectors.
```
()
(x as :number)
(x as :number, y as :number)
(x, y, ...zs)
(scalar as :number, (x, y))
((x, y), scalar as :number)
```

### neg
Multiplies a number by -1, negating it.
```
(n as :number)
```

### neg?
Returns true if a value is a negative number, otherwise returns false.
```
(x as :number)
(_)
```

### nil?
Returns true if a value is nil.
```
(nil)
(_)
```

### not
Returns false if a value is truthy, true if a value is falsy.
```
(nil)
(false)
(_)
```

### odd?
Returns true if a value is an odd number, otherwise returns false.
```
(x as :number)
(_)
```

### ok
Takes a value and wraps it in an :ok result tuple.
```
(value)
```

### ok?
Takes a value and returns true if it is an :ok result tuple.
```
((:ok, _))
(_)
```

### or
Returns true if any value passed in is truthy.
```
()
(x)
(x, y)
(x, y, ...zs)
```

### ordered?
Returns true if a value is an indexed collection: list or tuple.
```
(coll as :list)
(coll as :tuple)
(_)
```

### p5_calls
No documentation available.


### panic!
Causes Ludus to panic, outputting any arguments as messages.
```
()
(...args)
```

### pc!
Changes the turtle's pen color. Takes a single grayscale value, an rgb tuple, or an rgba tuple. Alias: pc!
```
(gray as :number)
((r as :number, g as :number, b as :number))
((r as :number, g as :number, b as :number, a as :number))
```

### pd!
Lowers the turtle's pen, causing it to draw. Alias: pd!
```
()
```

### pencolor
Returns the turtle's pen color as an (r, g, b, a) tuple.
```
()
```

### pencolor!
Changes the turtle's pen color. Takes a single grayscale value, an rgb tuple, or an rgba tuple. Alias: pc!
```
(gray as :number)
((r as :number, g as :number, b as :number))
((r as :number, g as :number, b as :number, a as :number))
```

### pendown!
Lowers the turtle's pen, causing it to draw. Alias: pd!
```
()
```

### pendown?
Returns the turtle's pen state: true if the pen is down.
```
()
```

### penup!
Lifts the turtle's pen, stopping it from drawing. Alias: pu!
```
()
```

### penwidth
Returns the turtle's pen width in pixels.
```
()
```

### penwidth!
Sets the width of the turtle's pen, measured in pixels. Alias: pw!
```
(width as :number)
```

### pi
No documentation available.


### pos?
Returns true if a value is a positive number, otherwise returns false.
```
(x as :number)
(_)
```

### position
Returns the turtle's current position.
```
()
```

### print!
Sends a text representation of Ludus values to the console.
```
(...args)
```

### prn!
Prints the underlying Clojure data structure of a Ludus value.
```
(x)
```

### pu!
Lifts the turtle's pen, stopping it from drawing. Alias: pu!
```
()
```

### pw!
Sets the width of the turtle's pen, measured in pixels. Alias: pw!
```
(width as :number)
```

### rad/deg
Converts an angle in radians to an angle in degrees.
```
(a as :number)
```

### rad/turn
Converts an angle in radians to an angle in turns.
```
(a as :number)
```

### random
Returns a random number. With zero arguments, returns a random number between 0 (inclusive) and 1 (exclusive). With one argument, returns a random number between 0 and n. With two arguments, returns a random number between m and n.
```
()
(n as :number)
(m as :number, n as :number)
```

### range
Returns the set of integers between start (inclusive) and end (exclusive) as a list. With one argument, starts at 0. If end is less than start, returns an empty list.
```
(end as :number)
(start as :number, end as :number)
```

### render_turtle!

```
()
```

### report!
Prints a value, then returns it.
```
(x)
(msg as :string, x)
```

### reset_turtle!
Resets the turtle to its original state.
```
()
```

### rest
Returns all but the first element of a list or tuple, as a list.
```
(xs as :list)
(xs as :tuple)
```

### right!
Rotates the turtle right, measured in turns. Alias: rt!
```
(turns as :number)
```

### round
Rounds a number to the nearest integer.
```
(n as :number)
```

### rt!
Rotates the turtle right, measured in turns. Alias: rt!
```
(turns as :number)
```

### second
Returns the second element of a list or tuple.
```
(xs)
```

### set
Takes an ordered collection--list or tuple--and turns it into a set.
```
(xs as :list)
(xs as :tuple)
```

### show
Returns a text representation of a Ludus value as a string.
```
(x)
```

### sin
Returns the sine of an angle. Default angle measure is turns. An optional keyword argument specifies the units of the angle passed in.
```
(a as :number)
(a as :number, :turns)
(a as :number, :degrees)
(a as :number, :radians)
```

### slice
Returns a slice of a list, representing a sub-list.
```
(xs as :list, end as :number)
(xs as :list, start as :number, end as :number)
```

### some
Takes a possibly nil value and a default value. Returns the value if it's not nil, returns the default if it's nil.
```
(nil, default)
(value, _)
```

### some?
Returns true if a value is not nil.
```
(nil)
(_)
```

### square
Squares a number.
```
(x as :number)
```

### string
Converts a value to a string by using `show`. If it is a string, returns it unharmed. Use this to build up strings of differen kinds of values.
```
(x as :string)
(x)
(x, ...xs)
```

### string?
Returns true if a value is a string.
```
(x as :string)
(_)
```

### sub
Subtracts numbers or vectors.
```
()
(x as :number)
(x as :number, y as :number)
(x, y, ...zs)
((x1, y1), (x2, y2))
```

### sum_of_squares
Returns the sum of squares of numbers.
```
()
(x as :number)
(x as :number, y as :number)
(x, y, ...zs)
```

### tan
Returns the sine of an angle. Default angle measure is turns. An optional keyword argument specifies the units of the angle passed in.
```
(a as :number)
(a as :number, :turns)
(a as :number, :degrees)
(a as :number, :radians)
```

### tau
No documentation available.


### turn/deg
Converts an angle in turns to an angle in degrees.
```
(a as :number)
```

### turn/rad
Converts an angle in turns to an angle in radians.
```
(a as :number)
```

### turtle_commands
No documentation available.


### turtle_state
Returns the turtle's current state.
```
()
```

### turtle_states
No documentation available.


### type
Returns a keyword representing the type of the value passed in.
```
(x)
```

### unwrap!
Takes a result tuple. If it's :ok, then returns the value. If it's not :ok, then it panics. If it's not a result tuple, it also panics.
```
((:ok, value))
((:err, msg))
(_)
```

### unwrap_or
Takes a value that is a result tuple and a default value. If it's :ok, then it returns the value. If it's :err, returns the default value.
```
((:ok, value), _)
((:err, _), default)
```

### update
Takes a dict, key, and function, and returns a new dict with the key set to the result of applying the function to original value held at the key.
```
(dict as :dict)
(dict as :dict, key as :keyword, updater as :fn)
```

### update!
Updates a ref by applying a function to its value. Returns the new value.
```
(r as :ref, f as :fn)
```

### values
Takes an associative collection and returns a list of values in that collection. Returns an empty list on anything other than a collection.
```
(coll)
```

### zero?
Returns true if a number is 0.
```
(0)
(_)
```