# 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
`*arguments*`: The arguments passed to the currently executing program core/base
`*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
`/=`: Check whether `A` is not equal to `B`, `B` is not equal to the first element in `REST`, etc. control/comparison
`/=` lua/basic
`<`: 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
`<=` 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
`<=>`: Bidirectional implication. core/base
`=`: Determine if two variables are equal. lua/basic
`=`: Check whether `A`, `B` and all items in `REST` are equal. control/comparison
`=:=`: Express that the functions `F` and `G` are equivalent at the point `X`. test/check
`=>`: Logical implication. core/base
`>`: 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
`>` lua/basic
`>=`: 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
`_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
`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/jit
`arch` luajit/ffi
`arg`: The arguments passed to the currently executing program core/base
`arg#` lua/basic
`arshift` luajit/bit
`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/demand
`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
`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
`band` luajit/bit
`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
`bnot` luajit/bit
`bool->string`: Convert the boolean `X` into a string. core/prelude
`boolean?`: Check whether `X` is a boolean. core/type
`bor` luajit/bit
`bswap` luajit/bit
`builtin`: Get the builtin with the given `NAME`. compiler/nodes
`builtin?`: Determine whether the specified `NODE` is the given `BUILTIN`. compiler/nodes
`bxor` luajit/bit
`byte` lua/string
`bytes->string`: Convert a list of `BYTES` to a string. core/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
`cardinality`: Return the number of elements in `SET`. data/set
`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` core/base
`cdr`: Return a reference the list `X` without the first element present. core/list
`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
`chars->string`: Convert a list of `CHARS` to a string. core/string
`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`: Colour 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
`concat`: Concatenate a list of strings, using an optional separator. core/string
`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`: Return a copy of the list `XSS` with the elements `XS` added to its head. core/list
`cons`: Add `X` to the start of the list `XS`. core/base
`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/method
`dec!`: Decrements the value described by `ADDRESS` by 1. control/setq
`defalias`: Alias the method at `NAME` to the method at `OTHER`. core/method
`defdefault`: Add a default case to the generic method `NAME` with the arguments `LL` and the body `BODY`. core/method
`defgeneric`: Define a generic method called `NAME` with the arguments given in `LL`, and the attributes given in `ATTRS`. core/method
`define-foreign-function`: Define a foreign function wrapper for the `C` symbol `NAME`, taking arguments `LAMBDA-LIST`. io/foreign
`define-foreign-functions`: Declare all the foreign functions specified in `C-DEFINITIONS`, and additionally build the wrappers as described in `FUNCTIONS`, using `define-foreign-function` io/foreign
`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/method
`defpass`: Define a pass with the given `NAME` and `BODY` taking the specified `ARGS`. compiler/pass
`defsetq`: Define the `setq!`/`over!` `PATTERN` with the replacement `REPL`. control/setq
`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
`demand`: Demand that particular `CONDITION` is upheld. core/demand
`denominator`: The rational’s denominator math/rational
`describe`: Create a group of tests, defined in `BODY`, which test `NAME` test
`desire`: Demand that particular `CONDITION` is upheld if debug assertions are on (`-fstrict-checks`). core/demand
`destructuring-bind`: Match a single pattern against a single value, then evaluate the `BODY`. core/match
`difftime` lua/os
`disjoint?`: Is the intersection of `SETS` empty? data/set
`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-index`: Finds the first index in `XS` where the item matches `X`. 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/method
`eql?`: `A` version of `eq?` that compares the types of `X` and `Y` instead of just the values. core/method
`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
`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
`exported-vars`: Generate a struct with all variables exported in the current module. compiler/helpers
`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
`find-index`: Finds the first index in `XS` where the item matches the predicate `P`. core/list
`first` core/base
`fix-symbol`: Convert the quasi-quoted `SYMBOL` into a fully resolved one. compiler/nodes
`flag?`: Determine whether one of the given compiler `FLAGS` are 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` luajit/jit
`flush` lua/io
`fmod` lua/math
`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
`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
`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 value described by `ADDRESS` by 1. control/setq
`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!`: Extend the association list `ALIST` in place by inserting `VAL`, bound to the key `KEY`. data/alist
`insert!`: Insert `VALS` into `SET`. data/set
`insert-nth!`: Mutate the list `LI`, inserting `VAL` at `IDX`. core/list
`intersection`: The set of values that occur in all the `SETS`. 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
`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/utf8
`len` lua/string
`len#` lua/basic
`length`: Returns the amount of numerical bits needed to contain `A`. math/bignum
`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
`lshift` luajit/bit
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` lua/string
`match`: Determine whether `EXPR` matches the provided pattern `PTRN`, returning nil or a lookup of capture names to captured expressions. compiler/pattern
`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/method
`new` luajit/ffi
`new`: Creates a new bignum from `A`. math/bignum
`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
`off` luajit/jit
`offset` lua/utf8
`offsetof` luajit/ffi
`on` luajit/jit
`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/jit
`os` luajit/ffi
`output` lua/io
`over!`: Replace the value at `ADDRESS` according to `FUN`. control/setq
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/method
`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!`: Mutate the list `XS`, adding `VALS` to its end. 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` lua/string
`reverse`: Reverse the list `XS`, using the accumulator `ACC`. core/list
`rol` luajit/bit
`ror` luajit/bit
`round`: Round `X`, to the nearest integer. math
`rshift` luajit/bit
`running` lua/coroutine
s
`scope-exported`: Fetch the variables exported in the given `SCOPE`, using the `active-scope` if none is given. compiler/resolve
`scope-vars`: Fetch 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->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
`setlocal` lua/debug
`setlocale` lua/os
`setmetatable` lua/debug
`setmetatable` lua/basic
`setq!`: Replace the value at `ADDRESS` with `VALUE`. control/setq
`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
`slicing-view`: Return a mutable reference to the list `LIST`, with indexing offset (positively) by `OFFSET`. core/list
`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`: Sort the list `XS`, non-destructively, optionally using `F` as a comparator. core/list
`sort` lua/table
`sort!`: Sort the list `XS` in place, optionally using `F` as a comparator. core/list
`splice`: Unpack a list of arguments, returning all elements in `XS`. core/base
`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
`status` luajit/jit
`stderr` lua/io
`stdin` lua/io
`stdout` lua/io
`string` luajit/ffi
`string->bytes`: Convert a string to a list of character bytes. core/string
`string->chars`: Convert a string to a list of characters. core/string
`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
`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
`tiny`: Negative infinity math
`tmpfile` lua/io
`tmpname` lua/os
`tobit` luajit/bit
`tohex` luajit/bit
`tointeger` lua/math
`tonumber` lua/basic
`tostring` lua/basic
`tostring`: Converts the bignum `A` to a string. math/bignum
`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
`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`: Set-like union of all the lists in `XSS`. core/list
`union`: The set of values that occur in any set in the `SETS`. data/set
`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
`version` luajit/jit
`version-num` luajit/jit
`vertex?` data/graph
`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/binders
`with`: Bind the single variable `VAR`, then evaluate `BODY`. core/base
`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