# Symbol index

Symbol | Defined in | |
---|---|---|

$ |
||

`$` : Perform interpolation (variable substitution) on the string `STR` . |
core/string | |

`$complex` |
math/complex | |

`$continuation` |
control/prompt | |

`$graph` |
data/graph | |

`$matrix` |
math/matrix | |

`$rational` |
math/rational | |

`$set` |
data/set | |

`$vector` |
math/vector | |

`$vertex` |
data/graph | |

`*` |
lua/basic | |

`*standard-error*` : The standard error stream. |
core/prelude | |

`*standard-input*` : The standard input stream. |
core/prelude | |

`*standard-output*` : The standard output stream. |
core/prelude | |

`+` |
lua/basic | |

`-` |
lua/basic | |

`->` : Chain a series of method calls together. |
data/function | |

`->float` : Convert the rational number `Y` to a floating-point number. |
math/rational | |

`->polar` : Get the `magnitude` and `angle` of complex number `Z` . |
math/complex | |

`->rat` : Convert the floating-point number `Y` to a rational number. |
math/rational | |

`-and` : Return the logical conjunction of values `A` and `B` . |
core/base | |

`-or` : Return the logical disjunction of values `A` and `B` . |
core/base | |

`..` |
lua/basic | |

`.<!` : Set the value at `KEYS` in the structure `X` to `VALUE` . |
core/table | |

`.>` : Index the structure `X` with the sequence of accesses given by `KEYS` . |
core/table | |

`/` |
lua/basic | |

`/=` |
lua/basic | |

`/=` : Check whether `A` is not equal to `B` , `B` is not equal to the first element in `REST` , etc. |
control/comparison | |

`<` : Check whether `A` is smaller than `B` , `B` is smaller than the first element in `REST` , and so on for all subsequent arguments. |
control/comparison | |

`<` |
lua/basic | |

`<=` : Check whether `A` is smaller or equal to `B` , `B` is smaller or equal to the first element in `REST` , and so on for all subsequent arguments. |
control/comparison | |

`<=` |
lua/basic | |

`<=>` : Bidirectional implication. |
core/base | |

`<>` : Compose, left-associatively, the list of lenses given by `LENSES` . |
data/lens | |

`=` : Check whether `A` , `B` and all items in `REST` are equal. |
control/comparison | |

`=` |
lua/basic | |

`=:=` : Express that the functions `F` and `G` are equivalent at the point `X` . |
test/check | |

`=>` : Logical implication. |
core/base | |

`>` |
lua/basic | |

`>` : Check whether `A` is larger than `B` , `B` is larger than the first element in `REST` , and so on for all subsequent arguments. |
control/comparison | |

`>=` : Check whether `A` is larger or equal to `B` , `B` is larger or equal to the first element in `REST` , and so on for all subsequent arguments. |
control/comparison | |

`>=` |
lua/basic | |

`\\` : The difference between `XS` and `YS` (non-associative. |
core/list | |

`^.` : Use `LENS` to focus on a bit of `VAL` . |
data/lens | |

`^=` : Use `LENS` to replace a bit of `VAL` with `NEW` . |
data/lens | |

`^~` : Use `LENS` to apply the function `F` over a bit of `VAL` . |
data/lens | |

`_ENV` |
lua/basic | |

`_G` |
lua/basic | |

a |
||

`abi` |
luajit/ffi | |

`abort-to-prompt` : Abort to the prompt `TAG` , giving `REST` as arguments to the handler. |
control/prompt | |

`abort/p` : Abort to the prompt `TAG` , giving `REST` as arguments to the handler. |
control/prompt | |

`abs` |
lua/math | |

`absolute` : Returns `A` if `A` is positive, otherwise inverts the sign and returns the positive version of `A` . |
math/bignum | |

`accumulate-with` : `A` composition of `reduce` and `map` . |
core/list | |

`accumulating` : Transform the lens `L` into a getter which folds the result using the function `F` and the zero element `Z` . |
data/lens | |

`acos` |
lua/math | |

`active-module` : Get the module of the node currently being resolved. |
compiler/resolve | |

`active-node` : Get the node currently being resolved. |
compiler/resolve | |

`active-scope` : Get the scope of the node currently being resolved. |
compiler/resolve | |

`add` : Returns `A` plus `B` . |
math/bignum | |

`add-action` : Append `VALUE` to the appropriate key in `DATA` for `ARG` . |
io/argparse | |

`add-argument!` : Add a new argument to `SPEC` , using the specified `NAMES` . |
io/argparse | |

`add-category!` : Add a new category with the given `ID` , display `NAME` and an optional `DESCRIPTION` . |
io/argparse | |

`add-edge!` : Add an edge `FROM` one vertex `TO` another. |
data/graph | |

`add-help!` : Add a help argument to `SPEC` . |
io/argparse | |

`add-pass!` : Register a `PASS` created with `defpass` . |
compiler/pass | |

`add-vertex!` : Create a vertex with the corresponding `VALUE` and add it to the `GRAPH` . |
data/graph | |

`affirm` : Assert each expression in `ASSERTS` evaluates to true |
test/assert | |

`alignof` |
luajit/ffi | |

`alive?` : Check that the continuation `K` may be executed further. |
control/prompt | |

`all` : Test if all elements of `XS` match the predicate `P` . |
core/list | |

`and` : Return the logical and of values `A` and `B` , and, if present, the logical and of all the values in `REST` . |
core/base | |

`angle` : Get the angle of complex number `Z` . |
math/complex | |

`angle` : Compute the angle between vectors `X` and `Y` . |
math/vector | |

`any` : Check for the existence of an element in `XS` that matches the predicate `P` . |
core/list | |

`append` : Concatenate `XS` and `YS` . |
core/list | |

`append-all!` : Appends the string `DATA` to the file at `PATH` . |
io | |

`append-bytes!` : Appends the bytes (list of numbers) `DATA` to the file at `PATH` . |
io | |

`append-lines!` : Appends the lines (list of strings) `DATA` to the file at `PATH` . |
io | |

`apply` : Apply the function `F` using `XS` as the argument list, with `XSS` as arguments before `XS` is spliced. |
core/base | |

`arch` |
luajit/ffi | |

`arg` : The arguments passed to the currently executing program |
core/base | |

`arg#` |
lua/basic | |

`as-is` : Return the value `X` unchanged. |
data/function | |

`ashr` : Returns the arithmetic right shift of `X` shifted right by `DISP` . |
lua/bit32 | |

`asin` |
lua/math | |

`assert` |
lua/basic | |

`assert!` : Assert `CND` is true, otherwise failing with `MSG` |
test/assert | |

`assert-type!` : Assert that the argument `ARG` has type `TY` , as reported by the function `type` . |
core/type | |

`assoc` : Return the value given by `KEY` in the association list `LIST` , or, in the case that it does not exist, the value `OR-VAL` , which can be nil. |
data/alist | |

`assoc->struct` : Convert the association list `LIST` into a structure. |
data/alist | |

`assoc?` : Check that `KEY` is bound in the association list `LIST` . |
data/alist | |

`at` : `A` lens that focuses on the K-th element of a list. |
data/lens | |

`atan` |
lua/math | |

`atan2` |
lua/math | |

`atom?` : Check whether `X` is an atomic object, that is, one of - `A` boolean - `A` string - `A` number - `A` symbol - `A` key - `A` function |
core/type | |

b |
||

`between?` : Check if the numerical value `X` is between `MIN` and `MAX` . |
core/type | |

`bit-and` : Returns the bitwise `AND` of its arguments. |
lua/bit32 | |

`bit-at` : Returns the value of the bit (0 or 1) of `A` at position `BIT` . |
math/bignum | |

`bit-extract` : Returns the unsigned number formed by splicing the bits `FIELD` to `FIELD` + `WIDTH` - 1 from `X` . |
lua/bit32 | |

`bit-not` : Returns the bitwise `NOT` of `X` . |
lua/bit32 | |

`bit-or` : Returns the bitwise `OR` of its arguments. |
lua/bit32 | |

`bit-replace` : Returns `X` with the bits `FIELD` to `FIELD` + `WIDTH` - 1 replaced with the unsigned number value of `V` . |
lua/bit32 | |

`bit-rotl` : Returns `X` rotated left by `DISP` . |
lua/bit32 | |

`bit-rotr` : Returns `X` rotated right by `DISP` . |
lua/bit32 | |

`bit-test` : Returns true if the bitwise `AND` of its arguments is not 0. |
lua/bit32 | |

`bit-xor` : Returns the bitwise `XOR` of its arguments. |
lua/bit32 | |

`block` : Estabilish an escape continuation called `break` and evaluate `BODY` . |
control/prompt | |

`bool->string` : Convert the boolean `X` into a string. |
core/prelude | |

`boolean?` : Check whether `X` is a boolean. |
core/type | |

`builtin` : Get the builtin with the given `NAME` . |
compiler/nodes | |

`builtin?` : Determine whether the specified `NODE` is the given `BUILTIN` . |
compiler/nodes | |

`byte` |
lua/string | |

c |
||

`C` |
luajit/ffi | |

`caaaar` |
core/list | |

`caaaars` |
core/list | |

`caaadr` |
core/list | |

`caaadrs` |
core/list | |

`caaar` |
core/list | |

`caaars` |
core/list | |

`caadar` |
core/list | |

`caadars` |
core/list | |

`caaddr` |
core/list | |

`caaddrs` |
core/list | |

`caadr` |
core/list | |

`caadrs` |
core/list | |

`caar` |
core/list | |

`caars` |
core/list | |

`cadaar` |
core/list | |

`cadaars` |
core/list | |

`cadadr` |
core/list | |

`cadadrs` |
core/list | |

`cadar` |
core/list | |

`cadars` |
core/list | |

`caddar` |
core/list | |

`caddars` |
core/list | |

`cadddr` |
core/list | |

`cadddrs` |
core/list | |

`caddr` |
core/list | |

`caddrs` |
core/list | |

`cadr` |
core/list | |

`cadrs` |
core/list | |

`call` : Index `X` with `KEY` and invoke the resulting function with `ARGS` . |
data/function | |

`call-with-escape-continuation` : Invoke the thunk `BODY` with an escape continuation. |
control/prompt | |

`call-with-prompt` : Call the thunk `BODY` with a prompt `PROMPT-TAG` in scope. |
control/prompt | |

`call/ec` |
control/prompt | |

`call/p` |
control/prompt | |

`can` : Create a test whose `BODY` asserts `NAME` can happen |
test | |

`cannot` : Create a test whose `BODY` asserts `NAME` cannot happen |
test | |

`car` : Return the first element present in the list `X` . |
core/list | |

`car` |
core/base | |

`cars` |
core/list | |

`case` : Match a single value against a series of patterns, evaluating the first body that matches, much like `cond` . |
core/match | |

`cast` |
luajit/ffi | |

`cdaaar` |
core/list | |

`cdaaars` |
core/list | |

`cdaadr` |
core/list | |

`cdaadrs` |
core/list | |

`cdaar` |
core/list | |

`cdaars` |
core/list | |

`cdadar` |
core/list | |

`cdadars` |
core/list | |

`cdaddr` |
core/list | |

`cdaddrs` |
core/list | |

`cdadr` |
core/list | |

`cdadrs` |
core/list | |

`cdar` |
core/list | |

`cdars` |
core/list | |

`cddaar` |
core/list | |

`cddaars` |
core/list | |

`cddadr` |
core/list | |

`cddadrs` |
core/list | |

`cddar` |
core/list | |

`cddars` |
core/list | |

`cdddar` |
core/list | |

`cdddars` |
core/list | |

`cddddr` |
core/list | |

`cddddrs` |
core/list | |

`cdddr` |
core/list | |

`cdddrs` |
core/list | |

`cddr` |
core/list | |

`cddrs` |
core/list | |

`cdef` |
luajit/ffi | |

`cdr` : Return the list `X` without the first element present. |
core/list | |

`cdr` |
core/base | |

`cdrs` |
core/list | |

`ceil` |
lua/math | |

`changed!` : Mark this pass as having a side effect. |
compiler/pass | |

`char` |
lua/utf8 | |

`char` |
lua/string | |

`char-at` : Index the string `XS` , returning the character at position `X` . |
core/string | |

`charpattern` |
lua/utf8 | |

`check` : Check a set of properties against a set of random variables 100 times. |
test/check | |

`clock` |
lua/os | |

`close` |
lua/io | |

`codepoint` |
lua/utf8 | |

`codes` |
lua/utf8 | |

`collectgarbage` |
lua/basic | |

`coloured` : Color a string `MSG` using `COL` if supported under the current terminal |
io/term | |

`coloured?` : Constant defining whether the current terminal has colour support |
io/term | |

`comp` : Return the pointwise composition of all functions in `FS` . |
data/function | |

`complex` : Represents a complex number, formed of a `real` and `imaginary` part. |
math/complex | |

`complex?` |
math/complex | |

`compose` : Return the pointwise composition of functions `F` and `G` . |
data/function | |

`concat` |
lua/table | |

`condensation` : Compute the condensation of an input graph, `IN-GRAPH` , replacing all strongly connected components with a super vertex. |
data/graph | |

`config` |
lua/package | |

`conjugate` : Get the complex conjugate of `Z` . |
math/complex | |

`cons` : Add `X` to the start of the list `XS` . |
core/base | |

`cons` : Return a copy of the list `XSS` with the elements `XS` added to its head. |
core/list | |

`const` : Return a function which always returns `X` . |
data/function | |

`const-val` : Get the actual value of `VAL` , an argument to a macro. |
core/base | |

`constant?` : Determine whether the specified `NODE` is a constant. |
compiler/nodes | |

`continuation?` |
control/prompt | |

`copy` |
luajit/ffi | |

`copy` : Returns a deep copied clone of `A` . |
math/bignum | |

`copy-of` : Create a shallow copy of `STRUCT` . |
core/table | |

`cos` |
lua/math | |

`cpath` |
lua/package | |

`create` : Create a new argument parser |
io/argparse | |

`create` |
lua/coroutine | |

`create-lookup` : Convert `VALUES` into a lookup table, with each value being converted to a key whose corresponding value is the value’s index. |
core/table | |

`cross` : Compute the vector cross product of `X` and `Y` . |
math/vector | |

`cut` : Partially apply a function `FUNC` , where each `<>` is replaced by an argument to a function. |
data/function | |

`cute` : Partially apply a function `FUNC` , where each `<>` is replaced by an argument to a function. |
data/function | |

d |
||

`date` |
lua/os | |

`debug` |
lua/debug | |

`debug` : Print the value `X` , then return it unmodified. |
core/type | |

`dec!` : Decrements the symbol `X` by 1. |
math | |

`defalias` : Alias the method at `NAME` to the method at `OTHER` . |
core/type | |

`defdefault` : Add a default case to the generic method `NAME` with the arguments `LL` and the body `BODY` . |
core/type | |

`defgeneric` : Define a generic method called `NAME` with the arguments given in `LL` , and the attributes given in `ATTRS` . |
core/type | |

`defmacro` : Define `NAME` to be the macro given by (lambda `ARGS` @`BODY` ), with optional metadata at the start of `BODY` . |
core/base | |

`defmethod` : Add a case to the generic method `NAME` with the arguments `LL` and the body `BODY` . |
core/type | |

`defpass` : Define a pass with the given `NAME` and `BODY` taking the specified `ARGS` . |
compiler/pass | |

`defstruct` : Define a struct called `NAME` . |
data/struct | |

`defun` : Define `NAME` to be the function given by (lambda `ARGS` @`BODY` ), with optional metadata at the start of `BODY` . |
core/base | |

`defun-ffi` : Define the external symbol `NAME` with the `C` type signature given by `TYPEDECL` . |
luajit/ffi | |

`deg` |
lua/math | |

`denominator` : The rational’s denumerator |
math/rational | |

`describe` : Create a group of tests, defined in `BODY` , which test `NAME` |
test | |

`destructuring-bind` : Match a single pattern against a single value, then evaluate the `BODY` . |
core/match | |

`difftime` |
lua/os | |

`divide` : Returns `A` divided by `B` . |
math/bignum | |

`do` : Iterate over all given `VARS` , running `STMTS` without collecting the results. |
core/list | |

`dofile` |
lua/basic | |

`dolist` : Iterate over all given `VARS` , running `STMTS` and collecting the results. |
core/list | |

`dominators` : Build the dominators from nodes descended from `ROOT` . |
data/graph | |

`dot` : Compute the dot product of vectors `X` and `Y` . |
math/vector | |

`drop` : Remove the first `N` elements of the list `XS` . |
core/list | |

`dump` |
lua/string | |

e |
||

`echelon` : Reduce the given `MATRIX` to row echelon form. |
math/matrix | |

`eighth` |
core/base | |

`elem?` : Test if `X` is present in the list `XS` . |
core/list | |

`element?` : Check if `VAL` is an element of `SET` . |
data/set | |

`else` : `else` is defined as having the value `true` . |
core/base | |

`empty-struct?` : Check that `XS` is the empty struct. |
core/table | |

`empty?` : Check whether `X` is the empty list or the empty string. |
core/type | |

`ends-with?` : Determine whether `STR` ends with `SUFFIX` . |
core/string | |

`eq?` : Compare values for equality deeply. |
core/type | |

`eql?` : `A` version of `eq?` that compares the types of `X` and `Y` instead of just the values. |
core/type | |

`equals?` : Returns true if `A` == `B` . |
math/bignum | |

`errno` |
luajit/ffi | |

`error` |
lua/basic | |

`error!` : Throw an error. |
core/prelude | |

`even?` : Is `X` an even number? |
math | |

`every` : `A` higher-order lens that focuses `LN` on every element of a list that satisfies the perdicate `X` . |
data/lens | |

`exclude` : Return a list with only the elements of `XS` that don’t match the predicate `P` . |
core/list | |

`execute` |
lua/os | |

`exists?` : Check if `X` exists, i. |
core/type | |

`exit` |
lua/os | |

`exit!` : Exit the program with the exit code `CODE` , and optionally, print the error message `REASON` . |
core/prelude | |

`exp` |
lua/math | |

`expt` |
lua/basic | |

`extend` : Extend the association list `LIST` _ by inserting `VAL` , bound to the key `KEY` , overriding any previous value. |
data/alist | |

f |
||

`fail!` : Fail with the error message `X` , that is, exit the program immediately, without unwinding for an error handler. |
core/prelude | |

`falsey?` : Check whether `X` is falsey, that is, it is either `false` or does not exist. |
core/type | |

`fast-struct` : `A` variation of `struct` , which will not perform any coercing of the `KEYS` in entries. |
core/table | |

`fifth` |
core/base | |

`fill` |
luajit/ffi | |

`filter` : Return a list with only the elements of `XS` that match the predicate `P` . |
core/list | |

`find` |
lua/string | |

`first` |
core/base | |

`fix-symbol` : Convert the quasi-quoted `SYMBOL` into a fully resolved one. |
compiler/nodes | |

`flag?` : Determine whether the given compiler `FLAG` is set. |
compiler | |

`flags` : Get a list of all compiler flags. |
compiler | |

`flat-map` : Map the function `FN` over the lists `XSS` , then flatten the result lists. |
core/list | |

`flatten` : Concatenate all the lists in `XSS` . |
core/list | |

`floor` |
lua/math | |

`flush` |
lua/io | |

`fmod` |
lua/math | |

`folding` : Transform the (traversing) lens `L` into a getter which folds the result using the function `F` and the zero element `Z` . |
data/lens | |

`for` : Iterate `BODY` , with the counter `CTR` bound to `START` , being incremented by `STEP` every iteration until `CTR` is outside of the range given by [`START` . |
core/base | |

`for-each` : Perform the set of actions `BODY` for all values in `LST` , binding the current value to `VAR` . |
core/list | |

`for-pairs` : Iterate over `TBL` , binding `VARS` for each key value pair in `BODY` . |
core/base | |

`forall` : Check that `PROP` holds across all possible points. |
test/check | |

`format` : Output the string `STR` formatted against `ARGS` to the stream `OUT` . |
data/format | |

`format` |
lua/string | |

`fourth` |
core/base | |

`function` : Create a lambda which matches its arguments against the patterns defined in `ARMS` . |
core/match | |

`function?` : Check whether `X` is a function. |
core/type | |

`fusion/add-rule!` : Register a new fusion rule. |
compiler/optimise | |

`fusion/defrule` : Define a rewrite rule which maps `FROM` to `TO` . |
compiler/optimise | |

g |
||

`gc` |
luajit/ffi | |

`gcd` : Compute the greatest common divisor of `X` and `Y` . |
math | |

`gensym` : Create a unique symbol, suitable for using in macros |
core/base | |

`get-idx` |
lua/basic | |

`get-vertex` : Get the corresponding vertex for this `VALUE` from the given `GRAPH` . |
data/graph | |

`getenv` |
lua/os | |

`gethook` |
lua/debug | |

`getinfo` |
lua/debug | |

`getlocal` |
lua/debug | |

`getmetatable` |
lua/debug | |

`getmetatable` |
lua/basic | |

`getregistry` |
lua/debug | |

`getter` : Define a getting lens using `VIEW` as the accessor. |
data/lens | |

`getter?` : Check that `LENS` has a defined getter, along with being tagged as a `LENS` . |
data/lens | |

`getupvalue` |
lua/debug | |

`getuservalue` |
lua/debug | |

`graph->dot` : Convert `GRAPH` to a string in the `DOT` format, suitable for consumption with GraphViz. |
data/graph | |

`graph?` |
data/graph | |

`groups-of` : Splits the list `XS` into sub-lists of size `NUM` . |
core/list | |

`gsub` |
lua/string | |

h |
||

`handler-case` : Evaluate the form `X` , and if an error happened, match the series of `(?pattern . ?body)` arms given in `BODY` against the value of the error, executing the first that succeeeds. |
core/match | |

`head` : `A` lens equivalent to `car` , which `view` s and applies `over` the first element of a list. |
data/lens | |

`height` : The height of this matrix. |
math/matrix | |

`help!` : Display the help for the argument parser as defined in `SPEC` . |
io/argparse | |

`huge` |
lua/math | |

i |
||

`id` : Return the value `X` unmodified. |
data/function | |

`identity` : Create the identity matrix with the given `DIM` . |
math/matrix | |

`if` : Evaluate `T` if `C` is true, otherwise, evaluate `B` . |
core/base | |

`if-let` : Evaluate `THEN` or `ELSE` , depending on the truthiness of all variables bound (as per `let` ) in `VARS` . |
core/binders | |

`if-match` : Matches a pattern against a value defined in `CS` , evaluating `T` with the captured variables in scope if the pattern succeeded, otherwise evaluating `E` . |
core/match | |

`if-with` : Bind the pair `VAR` of the form `(name value)` , evaluating `THEN` if the value is truthy or `ELSE` if not. |
core/binders | |

`imaginary` : The imaginary part of this `complex` number. |
math/complex | |

`inc!` : Increments the symbol `X` by 1. |
math | |

`init` : Return the list `XS` with the last element removed. |
core/list | |

`input` |
lua/io | |

`insert` |
lua/table | |

`insert` : Extend the association list `ALIST` by inserting `VAL` , bound to the key `KEY` . |
data/alist | |

`insert` : Build a copy of `SET` with VALs inserted. |
data/set | |

`insert!` : Insert `VALS` into `SET` . |
data/set | |

`insert!` : Extend the association list `ALIST` in place by inserting `VAL` , bound to the key `KEY` . |
data/alist | |

`insert-nth!` : Mutate the list `LI` , inserting `VAL` at `IDX` . |
core/list | |

`intersection` : The set of values that occur in both `A` and `B` . |
data/set | |

`invert` : Invert the provided `MATRIX` . |
math/matrix | |

`invokable?` : Test if the expression `X` makes sense as something that can be applied to a set of arguments. |
data/function | |

`ipairs` |
lua/basic | |

`is` : Create a test whose `BODY` asserts `NAME` is true |
test | |

`istype` |
luajit/ffi | |

`isyieldable` |
lua/coroutine | |

`it` : Create a test `NAME` which executes all expressions and assertions in `BODY` |
test | |

`it` : The simplest lens, not focusing on any subcomponent. |
data/lens | |

`iter-pairs` : Iterate over `TABLE` with a function `FUNC` of the form `(lambda (key val) ...)` |
core/table | |

k |
||

`key?` : Check whether `X` is a key. |
core/type | |

`keys` : Return the keys in the structure `ST` . |
core/table | |

l |
||

`lambda` |
core/base | |

`last` : Return the last element of the list `XS` . |
core/list | |

`lcm` : Compute the lowest common multiple of `X` and `Y` . |
math | |

`len` |
lua/string | |

`len` |
lua/utf8 | |

`len#` |
lua/basic | |

`length` : Returns the amount of numerical bits needed to contain `A` . |
math/bignum | |

`lens` : Define a lens using `VIEW` and `OVER` as the getter and the replacer functions, respectively. |
data/lens | |

`lens?` : Check that is `LENS` a valid lens, that is, has the proper tag, a valid getter and a valid setter. |
data/lens | |

`less-or-equal?` : Returns true if `A` <= `B` . |
math/bignum | |

`less-than?` : Returns true if `A` < `B` . |
math/bignum | |

`let` : Bind several variables (given in `VARS` ), then evaluate `BODY` . |
core/binders | |

`let*` : Bind several variables (given in `VARS` ), then evaluate `BODY` . |
core/binders | |

`let*` |
core/base | |

`let-escape-continuation` : Bind `K` within `BODY` to an escape continuation. |
control/prompt | |

`let-prompt` : Evaluate `E` in a prompt with the tag `TG` and handler `H` . |
control/prompt | |

`let/ec` |
control/prompt | |

`let/p` |
control/prompt | |

`letrec` : Bind several variables (given in `VARS` ), which may be recursive. |
core/binders | |

`lines` |
lua/io | |

`list` : Return the list of variadic arguments given. |
core/base | |

`list->struct` : Converts a `LIST` to a structure, mapping an index to the element in the list. |
core/table | |

`list->vector` : Create a new vector from a list of values. |
math/vector | |

`list?` : Check whether `X` is a list. |
core/type | |

`load` |
lua/basic | |

`load` |
luajit/ffi | |

`loaded` |
lua/package | |

`loadfile` |
lua/basic | |

`loadlib` |
lua/package | |

`log` |
lua/math | |

`logger/do-node-error!` : Push an error message to the logger, then fail. |
compiler | |

`logger/put-debug!` : Push an verbose message `MSG` to the logger |
compiler | |

`logger/put-error!` : Push an error message `MSG` to the logger |
compiler | |

`logger/put-node-error!` : Push a defailed error message to the logger. |
compiler | |

`logger/put-node-warning!` : Push a warning message to the logger. |
compiler | |

`logger/put-verbose!` : Push an verbose message `MSG` to the logger |
compiler | |

`logger/put-warning!` : Push an warning message `MSG` to the logger |
compiler | |

`loop` : `A` general iteration helper. |
core/binders | |

`lower` |
lua/string | |

m |
||

`magnitude` : Get the magnitude of complex number `Z` . |
math/complex | |

`make-graph` : Create a new, empty graph. |
data/graph | |

`make-set` : Create a new, empty set with the given `HASH-FUNCTION` . |
data/set | |

`map` : Iterate over all the successive cars of `XSS` , producing a single list by applying `FN` to all of them. |
core/list | |

`match` : Determine whether `EXPR` matches the provided pattern `PTRN` , returning nil or a lookup of capture names to captured expressions. |
compiler/pattern | |

`match` |
lua/string | |

`match-always` |
compiler/pattern | |

`matcher` : Create a matcher for the given pattern literal `PTRN` . |
compiler/pattern | |

`matches?` : Test if the value `X` matches the pattern `PT` . |
core/match | |

`matches?` : Determine whether `EXPR` matches the provided pattern `PTRN` . |
compiler/pattern | |

`matrix` : Create a new matrix with the given `WIDTH` and `HEIGHT` . |
math/matrix | |

`matrix-item` : Get the item in the provided `MATRIX` at `Y` `X` . |
math/matrix | |

`matrix?` |
math/matrix | |

`max` |
lua/math | |

`maxinteger` |
lua/math | |

`may` : Create a group of tests defined in `BODY` whose names take the form `<prefix> may NAME, and <test_name>` |
test | |

`maybe-map` : Iterate over all successive cars of `XSS` , producing a single list by applying `FN` to all of them, while discarding any `nil` s. |
core/list | |

`merge` : Merge all tables in `STRUCTS` together into a new table. |
core/table | |

`metatype` |
luajit/ffi | |

`min` |
lua/math | |

`mininteger` |
lua/math | |

`mod` |
lua/basic | |

`modf` |
lua/math | |

`modulo` : Returns the remainder of `A` divided by `B` . |
math/bignum | |

`move` |
lua/table | |

`multiply` : Returns `A` multiplied by `B` . |
math/bignum | |

n |
||

`n` : Get the length of list X |
core/base | |

`n*` : Generalised numeric cross product. |
math/numerics | |

`n+` : Generalised numeric addition. |
math/numerics | |

`n-` : Generalised numeric subtraction. |
math/numerics | |

`n/` : Generalised numeric division. |
math/numerics | |

`n<` : Generalised numeric less-than comparison. |
math/numerics | |

`n<=` : Generalised numeric less-than or equal to comparison. |
math/numerics | |

`n=` : Generalised numeric equality. |
math/numerics | |

`n>` : Generalised numeric greater than. |
math/numerics | |

`n>=` : Generalised numeric greater than or equal to. |
math/numerics | |

`nabs` : Generalised numeric absolute value. |
math/numerics | |

`nan?` : Is `X` equal to NaN? |
math | |

`negate` : Returns `A` with the sign inverted. |
math/bignum | |

`neq?` : Compare `X` and `Y` for inequality deeply. |
core/type | |

`new` : Creates a new bignum from `A` . |
math/bignum | |

`new` |
luajit/ffi | |

`nexpt` : Generalised numeric exponentiation. |
math/numerics | |

`next` |
lua/basic | |

`nil?` : Check if `X` does not exist, i. |
core/type | |

`ninth` |
core/base | |

`nkeys` : Return the number of keys in the structure `ST` . |
core/table | |

`nmod` : Generalised numeric modulus. |
math/numerics | |

`nnegate` : Generalised numeric negation. |
math/numerics | |

`node->val` : Gets the constant value of `NODE` . |
compiler/nodes | |

`node-contains-var?` : Determine whether `NODE` contains a reference to the given `VAR` . |
compiler/nodes | |

`node-contains-vars?` : Determine whether `NODE` contains a reference to any of the given `VARS` . |
compiler/nodes | |

`none` : Check that no elements in `XS` match the predicate `P` . |
core/list | |

`norm` : Compute the norm of vector `X` (i. |
math/vector | |

`not` : Compute the logical negation of the expression `EXPR` . |
core/base | |

`nrecip` : Generalised numeric reciprocal. |
math/numerics | |

`nsign` : Generalised numeric sign number. |
math/numerics | |

`nsqrt` : Generalised numeric square root. |
math/numerics | |

`nth` : Get the `IDX` th element in the list `XS` . |
core/list | |

`nths` : Get the IDX-th element in all the lists given at `XSS` . |
core/list | |

`nub` : Remove duplicate elements from `XS` . |
core/list | |

`null` : Create a vector with a magnitude of 0. |
math/vector | |

`number->string` : Convert the number `X` into a string. |
core/prelude | |

`number?` : Check whether `X` is a number. |
core/type | |

`numerator` : The rational’s numerator |
math/rational | |

o |
||

`odd?` : Is `X` an odd number? |
math | |

`offset` |
lua/utf8 | |

`offsetof` |
luajit/ffi | |

`on` : `A` lens that focuses on the element of a structure that is at the key `K` . |
data/lens | |

`on!` : `A` lens that focuses (and mutates) the element of a structure that is at the key `K` . |
data/lens | |

`open` |
lua/io | |

`or` : Return the logical or of values `A` and `B` , and, if present, the logical or of all the values in `REST` . |
core/base | |

`os` |
luajit/ffi | |

`output` |
lua/io | |

`over` : Flipped synonym for `^~` |
data/lens | |

`overl!` : Mutate `VAL` by applying to a bit of it the function `F` , using `LENS` . |
data/lens | |

p |
||

`pack` |
lua/table | |

`pairs` |
lua/basic | |

`parse!` : Parse `ARGS` using the argument parser defined in `SPEC` . |
io/argparse | |

`partition` : Split `XS` based on the predicate `P` . |
core/list | |

`path` |
lua/package | |

`pattern` : Quote the provided pattern `PTRN` , suitable for matching with i `matches?` . |
compiler/pattern | |

`pcall` |
lua/basic | |

`pending` : Create a test `NAME` whose `BODY` will not be run. |
test | |

`pi` |
lua/math | |

`polar->` : Create a complex number from the given `MAGNITUDE` and `ANGLE` . |
math/complex | |

`pop-last!` : Mutate the list `XS` , removing and returning its last element. |
core/list | |

`popen` |
lua/io | |

`power` : Returns `A` to the power of `B` . |
math/bignum | |

`pred` : Return the predecessor of the number `X` . |
math | |

`preload` |
lua/package | |

`pretty` : Pretty-print a value. |
core/type | |

`print` |
lua/basic | |

`print!` : Print to standard output. |
core/prelude | |

`printf` : Print the formatted string `FMT` using `ARGS` . |
core/prelude | |

`prod` : Return the product of all elements in `XS` . |
core/list | |

`progn` : Group a series of expressions together. |
core/base | |

`prune` : Remove values matching the predicates `empty?` or `nil?` from the list `XS` . |
core/list | |

`push-cdr!` : Mutate the list `XS` , adding `VALS` to its end. |
core/list | |

q |
||

`quasiquote` : Quote `VAL` , but replacing all `unquote` and `unquote-splice` with their actual value. |
core/base | |

`quoted` : Quote the string `STR` so it is suitable for printing. |
core/string | |

r |
||

`rad` |
lua/math | |

`random` |
lua/math | |

`randomseed` |
lua/math | |

`range` : Build a list from :`FROM` to :`TO` , optionally passing by :`BY` . |
core/list | |

`range/get-source` : Get the nearest source position of `NODE` |
compiler | |

`rational` : `A` rational number, represented as a tuple of numerator and denominator. |
math/rational | |

`rational?` |
math/rational | |

`rawequal` |
lua/basic | |

`rawget` |
lua/basic | |

`rawlen` |
lua/basic | |

`rawset` |
lua/basic | |

`read` |
lua/io | |

`read-all!` : Reads the data from the file at `PATH` and returns it as a string. |
io | |

`read-bytes!` : Reads the data from the file at `PATH` and returns it as a list of bytes (numbers). |
io | |

`read-lines!` : Reads the lines from the file at `PATH` and returns it as a list of strings. |
io | |

`real` : The real part of this `complex` number. |
math/complex | |

`reduce` : Accumulate the list `XS` using the binary function `F` and the zero element `Z` . |
core/list | |

`reduced-echelon` : Reduce the given `MATRIX` to reduced row echelon form. |
math/matrix | |

`reify` : Return the definition of the symbol (not variable) `X` , returning `nil` if it’s not a top-level definition. |
compiler/resolve | |

`remove` |
lua/os | |

`remove` |
lua/table | |

`remove-nth!` : Mutate the list `LI` , removing the value at `IDX` and returning it. |
core/list | |

`rename` |
lua/os | |

`rep` |
lua/string | |

`require` |
lua/basic | |

`reset` : Establish a prompt, and evaluate `BODY` within that prompt. |
control/prompt | |

`resume` |
lua/coroutine | |

`reverse` : Reverse the list `XS` , using the accumulator `ACC` . |
core/list | |

`reverse` |
lua/string | |

`round` : Round `X` , to the nearest integer. |
math | |

`running` |
lua/coroutine | |

s |
||

`scope-vars` : Return the variables present in the given `SCOPE` , using the `active-scope` if none is given. |
compiler/resolve | |

`searchers` |
lua/package | |

`searchpath` |
lua/package | |

`second` |
core/base | |

`section` : Create a group of tests defined in `BODY` whose names take the form `<prefix> NAME <test_name>` |
test | |

`select` |
lua/basic | |

`self` : Index `X` with `KEY` and invoke the resulting function with `X` and `ARGS` . |
data/function | |

`set` : Flipped synonym for `^=` |
data/lens | |

`set->list` : Convert `SET` to a list. |
data/set | |

`set-action` : Set the appropriate key in `DATA` for `ARG` to `VALUE` . |
io/argparse | |

`set-idx!` |
lua/basic | |

`set-num-action` : Set the appropriate key in `DATA` for `ARG` to `VALUE` , ensuring it is a number. |
io/argparse | |

`set-of` : Create the set containing `VALUES` with the default hash function. |
data/set | |

`set?` |
data/set | |

`sethook` |
lua/debug | |

`setl!` : Mutate `VAL` by replacing a bit of it with `NEW` , using `LENS` . |
data/lens | |

`setlocal` |
lua/debug | |

`setlocale` |
lua/os | |

`setmetatable` |
lua/basic | |

`setmetatable` |
lua/debug | |

`setter` : Define a setting lens using `VIEW` as the accessor. |
data/lens | |

`setter?` : Check that `LENS` has a defined setter, along with being tagged as a `LENS` . |
data/lens | |

`setupvalue` |
lua/debug | |

`setuservalue` |
lua/debug | |

`seventh` |
core/base | |

`shift` : Abort to the nearest `reset` , and evaluate `BODY` in a scope where the captured continuation is bound to `K` . |
control/prompt | |

`shl` : Returns `X` shifted left by `DISP` . |
lua/bit32 | |

`shl` : Returns `A` shifted left by `B` . |
math/bignum | |

`shl!` : Shifts (modifies) `A` to the left by `B` . |
math/bignum | |

`shr` : Returns `X` shifted right by `DISP` . |
lua/bit32 | |

`shr` : Returns `A` shifted right by `B` . |
math/bignum | |

`shr!` : Shifts (modifies) `A` to the right by `B` . |
math/bignum | |

`sin` |
lua/math | |

`sixth` |
core/base | |

`sizeof` |
luajit/ffi | |

`slice` : Take a slice of `XS` , with all values at indexes between `START` and `FINISH` (or the last entry of `XS` if not specified). |
core/base | |

`slot?` : Test whether `SYMB` is a slot. |
data/function | |

`snoc` : Return a copy of the list `XS` with the element `XS` added to its end. |
core/list | |

`sort` |
lua/table | |

`sort` : Sort the list `XS` , non-destructively, optionally using `F` as a comparator. |
core/list | |

`sort!` : Sort the list `XS` in place, optionally using `F` as a comparator. |
core/list | |

`split` : Splits a list into sub-lists by the separator `Y` . |
core/list | |

`split` : Split the string given by `TEXT` in at most `LIMIT` components, which are delineated by the Lua pattern `PATTERN` . |
core/string | |

`sprintf` : Format the format string `FMT` using `ARGS` . |
core/prelude | |

`sqrt` |
lua/math | |

`starts-with?` : Determine whether `STR` starts with `PREFIX` . |
core/string | |

`status` |
lua/coroutine | |

`stderr` |
lua/io | |

`stdin` |
lua/io | |

`stdout` |
lua/io | |

`string` |
luajit/ffi | |

`string->number` : Convert the string `X` into a number. |
core/prelude | |

`string->symbol` : Convert the string `X` to a symbol. |
core/symbol | |

`string?` : Check whether `X` is a string. |
core/type | |

`strongly-connected-components` : Find all strong components from a `GRAPH` . |
data/graph | |

`struct` : Return the structure given by the list of pairs `ENTRIES` . |
core/table | |

`struct->assoc` : Convert the structure `TBL` into an association list. |
data/alist | |

`struct->list` : Converts a structure `TBL` that is a list by having its keys be indices to a regular list. |
core/table | |

`struct->list!` : Converts a structure `TBL` that is a list by having its keys be indices to a regular list. |
core/table | |

`sub` |
lua/string | |

`subtract` : Returns `A` minus `B` . |
math/bignum | |

`succ` : Return the successor of the number `X` . |
math | |

`sum` : Return the sum of all elements in `XS` . |
core/list | |

`sym..` : Concatenate all the symbols in `XS` . |
core/symbol | |

`symbol->string` : Convert the symbol `X` to a string. |
core/symbol | |

`symbol->var` : Extract the variable from the given `SYMBOL` . |
compiler/nodes | |

`symbol?` : Check whether `X` is a symbol. |
core/type | |

t |
||

`table?` : Check whether the value `X` is a table. |
core/type | |

`tail` : `A` lens equivalent to `cdr` , which `view` s and applies `over` to all but the first element of a list. |
data/lens | |

`take` : Take the first `N` elements of the list `XS` . |
core/list | |

`take-while` : Takes elements from the list `XS` while the predicate `P` is true, starting at index `IDX` . |
core/list | |

`tan` |
lua/math | |

`tenth` |
core/base | |

`third` |
core/base | |

`time` |
lua/os | |

`tmpfile` |
lua/io | |

`tmpname` |
lua/os | |

`tointeger` |
lua/math | |

`tonumber` |
lua/basic | |

`tostring` : Converts the bignum `A` to a string. |
math/bignum | |

`tostring` |
lua/basic | |

`traceback` |
lua/debug | |

`traverse` : An alias for `map` with the arguments `XS` and `F` flipped. |
core/list | |

`traverse-node` : Traverse `NODE` with `VISITOR` . |
compiler/nodes | |

`traverse-nodes` : Traverse a list of `NODES` , starting at `IDX` , using the specified `VISITOR` . |
compiler/nodes | |

`traverse-postorder` : Visit a graph using postorder traversal starting at `ROOT` , calling `VISITOR` for each vertex. |
data/graph | |

`traverse-preorder` : Visit a graph using preorder traversal starting at `ROOT` , calling `VISITOR` for each vertex. |
data/graph | |

`traversing` : `A` lens which maps the lens `L` over every element of a given list. |
data/lens | |

`trim` : Remove whitespace from both sides of `STR` . |
core/string | |

`tripping` : Express that the composition of the functions `F` and `G` (in order! |
test/check | |

`try-var-lookup` : Try to look up `SYMBOL` in the given `SCOPE` , using the `active-scope` if none given. |
compiler/resolve | |

`type` |
lua/io | |

`type` : Return the type of `VAL` . |
core/type | |

`type` |
lua/math | |

`type#` |
lua/basic | |

`typeinfo` |
luajit/ffi | |

`typeof` |
luajit/ffi | |

u |
||

`ult` |
lua/math | |

`union` : The set of values that occur in either `A` or `B` . |
data/set | |

`union` : Set-like union of `XS` and `YS` . |
core/list | |

`unit` : Convert the vector `X` into the unit vector. |
math/vector | |

`unless` : Evaluate `BODY` if `C` is false, otherwise, evaluate `nil` . |
core/base | |

`unpack` |
lua/table | |

`update-struct` : Create a new structure based of `ST` , setting the values given by the pairs in `KEYS` . |
core/table | |

`upper` |
lua/string | |

`upvalueid` |
lua/debug | |

`upvaluejoin` |
lua/debug | |

`usage!` : Display a short usage for the argument parser as defined in `SPEC` . |
io/argparse | |

`usage-error!` : Display the usage of `SPEC` and exit with an `ERROR` message. |
io/argparse | |

`use` : Bind each variable in `VAR` , checking for truthyness between bindings, execute `BODY` , then run a finaliser for all the variables bound by `VAR` . |
core/binders | |

v |
||

`val->node` : Gets the node representation of the constant `VALUE` . |
compiler/nodes | |

`values` : Return the values in the structure `ST` . |
core/table | |

`values-list` : Return multiple values, one per element in `XS` . |
core/base | |

`var->symbol` : Create a new symbol referencing the given `VARIABLE` . |
compiler/nodes | |

`var-definition` : Get the definition of the given `VARIABLE` , returning `nil` if it is not a top level definition. |
compiler/resolve | |

`var-docstring` : Get the docstring for the given `VARIABLE` , returning `nil` if it is not a top level definition. |
compiler/resolve | |

`var-lookup` : Look up `SYMBOL` in the given `SCOPE` , using the `active-scope` if none given. |
compiler/resolve | |

`var-usage` : Get usage information about the specified `VAR` . |
compiler/pass | |

`var-value` : Get the value of the given `VARIABLE` , returning `nil` if it is not a top level definition. |
compiler/resolve | |

`vector` : Create a new vector from several values. |
math/vector | |

`vector-dim` : The dimension of this vector. |
math/vector | |

`vector-item` : Get the `I` th element in the `VECTOR` . |
math/vector | |

`vector?` |
math/vector | |

`vertex?` |
data/graph | |

`view` : Flipped synonym for `^.` |
data/lens | |

`visit-node` : Visit `NODE` with `VISITOR` . |
compiler/nodes | |

`visit-nodes` : Visit a list of `NODES` , starting at `IDX` , using the specified `VISITOR` . |
compiler/nodes | |

w |
||

`when` : Evaluate `BODY` when `C` is true, otherwise, evaluate `nil` . |
core/base | |

`when-let` : Bind `VARS` , as with `let` , and check they are all truthy before evaluating `BODY` . |
core/binders | |

`when-let*` : Bind each pair of `(name value)` of `VARS` , checking if the value is truthy before binding the next, and finally evaluating `BODY` . |
core/binders | |

`when-with` : Bind the `PAIR` var of the form `(name value)` , only evaluating `BODY` if the value is truthy |
core/binders | |

`while` : Iterate `BODY` while the expression `CHECK` evaluates to `true` . |
core/base | |

`width` : The width of this matrix. |
math/matrix | |

`will` : Create a test whose `BODY` asserts `NAME` will happen |
test | |

`will-not` : Create a test whose `BODY` asserts `NAME` will not happen |
test | |

`with` : Bind the single variable `VAR` , then evaluate `BODY` . |
core/base | |

`with` : Bind the single variable `VAR` , then evaluate `BODY` . |
core/binders | |

`wrap` |
lua/coroutine | |

`write` |
lua/io | |

`write-all!` : Writes the string `DATA` to the file at `PATH` . |
io | |

`write-bytes!` : Writes the bytes (list of numbers) `DATA` to the file at `PATH` . |
io | |

`write-lines!` : Writes the lines (list of strings) `DATA` to the file at `PATH` . |
io | |

x |
||

`xpcall` |
lua/basic | |

y |
||

`yield` |
lua/coroutine |