The Urn Logo
Try online GitLab GitHub

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-edge!: Add an edge FROM one vertex TO another. data/graph
  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
  add-help!: Add a help argument to SPEC. 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
  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
  car: Return the first element present in the list X. core/list
  cars core/list
  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
  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
  load lua/basic
  loadfile lua/basic
  lshift lua/bit32
  lines lua/io
  log lua/math
  loaded lua/package
  loadlib lua/package
  len lua/string
  lower lua/string
  len lua/utf8
  lshift luajit/bit
  load luajit/ffi
  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
  negate: Returns A with the sign inverted. math/bignum
  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 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
  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
  preload 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
  read lua/io
  rad lua/math
  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

Tutorial

Reference

Recent News

All libraries