# Symbol index

Symbol Defined in
\$
/=: 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
<=: 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
=: Check whether A, B and all items in REST are equal. control/comparison
>: 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
\$continuation control/prompt
*arguments*: The arguments passed to the currently executing program core/base
-and: Return the logical conjunction of values A and B. core/base
-or: Return the logical disjunction of values A and B. core/base
<=>: Bidirectional implication. core/base
=>: Logical implication. core/base
\\: The difference between XS and YS (non-associative. core/list
*standard-error*: The standard error stream. core/prelude
*standard-input*: The standard input stream. core/prelude
*standard-output*: The standard output stream. core/prelude
\$: Perform interpolation (variable substitution) on the string STR. core/string
.<!: 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
\$bitset data/bitset
->: Chain a series of method calls together. data/function
\$graph data/graph
\$vertex data/graph
\$set data/set
* lua/basic
+ lua/basic
- lua/basic
.. lua/basic
/ lua/basic
/= lua/basic
< lua/basic
<= lua/basic
=: Determine if two variables are equal. lua/basic
> lua/basic
>= lua/basic
_ENV lua/basic
_G lua/basic
\$complex math/complex
->polar: Get the magnitude and angle of complex number Z. math/complex
\$matrix math/matrix
\$rational math/rational
->float: Convert the rational number Y to a floating-point number. math/rational
->rat: Convert the floating-point number Y to a rational number. math/rational
\$vector math/vector
=:=: Express that the functions F and G are equivalent at the point X. test/check
a
add-pass!: Register a PASS created with defpass. compiler/pass
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
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
alive?: Check that the continuation K may be executed further. control/prompt
and: Return the logical and of values A and B, and, if present, the logical and of all the values in REST. core/base
apply: Apply the function F using XS as the argument list, with XSS as arguments before XS is spliced. core/base
arg: The arguments passed to the currently executing program core/base
assert-type!: Assert that the argument ARG has type TY, as reported by the function type. core/demand
accumulate-with: A composition of reduce and map. core/list
all: Test if all elements of XS match the predicate P. core/list
any: Check for the existence of an element in XS that matches the predicate P. core/list
append: Concatenate XS and YS. core/list
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
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
as-is: Return the value X unchanged. data/function
add-vertex!: Create a vertex with the corresponding VALUE and add it to the GRAPH. data/graph
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
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
arg# lua/basic
assert lua/basic
arshift lua/bit32
abs lua/math
acos lua/math
asin lua/math
atan lua/math
atan2 lua/math
arshift luajit/bit
abi luajit/ffi
alignof luajit/ffi
arch luajit/ffi
arch luajit/jit
absolute: Returns A if A is positive, otherwise inverts the sign and returns the positive version of A. math/bignum
add: Returns A plus B. math/bignum
ashr: Returns the arithmetic right shift of X shifted right by DISP. math/bit32
angle: Get the angle of complex number Z. math/complex
angle: Compute the angle between vectors X and Y. math/vector
affirm: Assert each expression in ASSERTS evaluates to true test/assert
assert!: Assert CND is true, otherwise failing with MSG test/assert
b
builtin: Get the builtin with the given NAME. compiler/nodes
builtin?: Determine whether the specified NODE is the given BUILTIN. compiler/nodes
block: Estabilish an escape continuation called break and evaluate BODY. control/prompt
bool->string: Convert the boolean X into a string. core/prelude
bytes->string: Convert a list of BYTES to a string. core/string
between?: Check if the numerical value X is between MIN and MAX. core/type
boolean?: Check whether X is a boolean. core/type
bitset? data/bitset
bitsets-and: Performs a logical AND between two bitsets and returns the result as a new bitset data/bitset
bitsets-or: Performs a logical OR between two bitsets and returns the result as a new bitset data/bitset
bitsets-xor: Performs a logical XOR between two bitsets and returns the result as a new bitset data/bitset
band lua/bit32
bnot lua/bit32
bor lua/bit32
bswap lua/bit32
bxor lua/bit32
byte lua/string
band luajit/bit
bnot luajit/bit
bor luajit/bit
bswap luajit/bit
bxor luajit/bit
bit-at: Returns the value of the bit (0 or 1) of A at position BIT. math/bignum
bit-and: Returns the bitwise AND of its arguments. math/bit32
bit-extract: Returns the unsigned number formed by splicing the bits FIELD to FIELD + WIDTH - 1 from X. math/bit32
bit-not: Returns the bitwise NOT of X. math/bit32
bit-or: Returns the bitwise OR of its arguments. math/bit32
bit-replace: Returns X with the bits FIELD to FIELD + WIDTH - 1 replaced with the unsigned number value of V. math/bit32
bit-rotl: Returns X rotated left by DISP. math/bit32
bit-rotr: Returns X rotated right by DISP. math/bit32
bit-test: Returns true if the bitwise AND of its arguments is not 0. math/bit32
bit-xor: Returns the bitwise XOR of its arguments. math/bit32
c
constant?: Determine whether the specified NODE is a constant. compiler/nodes
changed!: Mark this pass as having a side effect. compiler/pass
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
continuation? control/prompt
car core/base
cdr core/base
cons: Add X to the start of the list XS. core/base
const-val: Get the actual value of VAL, an argument to a macro. core/base
caaaar core/list
caaaars core/list
caaar core/list
caaars core/list
caar core/list
caars core/list
car: Return the first element present in the list X. core/list
cars core/list
cdaaar core/list
cdaaars core/list
cdaar core/list
cdaars core/list
cdar core/list
cdars core/list
cddaar core/list
cddaars 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
cdr: Return a reference the list X without the first element present. core/list
cdrs core/list
cons: Return a copy of the list XSS with the elements XS added to its head. core/list
case: Match a single value against a series of patterns, evaluating the first body that matches, much like cond. core/match
char-at: Index the string XS, returning the character at position X. core/string
chars->string: Convert a list of CHARS to a string. core/string
concat: Concatenate a list of strings, using an optional separator. core/string
copy-of: Create a shallow copy of STRUCT. core/table
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
cardinality: Returns the number of set bits in the bitset BS data/bitset
clear-bit!: Clears the bit in the bitset BS with the specified index BIT data/bitset
call: Index X with KEY and invoke the resulting function with ARGS. data/function
comp: Return the pointwise composition of all functions in FS. data/function
compose: Return the pointwise composition of functions F and G. data/function
const: Return a function which always returns X. data/function
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
condensation: Compute the condensation of an input graph, IN-GRAPH, replacing all strongly connected components with a super vertex. data/graph
cardinality: Return the number of elements in SET. data/set
create: Create a new argument parser io/argparse
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
collectgarbage lua/basic
create lua/coroutine
close lua/io
ceil lua/math
cos lua/math
clock lua/os
config lua/package
cpath lua/package
char lua/string
concat lua/table
char lua/utf8
charpattern lua/utf8
codepoint lua/utf8
codes lua/utf8
C luajit/ffi
cast luajit/ffi
cdef luajit/ffi
copy luajit/ffi
copy: Returns a deep copied clone of A. math/bignum
complex: Represents a complex number, formed of a real and imaginary part. math/complex
complex? math/complex
conjugate: Get the complex conjugate of Z. math/complex
cross: Compute the vector cross product of X and Y. math/vector
can: Create a test whose BODY asserts NAME can happen test
cannot: Create a test whose BODY asserts NAME cannot happen test
check: Check a set of properties against a set of random variables 100 times. test/check
d
defpass: Define a pass with the given NAME and BODY taking the specified ARGS. compiler/pass
dec!: Decrements the value described by ADDRESS by 1. control/setq
defsetq: Define the setq!/over! PATTERN with the replacement REPL. control/setq
defmacro: Define NAME to be the macro given by (lambda ARGS @BODY), with optional metadata at the start of BODY. core/base
defun: Define NAME to be the function given by (lambda ARGS @BODY), with optional metadata at the start of BODY. core/base
demand: Demand that particular CONDITION is upheld. core/demand
desire: Demand that particular CONDITION is upheld if debug assertions are on (-fstrict-checks). core/demand
do: Iterate over all given VARS, running STMTS without collecting the results. core/list
dolist: Iterate over all given VARS, running STMTS and collecting the results. core/list
drop: Remove the first N elements of the list XS. core/list
destructuring-bind: Match a single pattern against a single value, then evaluate the BODY. core/match
debug: Print the value X, then return it unmodified. core/method
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
defmethod: Add a case to the generic method NAME with the arguments LL and the body BODY. core/method
dominators: Build the dominators from nodes descended from ROOT. data/graph
disjoint?: Is the intersection of SETS empty? data/set
defstruct: Define a struct called NAME. data/struct
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
dofile lua/basic
debug lua/debug
deg lua/math
date lua/os
difftime lua/os
dump lua/string
defun-ffi: Define the external symbol NAME with the C type signature given by TYPEDECL. luajit/ffi
divide: Returns A divided by B. math/bignum
denominator: The rational’s denominator math/rational
dot: Compute the dot product of vectors X and Y. math/vector
describe: Create a group of tests, defined in BODY, which test NAME test
e
exported-vars: Generate a struct with all variables exported in the current module. compiler/helpers
eighth core/base
else: else is defined as having the value true. 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
exclude: Return a list with only the elements of XS that don’t match the predicate P. core/list
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
error!: Throw an error. core/prelude
exit!: Exit the program with the exit code CODE, and optionally, print the error message REASON. core/prelude
ends-with?: Determine whether STR ends with SUFFIX. core/string
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
exists?: Check if X exists, i. core/type
extend: Extend the association list LIST_ by inserting VAL, bound to the key KEY, overriding any previous value. data/alist
element?: Check if VAL is an element of SET. data/set
error lua/basic
expt lua/basic
exp lua/math
execute lua/os
exit lua/os
errno luajit/ffi
equals?: Returns true if A == B. math/bignum
even?: Is X an even number? math
echelon: Reduce the given MATRIX to row echelon form. math/matrix
f
flag?: Determine whether one of the given compiler FLAGS are set. compiler
flags: Get a list of all compiler flags. compiler
fix-symbol: Convert the quasi-quoted SYMBOL into a fully resolved one. compiler/nodes
fusion/add-rule!: Register a new fusion rule. compiler/optimise
fusion/defrule: Define a rewrite rule which maps FROM to TO. compiler/optimise
fifth core/base
first core/base
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-pairs: Iterate over TBL, binding VARS for each key value pair in BODY. core/base
fourth core/base
filter: Return a list with only the elements of XS that match the predicate P. core/list
find-index: Finds the first index in XS where the item matches the predicate P. core/list
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
for-each: Perform the set of actions BODY for all values in LST, binding the current value to VAR. core/list
function: Create a lambda which matches its arguments against the patterns defined in ARMS. core/match
fail!: Fail with the error message X, that is, exit the program immediately, without unwinding for an error handler. core/prelude
fast-struct: A variation of struct, which will not perform any coercing of the KEYS in entries. core/table
falsey?: Check whether X is falsey, that is, it is either false or does not exist. core/type
function?: Check whether X is a function. core/type
flip-bit!: Inverts the value of the bit in the bitset BS with the specified index BIT data/bitset
format: Output the string STR formatted against ARGS to the stream OUT. data/format
flush lua/io
floor lua/math
fmod lua/math
find lua/string
format lua/string
fill luajit/ffi
flush luajit/jit
forall: Check that PROP holds across all possible points. test/check
g
gensym: Create a unique symbol, suitable for using in macros core/base
groups-of: Splits the list XS into sub-lists of size NUM. core/list
get-bit: Returns the value of the bit in the bitset BS with the specified index BIT data/bitset
get-vertex: Get the corresponding vertex for this VALUE from the given GRAPH. data/graph
graph->dot: Convert GRAPH to a string in the DOT format, suitable for consumption with GraphViz. data/graph
graph? data/graph
get-idx lua/basic
getmetatable lua/basic
gethook lua/debug
getinfo lua/debug
getlocal lua/debug
getmetatable lua/debug
getregistry lua/debug
getupvalue lua/debug
getuservalue lua/debug
getenv lua/os
gsub lua/string
gc luajit/ffi
gcd: Compute the greatest common divisor of X and Y. math
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
help!: Display the help for the argument parser as defined in SPEC. io/argparse
huge lua/math
height: The height of this matrix. math/matrix
i
inc!: Increments the value described by ADDRESS by 1. control/setq
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-with: Bind the pair VAR of the form (name value), evaluating THEN if the value is truthy or ELSE if not. core/binders
init: Return the list XS with the last element removed. core/list
insert-nth!: Mutate the list LI, inserting VAL at IDX. core/list
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
iter-pairs: Iterate over TABLE with a function FUNC of the form (lambda (key val) ...) core/table
insert: Extend the association list ALIST by inserting VAL, bound to the key KEY. data/alist
insert!: Extend the association list ALIST in place by inserting VAL, bound to the key KEY. data/alist
intersects: Tests if two bitsets share any of the same set bits data/bitset
id: Return the value X unmodified. data/function
invokable?: Test if the expression X makes sense as something that can be applied to a set of arguments. data/function
insert: Build a copy of SET with VALs inserted. data/set
insert!: Insert VALS into SET. data/set
intersection: The set of values that occur in all the SETS. data/set
ipairs lua/basic
isyieldable lua/coroutine
input lua/io
insert lua/table
istype luajit/ffi
imaginary: The imaginary part of this complex number. math/complex
identity: Create the identity matrix with the given DIM. math/matrix
invert: Invert the provided MATRIX. math/matrix
is: Create a test whose BODY asserts NAME is true test
it: Create a test NAME which executes all expressions and assertions in BODY test
k
keys: Return the keys in the structure ST. core/table
key?: Check whether X is a key. core/type
l
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
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
lambda core/base
let* core/base
list: Return the list of variadic arguments given. core/base
let: Bind several variables (given in VARS), then evaluate BODY. core/binders
let*: Bind several variables (given in VARS), then evaluate BODY. core/binders
letrec: Bind several variables (given in VARS), which may be recursive. core/binders
loop: A general iteration helper. core/binders
last: Return the last element of the list XS. core/list
list->struct: Converts a LIST to a structure, mapping an index to the element in the list. core/table
list?: Check whether X is a list. core/type
len# lua/basic
lshift lua/bit32
lines lua/io
log lua/math
len lua/string
lower lua/string
len lua/utf8
lshift luajit/bit
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
lcm: Compute the lowest common multiple of X and Y. math
list->vector: Create a new vector from a list of values. math/vector
m
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?: Determine whether EXPR matches the provided pattern PTRN. compiler/pattern
map: Iterate over all the successive cars of XSS, producing a single list by applying FN to all of them. core/list
maybe-map: Iterate over all successive cars of XSS, producing a single list by applying FN to all of them, while discarding any nils. core/list
matches?: Test if the value X matches the pattern PT. core/match
merge: Merge all tables in STRUCTS together into a new table. core/table
make-bitset: Creates a new, empty bitset data/bitset
make-graph: Create a new, empty graph. data/graph
make-set: Create a new, empty set with the given HASH-FUNCTION. data/set
mod lua/basic
max lua/math
maxinteger lua/math
min lua/math
mininteger lua/math
modf lua/math
match lua/string
move lua/table
metatype luajit/ffi
modulo: Returns the remainder of A divided by B. math/bignum
multiply: Returns A multiplied by B. math/bignum
magnitude: Get the magnitude of complex number Z. math/complex
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
may: Create a group of tests defined in BODY whose names take the form <prefix> may NAME, and <test_name> test
n
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
n: Get the length of list X core/base
ninth core/base
not: Compute the logical negation of the expression EXPR. core/base
none: Check that no elements in XS match the predicate P. core/list
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
neq?: Compare X and Y for inequality deeply. core/method
number->string: Convert the number X into a string. core/prelude
nkeys: Return the number of keys in the structure ST. core/table
nil?: Check if X does not exist, i. core/type
number?: Check whether X is a number. core/type
next-clear-bit: Finds the next clear bit in the bitset BS after the index START. data/bitset
next-set-bit: Finds the next set bit in the bitset BS after the index START. data/bitset
next lua/basic
new luajit/ffi
new: Creates a new bignum from A. math/bignum
nan?: Is X equal to NaN? math
n*: Generalised numeric cross product. 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
nexpt: Generalised numeric exponentiation. math/numerics
nmod: Generalised numeric modulus. math/numerics
nnegate: Generalised numeric negation. math/numerics
nrecip: Generalised numeric reciprocal. math/numerics
nsign: Generalised numeric sign number. math/numerics
nsqrt: Generalised numeric square root. math/numerics
numerator: The rational’s numerator math/rational
norm: Compute the norm of vector X (i. math/vector
null: Create a vector with a magnitude of 0. math/vector
o
over!: Replace the value at ADDRESS according to FUN. control/setq
or: Return the logical or of values A and B, and, if present, the logical or of all the values in REST. core/base
open lua/io
output lua/io
offset lua/utf8
offsetof luajit/ffi
os luajit/ffi
off luajit/jit
on luajit/jit
os luajit/jit
odd?: Is X an odd number? math
p
pattern: Quote the provided pattern PTRN, suitable for matching with i matches?. compiler/pattern
progn: Group a series of expressions together. core/base
partition: Split XS based on the predicate P. core/list
pop-last!: Mutate the list XS, removing and returning its last element. core/list
prod: Return the product of all elements in XS. core/list
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
pretty: Pretty-print a value. core/method
print!: Print to standard output. core/prelude
printf: Print the formatted string FMT using ARGS. core/prelude
parse!: Parse ARGS using the argument parser defined in SPEC. io/argparse
pairs lua/basic
pcall lua/basic
print lua/basic
popen lua/io
pi lua/math
path lua/package
pack lua/table
power: Returns A to the power of B. math/bignum
polar->: Create a complex number from the given MAGNITUDE and ANGLE. math/complex
pred: Return the predecessor of the number X. math
pending: Create a test NAME whose BODY will not be run. test
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
range/get-source: Get the nearest source position of NODE compiler
reify: Return the definition of the symbol (not variable) X, returning nil if it’s not a top-level definition. compiler/resolve
reset: Establish a prompt, and evaluate BODY within that prompt. control/prompt
range: Build a list from :FROM to :TO, optionally passing by :BY. core/list
reduce: Accumulate the list XS using the binary function F and the zero element Z. core/list
remove-nth!: Mutate the list LI, removing the value at IDX and returning it. core/list
reverse: Reverse the list XS, using the accumulator ACC. core/list
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
rawequal lua/basic
rawget lua/basic
rawlen lua/basic
rawset lua/basic
require lua/basic
rol lua/bit32
ror lua/bit32
rshift lua/bit32
resume lua/coroutine
running lua/coroutine
random lua/math
randomseed lua/math
remove lua/os
rename lua/os
rep lua/string
reverse lua/string
remove lua/table
rol luajit/bit
ror luajit/bit
rshift luajit/bit
real: The real part of this complex number. math/complex
reduced-echelon: Reduce the given MATRIX to reduced row echelon form. math/matrix
rational: A rational number, represented as a tuple of numerator and denominator. math/rational
rational? math/rational
round: Round X, to the nearest integer. math
s
symbol->var: Extract the variable from the given SYMBOL. compiler/nodes
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
shift: Abort to the nearest reset, and evaluate BODY in a scope where the captured continuation is bound to K. control/prompt
setq!: Replace the value at ADDRESS with VALUE. control/setq
second core/base
seventh core/base
sixth core/base
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
splice: Unpack a list of arguments, returning all elements in XS. core/base
slicing-view: Return a mutable reference to the list LIST, with indexing offset (positively) by OFFSET. core/list
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!: 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
sum: Return the sum of all elements in XS. core/list
sprintf: Format the format string FMT using ARGS. core/prelude
string->number: Convert the string X into a number. core/prelude
split: Split the string given by TEXT in at most LIMIT components, which are delineated by the Lua pattern PATTERN. core/string
starts-with?: Determine whether STR starts with PREFIX. core/string
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->symbol: Convert the string X to a symbol. core/symbol
sym..: Concatenate all the symbols in XS. core/symbol
symbol->string: Convert the symbol X to a string. core/symbol
struct: Return the structure given by the list of pairs ENTRIES. core/table
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
string?: Check whether X is a string. core/type
symbol?: Check whether X is a symbol. core/type
struct->assoc: Convert the structure TBL into an association list. data/alist
set-bit!: Sets the bit in the bitset BS with the specified index BIT data/bitset
set-bit-value!: Sets the value of the bit in the bitset BS with the specified index BIT to VALUE data/bitset
self: Index X with KEY and invoke the resulting function with X and ARGS. data/function
slot?: Test whether SYMB is a slot. data/function
strongly-connected-components: Find all strong components from a GRAPH. data/graph
set->list: Convert SET to a list. data/set
set-of: Create the set containing VALUES with the default hash function. data/set
set? data/set
set-action: Set the appropriate key in DATA for ARG to VALUE. io/argparse
set-num-action: Set the appropriate key in DATA for ARG to VALUE, ensuring it is a number. io/argparse
select lua/basic
set-idx! lua/basic
setmetatable lua/basic
status lua/coroutine
sethook lua/debug
setlocal lua/debug
setmetatable lua/debug
setupvalue lua/debug
setuservalue lua/debug
stderr lua/io
stdin lua/io
stdout lua/io
sin lua/math
sqrt lua/math
setlocale lua/os
searchers lua/package
searchpath lua/package
sub lua/string
sort lua/table
sizeof luajit/ffi
string luajit/ffi
status luajit/jit
shl: Returns A shifted left by B. math/bignum
shl!: Shifts (modifies) A to the left by B. math/bignum
shr: Returns A shifted right by B. math/bignum
shr!: Shifts (modifies) A to the right by B. math/bignum
subtract: Returns A minus B. math/bignum
shl: Returns X shifted left by DISP. math/bit32
shr: Returns X shifted right by DISP. math/bit32
succ: Return the successor of the number X. math
section: Create a group of tests defined in BODY whose names take the form <prefix> NAME <test_name> test
t
traverse-node: Traverse NODE with VISITOR. compiler/nodes
traverse-nodes: Traverse a list of NODES, starting at IDX, using the specified VISITOR. compiler/nodes
try-var-lookup: Try to look up SYMBOL in the given SCOPE, using the active-scope if none given. compiler/resolve
tenth core/base
third core/base
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
traverse: An alias for map with the arguments XS and F flipped. core/list
trim: Remove whitespace from both sides of STR. core/string
table?: Check whether the value X is a table. core/type
type: Return the type of VAL. core/type
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
tonumber lua/basic
tostring lua/basic
type# lua/basic
tobit lua/bit32
tohex lua/bit32
traceback lua/debug
tmpfile lua/io
type lua/io
tan lua/math
tointeger lua/math
type lua/math
time lua/os
tmpname lua/os
tobit luajit/bit
tohex luajit/bit
typeinfo luajit/ffi
typeof luajit/ffi
tostring: Converts the bignum A to a string. math/bignum
tiny: Negative infinity math
tripping: Express that the composition of the functions F and G (in order! test/check
u
unless: Evaluate BODY if C is false, otherwise, evaluate nil. core/base
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
union: Set-like union of all the lists in XSS. core/list
update-struct: Create a new structure based of ST, setting the values given by the pairs in KEYS. core/table
union: The set of values that occur in any set in the SETS. data/set
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
upvalueid lua/debug
upvaluejoin lua/debug
ult lua/math
upper lua/string
unpack lua/table
unit: Convert the vector X into the unit vector. math/vector
v
val->node: Gets the node representation of the constant VALUE. compiler/nodes
var->symbol: Create a new symbol referencing the given VARIABLE. compiler/nodes
visit-node: Visit NODE with VISITOR. compiler/nodes
visit-nodes: Visit a list of NODES, starting at IDX, using the specified VISITOR. compiler/nodes
var-usage: Get usage information about the specified VAR. compiler/pass
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-value: Get the value of the given VARIABLE, returning nil if it is not a top level definition. compiler/resolve
values-list: Return multiple values, one per element in XS. core/base
values: Return the values in the structure ST. core/table
vertex? data/graph
version luajit/jit
version-num luajit/jit
valid-u-32: Returns whether the number N is a valid u32 integer. math/bit32
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 vector X. math/vector
vector? math/vector
w
when: Evaluate BODY when C is true, otherwise, evaluate nil. core/base
while: Iterate BODY while the expression CHECK evaluates to true. core/base
with: Bind the single variable VAR, then evaluate BODY. 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
with: Bind the single variable VAR, then evaluate BODY. core/binders
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
wrap lua/coroutine
write lua/io
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
x
xpcall lua/basic
y
yield lua/coroutine