The Urn Logo

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 views 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 nils. 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 views 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