Core API

Returns the remainder of dividend / divisor.

(% 10 3) # -> 1
(% -10 3) # -> -1
(% 10 -3) # -> 1
(% -10 -3) # -> -1
(% 1.4 1) # -> 0.4
(% -1.4 1) # -> -0.4
(% 1.4 1) # -> 0.4
(% -1.4 1) # -> -0.4
(% -1.4 0) # -> -nan
(% -1.4 0) # -> -nan

Shorthand for (set x (% x n)).

(var x 10) # -> 10
(%= x 3) # -> 1
x # -> 1

Returns the product of all elements in xs. If xs is empty, returns 1.

(*) # -> 1
(* 10) # -> 10
(* 10 20) # -> 200
(* 1 2 3 4 5 6 7) #-> 5040

# Can take product of array with splice, but 'product' is better
(* ;(range 1 20)) #-> 1.21645e+17
(product (range 1 20)) #-> 1.21645e+17

Shorthand for (set x (\* x n)).

(var x 100) # -> 100
x # -> 100
(*= x 10) # -> 1000
x # -> 1000

Dynamic bindings that will contain command line arguments at program start.

Bound to the name of the currently compiling file.

Enables a built in debugger on errors and other useful features for debugging in a repl.

Optional namespace prefix to add to keywords declared with `defdyn`.
 Use this to prevent keyword collisions between dynamic bindings.

Whether or not to colorize documentation printed with `doc-format`.

Width in columns to print documentation printed with `doc-format`.

Where error printing prints output to.

Whether or not to turn on error coloring in stacktraces and other error messages.

Name of the interpreter executable used to execute this program. Corresponds to `argv[0]` in the call to
 `int main(int argc, char **argv);`.

When set, will cause the current context to complete. Can be set to exit from repl (or file), for example.

Set the return value from `run-context` upon an exit. By default, `run-context` will return nil.

 Current native library for ffi/bind and other settings

The current lint error level. The error level is the lint level at which compilation will exit with an error and not continue.

A table of keyword alias to numbers denoting a lint level. Can be used to provided custom aliases for numeric lint levels.

The current lint warning level. The warning level is the lint level at which and error will be printed but compilation will continue as normal.

Inside a macro, is bound to the source form that invoked the macro

Bound to an array of lint messages that will be reported by the compiler inside a macro.
To indicate an error or warning, a macro author should use `maclintf`.

Where normal print functions print output to.

The implicit base grammar used when compiling PEGs. Any undefined keywords
found when compiling a peg will use lookup in this table (if defined).

Format specifier for the `pp` function

Path to profile file loaded when starting up the repl.

When set, allow dynamically rebinding top level defs. Will slow generated code and is intended to be used for development.

Path of directory to load system modules from.

Returns the sum of all xs. xs must be integers or real numbers only. If xs is empty, return 0.

(+) # -> 0
(+ 10) # -> 10
(+ 1 2) # -> 3
(+ 1.4 -4.5) # -> -3.1
(+ 1 2 3 4 5 6 7 8 9 10) # -> 55

# Splice can be used to sum arrays, but 'sum' is better
(+ ;(range 101)) # -> 5050
(sum (range 101)) # -> 5050

# Janet can add types that support the :+ or :r+ method
(+ (int/s64 "10") 10) # -> <core/s64 20>

# Bad types give errors
(+ nil 10) # -> error: could not find method :+ for nil, or :r+ for 10

Increments the var x by 1.

Increments the var x by n.

(var x 100) # -> 100
x # -> 100
(+= x 10) # -> 110
x # -> 110

Returns the difference of xs. If xs is empty, returns 0. If xs has one element, returns the negative value of that element. Otherwise, returns the first element in xs minus the sum of the rest of the elements.

(-) # -> 0
(- 10) # -> -10
(- 1 2) # -> -1
(+ 1.4 -4.5) # -> 5.9

# Equivalent to (- first (+ ;rest))
(- 1 2 3 4 5 6 7 8 9 10) # -> -53

# Janet can subtract types that support the :- or :r- method
(- (int/s64 "10") 10) # -> <core/s64 0>

Decrements the var x by 1.

Decrements the var x by n.

(var x 10) # -> 10
(-= x 20) # -> -10
x # -> -10

Threading macro. Inserts x as the second value in the first form
in `forms`, and inserts the modified first form into the second form
in the same manner, and so on. Useful for expressing pipelines of data.

Threading macro. Inserts x as the last value in the first form
in `forms`, and inserts the modified first form into the second form
in the same manner, and so on. Useful for expressing pipelines of data.

Short circuit threading macro. Inserts x as the second value in the first form
in `forms`, and inserts the modified first form into the second form
in the same manner, and so on. The pipeline will return nil
if an intermediate value is nil.
Useful for expressing pipelines of data.

Short circuit threading macro. Inserts x as the last value in the first form
in `forms`, and inserts the modified first form into the second form
in the same manner, and so on. The pipeline will return nil
if an intermediate value is nil.
Useful for expressing pipelines of data.

(/ & xs)

Returns the quotient of xs. If xs is empty, returns 1. If xs has one value x, returns the reciprocal of x. Otherwise return the first value of xs repeatedly divided by the remaining values.

(/= x n)

Shorthand for (set x (/ x n)).

Check if xs is in ascending order. Returns a boolean.

Check if xs is in non-descending order. Returns a boolean.

Check if all values in xs are equal. Returns a boolean.

Check if xs is in descending order. Returns a boolean.

Check if xs is in non-ascending order. Returns a boolean.

Check if x is an abstract type.

Similar to `reduce`, but accumulates intermediate values into an array.
The last element in the array is what would be the return value from `reduce`.
The `init` value is not added to the array (the return value will have the same
number of elements as `ind`).
Returns a new array.

The 2-argument version of `accumulate` that does not take an initialization value.
The first value in `ind` will be added to the array as is, so the length of the
return value will be `(length ind)`.

Returns true if `(pred item)` returns a truthy value for every item in `xs`.
Otherwise, returns the first falsey `(pred item)` result encountered.
Returns true if `xs` is empty.

Get all symbols available in an environment. Defaults to the current
fiber's environment. If `local` is truthy, will not show inherited bindings
(from prototype tables).

Get all dynamic bindings in an environment. Defaults to the current
fiber's environment. If `local` is truthy, will not show inherited bindings
(from prototype tables).

Evaluates to the last argument if all preceding elements are truthy, otherwise
evaluates to the first falsey argument.

Returns the first truthy value in `ind`, otherwise nil.

Applies a function to a variable number of arguments. Each element in args is used as an argument to f, except the last element in args, which is expected to be an array-like. Each element in this last argument is then also pushed as an argument to f. For example:

	(apply + 1000 (range 10))

sums the first 10 integers and 1000.

(apply + (range 10)) # -> 45
(apply + []) # -> 0
(apply + 1 2 3 4 5 6 7 [8 9 10]) # -> 55
(apply + 1 2 3 4 5 6 7 8 9 10) # -> error: expected array|tuple, got number 

# Can also be used to call macros like functions.
# Will return the macro expanded code of the original macro.
(apply for 'x 0 10 ['(print x)])
# -> (do (var _000000 0) (def _000001 10) (while ...

Create a new array that contains items. Returns the new array.

Empties an array, setting it's count to 0 but does not free the backing capacity. Returns the modified array.

Concatenates a variable number of arrays (and tuples) into the first argument, which must be an array. If any of the parts are arrays or tuples, their elements will be inserted into the array. Otherwise, each part in `parts` will be appended to `arr` in order. Return the modified array `arr`.

Ensures that the memory backing the array is large enough for `capacity` items at the given rate of growth. `capacity` and `growth` must be integers. If the backing capacity is already enough, then this function does nothing. Otherwise, the backing memory will be reallocated so that there is enough space.

Replace all elements of an array with `value` (defaulting to nil) without changing the length of the array. Returns the modified array.

Insert all `xs` into array `arr` at index `at`. `at` should be an integer between 0 and the length of the array. A negative value for `at` will index backwards from the end of the array, such that inserting at -1 appends to the array. Returns the array.

Creates a new empty array with a pre-allocated capacity. The same as `(array)` but can be more efficient if the maximum size of an array is known.

(def arr (array/new 100)) # -> @[]

# Now we can fill up the array without triggering a resize
(for i 0 100
  (put arr i i))

Creates a new array of `count` elements, all set to `value`, which defaults to nil. Returns the new array.

Returns the last element of the array. Does not modify the array.

Remove the last element of the array and return it. If the array is empty, will return nil. Modifies the input array.

Insert an element in the end of an array. Modifies the input array and returns it.

Remove up to `n` elements starting at index `at` in array `arr`. `at` can index from the end of the array with a negative index, and `n` must be a non-negative integer. By default, `n` is 1. Returns the array.

Takes a slice of array or tuple from `start` to `end`. The range is half open, [start, end). Indexes can also be negative, indicating indexing from the end of the array. By default, `start` is 0 and `end` is the length of the array. Note that index -1 is synonymous with index `(length arrtup)` to allow a full negative slice range. Returns a new array.

Set the backing capacity of an array to its current length. Returns the modified array.

Check if x is an array.

Thread forms together, replacing `as` in `forms` with the value
of the previous form. The first form is the value x. Returns the
last value.

Use a function or macro literal `f` as a macro. This lets
any function be used as a macro. Inside a quasiquote, the
idiom `(as-macro ,my-custom-macro arg1 arg2...)` can be used
to avoid unwanted variable capture of `my-custom-macro`.

Thread forms together, replacing `as` in `forms` with the value
of the previous form. The first form is the value x. If any
intermediate values are falsey, return nil; otherwise, returns the
last value.

Returns a new function that is the compiled result of the assembly.
The syntax for the assembly can be found on the Janet website, and should correspond
to the return value of disasm. Will throw an
error on invalid assembly.

Throw an error if x is not truthy. Will not evaluate `err` if x is truthy.

Default handler for a compile error.

Default handler for a parse error.

Returns the bit-wise and of all values in xs. Each x in xs must be an integer.

Returns the value of x bit shifted left by the sum of all values in shifts. x and each element in shift must be an integer.

Returns the bit-wise inverse of integer x.

Check if x is a boolean.

Returns the bit-wise or of all values in xs. Each x in xs must be an integer.

Returns the value of x bit shifted right by the sum of all values in shifts. x and each element in shift must be an integer.

Returns the value of x bit shifted right by the sum of all values in shifts. x and each element in shift must be an integer. The sign of x is not preserved, so for positive shifts the return value will always be positive.

Creates a buffer by concatenating the elements of `xs` together. If an element is not a byte sequence, it is converted to bytes via `describe`. Returns the new buffer.

Gets the bit at the given bit-index. Returns true if the bit is set, false if not.

Clears the bit at the given bit-index. Returns the buffer.

Sets the bit at the given bit-index. Returns the buffer.

Toggles the bit at the given bit index in buffer. Returns the buffer.

Insert the contents of `src` into `dest`. Can optionally take indices that indicate which part of `src` to copy into which part of `dest`. Indices can be negative in order to index from the end of `src` or `dest`. Returns `dest`.

Sets the size of a buffer to 0 and empties it. The buffer retains its memory so it can be efficiently refilled. Returns the modified buffer.

Fill up a buffer with bytes, defaulting to 0s. Does not change the buffer's length. Returns the modified buffer.

Snprintf like functionality for printing values into a buffer. Returns the modified buffer.

Creates a new, empty buffer with enough backing memory for `capacity` bytes. Returns a new buffer of length 0.

Creates a new buffer of length `count` filled with `byte`. By default, `byte` is 0. Returns the new buffer.

Removes the last `n` bytes from the buffer. Returns the modified buffer.

Push both individual bytes and byte sequences to a buffer. For each x in xs, push the byte if x is an integer, otherwise push the bytesequence to the buffer. Thus, this function behaves like both `buffer/push-string` and `buffer/push-byte`. Returns the modified buffer. Will throw an error if the buffer overflows.

Same as buffer/push, but inserts new data at index `index`.

Append bytes to a buffer. Will expand the buffer as necessary. Returns the modified buffer. Will throw an error if the buffer overflows.

Push byte sequences onto the end of a buffer. Will accept any of strings, keywords, symbols, and buffers. Returns the modified buffer. Will throw an error if the buffer overflows.

Append machine words to a buffer. The 4 bytes of the integer are appended in twos complement, little endian order, unsigned for all x. Returns the modified buffer. Will throw an error if the buffer overflows.

Takes a slice of a byte sequence from `start` to `end`. The range is half open, [start, end). Indexes can also be negative, indicating indexing from the end of the end of the array. By default, `start` is 0 and `end` is the length of the buffer. Returns a new buffer.

Set the backing capacity of the buffer to the current length of the buffer. Returns the modified buffer.

Check if x is a buffer.

Returns the bit-wise xor of all values in xs. Each in xs must be an integer.

Check if x is a string, symbol, keyword, or buffer.

Resume a fiber but have it immediately raise an error. This lets a programmer unwind a pending fiber. Returns the same result as resume.

Select the body that equals the dispatch value. When `pairs`
has an odd number of elements, the last is the default expression.
If no match is found, returns nil.

Check if x a cfunction.

Convert a string of length 1 to its byte (ascii) value at compile time.

Entrance for the Janet CLI tool. Call this function with the command line
arguments as an array or tuple of strings to invoke the CLI interface.

Returns -1 if x is strictly less than y, 1 if y is strictly greater than x, and 0 otherwise. To return 0, x and y must be the exact same type.

Ignores the body of the comment.

Takes multiple functions and returns a function that is the composition
of those functions.

Polymorphic compare. Returns -1, 0, 1 for x < y, x = y, x > y respectively.
Differs from the primitive comparators in that it first checks to
see whether either x or y implement a `compare` method which can
compare x and y. If so, it uses that method. If not, it
delegates to the primitive comparators.

Equivalent of `<` but using polymorphic `compare` instead of primitive comparator.

Equivalent of `<=` but using polymorphic `compare` instead of primitive comparator.

Equivalent of `=` but using polymorphic `compare` instead of primitive comparator.

Equivalent of `>` but using polymorphic `compare` instead of primitive comparator.

Equivalent of `>=` but using polymorphic `compare` instead of primitive comparator.

Check the condition `cnd` at compile time -- if truthy, compile `tru`, else compile `fals`.

Compiles an Abstract Syntax Tree (ast) into a function. Pair the compile function with parsing functionality to implement eval. Returns a new function and does not modify ast. Returns an error struct with keys :line, :column, and :error if compilation fails. If a `lints` array is given, linting messages will be appended to the array. Each message will be a tuple of the form `(level line col message)`.

Returns a function that is the complement to the argument.

Evals x at compile time and returns the result. Similar to a top level unquote.

Check the condition `cnd` at compile time -- if truthy, compile `(upscope ;body)`, else compile nil.

Evaluates conditions sequentially until the first true condition
is found, and then executes the corresponding body. If there are an
odd number of forms, and no forms are matched, the last expression
is executed. If there are no matches, returns nil.

A wrapper for making fibers that may yield multiple values (coroutine). Same as `(fiber/new (fn [] ;body) :yi)`.

Count the number of items in `ind` for which `(pred item)`
is true.

Get the current environment table. Same as `(fiber/getenv (fiber/current))`. If `n`
is provided, gets the nth prototype of the environment table.

Throws a debug signal that can be caught by a parent fiber and used to inspect the running state of the current fiber. Returns the value passed in by resume.

Gets all values currently on the fiber's argument stack. Normally, this should be empty unless the fiber signals while pushing arguments to make a function call. Returns a new array.

Sets a breakpoint in `source` at a given line and column. Will throw an error if the breakpoint location cannot be found. For example

	(debug/break "core.janet" 10 4)

will set a breakpoint at line 10, 4th column of the file core.janet.

Set a breakpoint in a given function. pc is an optional offset, which is in bytecode instructions. fun is a function value. Will throw an error if the offset is too large or negative.

Returns an array of all child fibers from a root fiber. This function is useful when a fiber signals or errors to an ancestor fiber. Using this function, the fiber handling the error can see which fiber raised the signal. This function should be used mostly for debugging purposes.

Gets information about the stack as an array of tables. Each table in the array contains information about a stack frame. The top-most, current stack frame is the first table in the array, and the bottom-most stack frame is the last value. Each stack frame contains some of the following attributes:

* :c - true if the stack frame is a c function invocation

* :source-column - the current source column of the stack frame

* :function - the function that the stack frame represents

* :source-line - the current source line of the stack frame

* :name - the human-friendly name of the function

* :pc - integer indicating the location of the program counter

* :source - string with the file path or other identifier for the source code

* :slots - array of all values in each slot

* :tail - boolean indicating a tail call

Prints a nice looking stacktrace for a fiber. Can optionally provide an error value to print the stack trace with. If `err` is nil or not provided, and no prefix is given, will skip the error line. Returns the fiber.

Run a fiber for one virtual instruction of the Janet machine. Can optionally pass in a value that will be passed as the resuming value. Returns the signal value, which will usually be nil, as breakpoints raise nil signals.

Remove a breakpoint with a source key at a given line and column. Will throw an error if the breakpoint cannot be found.

Unset a breakpoint set with debug/fbreak.

Run a repl-based debugger on a fiber. Optionally pass in a level to differentiate nested debuggers.

An environment that contains dot prefixed functions for debugging.

Create a function that can be passed to `run-context`'s `:on-status` argument that will drop into a debugger on errors. The debugger will only start on abnormal signals if the env table has the `:debug` dyn set to a truthy value.

Returns x - 1.

Like `not=`, but mutable types (arrays, tables, buffers) are considered
equal if they have identical structure. Much slower than `not=`.

Like `=`, but mutable types (arrays, tables, buffers) are considered
equal if they have identical structure. Much slower than `=`.

Define a private value that will not be exported.

# In a file module.janet
(def- private-thing :encapsulated)
(def public-thing :exposed)

# In a file main.janet
(import module)

module/private-thing # -> Unknown symbol
module/public-thing # -> :exposed

# Same as normal def with :private metadata
(def :private x private-thing :encapsulated)

Define a default value for an optional argument.
Expands to `(def sym (if (= nil sym) val sym))`.

The default grammar used for pegs. This grammar defines several common patterns
that should make it easier to write more complex patterns.

Define an alias for a keyword that is used as a dynamic binding. The
alias is a normal, lexically scoped binding that can be used instead of
a keyword to prevent typos. `defdyn` does not set dynamic bindings or otherwise
replace `dyn` and `setdyn`. The alias _must_ start and end with the `*` character, usually
called "earmuffs".

Run `form` unconditionally after `body`, even if the body throws an error.
Will also run `form` if a user signal 0-4 is received.

# Evaluates to 6 after printing "scope left!"
(defer (print "scope left!")
  (+ 1 2 3))

# cleanup will always be called, even if there is a failure
(defer (cleanup)
  (step-1)
  (step-2)
  (if (< 0.1 (math/random)) (error "failure"))
  (step-3))

Dynamically create a global def.

Define a macro.

Define a private macro that will not be exported.

Define a function. Equivalent to `(def name (fn name [args] ...))`.

(defn simple
  [x]
  (print (+ x 1)))

(simple 10) # -> 11

(defn long-body
  [y]
  (print y)
  (print (+ y 1))
  (print (+ y 2))
  (+ y 3))

(defn with-docstring
  "This function has a docstring"
  []
  (print "hello!"))

(defn with-tags
  :tag1 :tag2 :private
  "Also has a docstring and a variadic argument 'more'!"
  [x y z & more]
  [x y z more])

(with-tags 1 2) # raises arity error
(with-tags 1 2 3) # -> (1 2 3 ())
(with-tags 1 2 3 4) # -> (1 2 3 (4))
(with-tags 1 2 3 4 5) # -> (1 2 3 (4 5))

# Tags (and other metadata) are (usually) visible in the environment.
(dyn 'with-tags) # -> @{:tag2 true :value <function with-tags> :doc "(with-tags x y z & more)\n\nAlso has a docstring..." :source-map ("repl" 4 1) :tag1 true :private true}

Define a private function that will not be exported.

# In a file module.janet
(defn- not-exposed-fn
  [x]
  (+ x x))
(not-exposed-fn 10) # -> 20

# In a file main.janet
(import module)

(module/not-exposed-fn 10) # -> Unknown symbol error

# Same as
(defn not-exposed-fn
  :private
  [x]
  (+ x x))

Lazily evaluate a series of expressions. Returns a function that returns the result of the last expression. Will only evaluate the body once, and then memoizes the result.

Returns a string that is a human-readable description of `x`. For recursive data structures, the string returned contains a pointer value from which the identity of `x` can be determined.

Check if x is a table or struct.

Returns assembly that could be used to compile the given function. func must be a function, not a c function. Will throw on error on a badly typed argument. If given a field name, will only return that part of the function assembly. Possible fields are:

* :arity - number of required and optional arguments.
* :min-arity - minimum number of arguments function can be called with.
* :max-arity - maximum number of arguments function can be called with.
* :vararg - true if function can take a variable number of arguments.
* :bytecode - array of parsed bytecode instructions. Each instruction is a tuple.
* :source - name of source file that this function was compiled from.
* :name - name of function.
* :slotcount - how many virtual registers, or slots, this function uses. Corresponds to stack space used by function.
* :symbolmap - all symbols and their slots.
* :constants - an array of constants referenced by this function.
* :sourcemap - a mapping of each bytecode instruction to a line and column in the source file.
* :environments - an internal mapping of which enclosing functions are referenced for bindings.
* :defs - other function definitions that this function may instantiate.

Returns an array of the deduplicated values in `xs`.

Shows documentation for the given symbol, or can show a list of available bindings.
If `sym` is a symbol, will look for documentation for that symbol. If `sym` is a string
or is not provided, will show all lexical and dynamic bindings in the current environment
containing that string (all bindings will be shown if no string is given).

Get the documentation for a symbol in a given environment. Function form of `doc`.

Reformat a docstring to wrap a certain width. Docstrings can either be plaintext
or a subset of markdown. This allows a long single line of prose or formatted text to be
a well-formed docstring. Returns a buffer containing the formatted text.

Searches all loaded modules in module/cache for a given binding and prints out its documentation.
This does a search by value instead of by name. Returns nil.

Evaluate a file, file path, or stream and return the resulting environment. :env, :expander,
:source, :evaluator, :read, and :parser are passed through to the underlying
`run-context` call. If `exit` is true, any top level errors will trigger a
call to `(os/exit 1)` after printing the error.

Drop the first n elements in an indexed or bytes type. Returns a new tuple or string
instance, respectively.

Same as `(drop-while (complement pred) ind)`.

Given a predicate, remove elements from an indexed or bytes type that satisfy
the predicate, and abort on first failure. Returns a new tuple or string, respectively.

Get a dynamic binding. Returns the default value (or nil) if no binding found.

Loop over each value in `ds`. Returns nil.

Loop over each key in `ds`. Returns nil.

Loop over each (key, value) pair in `ds`. Returns nil.

Run `form` after `body` in the case that body terminates abnormally (an error or user signal 0-4).
Otherwise, return last form in `body`.

# Half of the time, return "ok", the other
# half of the time, print there was an error and throw "oops".
(edefer (print "there was an error")
  (if (< (math/random) 0.5)
    (error "oops")
    "ok"))

Flush `(dyn :err stderr)` if it is a file, otherwise do nothing.

Check if xs is empty.

Creates a forward lookup table for unmarshalling from an environment. To create a reverse lookup table, use the invert function to swap keys and values in the returned table.

Same as `prin`, but uses `(dyn :err stderr)` instead of `(dyn :out stdout)`.

Like `eprintf` but with no trailing newline.

Same as `print`, but uses `(dyn :err stderr)` instead of `(dyn :out stdout)`.

Prints output formatted as if with `(string/format fmt ;xs)` to `(dyn :err stderr)` with a trailing newline.

Throws an error e that can be caught and handled by a parent fiber.

A combination of `error` and `string/format`. Equivalent to `(error (string/format fmt ;args))`.

Acquire a lock such that this operating system thread is the only thread with access to this resource. This will block this entire thread until the lock becomes available, and will not yield to other fibers on this system thread.

Acquire a read lock an a read-write lock.

Acquire a write lock on a read-write lock.

Call a function asynchronously.
Returns a fiber that is scheduled to run the function.

Cancel a suspended fiber in the event loop. Differs from cancel in that it returns the canceled fiber immediately.

Get the number of items a channel will store before blocking writers.

Create a new channel. capacity is the number of values to queue before blocking writers, defaults to 0 if not provided. Returns a new channel.

Close a channel. A closed channel will cause all pending reads and writes to return nil. Returns the channel.

Same as ev/read, but will not return early if less than n bytes are available. If an end of stream is reached, will also return early with the collected bytes.

Close a stream. This should be the same as calling (:close stream) for all streams.

Get the number of items currently waiting in a channel.

Set a deadline for a fiber `tocheck`. If `tocheck` is not finished after `sec` seconds, `tocancel` will be canceled as with `ev/cancel`. If `tocancel` and `tocheck` are not given, they default to `(fiber/root)` and `(fiber/current)` respectively. Returns `tocancel`.

Run some code in a new thread. Suspends the current fiber until the thread is complete, and
evaluates to nil.

Check if a channel is full or not.

Run a number of fibers in parallel on the event loop, and join when they complete.
Returns the gathered results in an array.

Write a value to a channel, suspending the current fiber if the channel is full. Returns the channel if the write succeeded, nil otherwise.

Send a message to the current supervisor channel if there is one. The message will be a tuple of all of the arguments combined into a single message, where the first element is tag. By convention, tag should be a keyword indicating the type of message. Returns nil.

Put a fiber on the event loop to be resumed later. If a function is used, it is wrapped with `fiber/new` first. Optionally pass a value to resume with, otherwise resumes with nil. Returns the fiber. An optional `core/channel` can be provided as a supervisor. When various events occur in the newly scheduled fiber, an event will be pushed to the supervisor. If not provided, the new fiber will inherit the current supervisor.

Create a new lock to coordinate threads.

Read up to n bytes into a buffer asynchronously from a stream. `n` can also be the keyword `:all` to read into the buffer until end of stream. Optionally provide a buffer to write into as well as a timeout in seconds after which to cancel the operation and raise an error. Returns the buffer if the read was successful or nil if end-of-stream reached. Will raise an error if there are problems with the IO operation.

Release a lock such that other threads may acquire it.

Release a read lock on a read-write lock

Release a write lock on a read-write lock

Similar to ev/select, but will try clauses in a random order for fairness.

Create a new read-write lock to coordinate threads.

Block until the first of several channel operations occur. Returns a tuple of the form [:give chan], [:take chan x], or [:close chan], where a :give tuple is the result of a write and :take tuple is the result of a read. Each clause must be either a channel (for a channel take operation) or a tuple [channel x] for a channel give operation. Operations are tried in order, such that the first clauses will take precedence over later clauses. Both and give and take operations can return a [:close chan] tuple, which indicates that the specified channel was closed while waiting, or that the channel was already closed.

Suspend the current fiber for sec seconds without blocking the event loop.

Run some code in a new fiber. This is shorthand for `(ev/go (fn [] ;body))`.

Run some code in a new thread. Like `ev/do-thread`, but returns nil immediately.

Read from a channel, suspending the current fiber if no value is available.

Run `main` in a new operating system thread, optionally passing `value` to resume with. The parameter `main` can either be a fiber, or a function that accepts 0 or 1 arguments. Unlike `ev/go`, this function will suspend the current fiber until the thread is complete. If you want to run the thread without waiting for a result, pass the `:n` flag to return nil immediately. Otherwise, returns nil. Available flags:

* `:n` - return immediately
* `:t` - set the task-id of the new thread to value. The task-id is passed in messages to the supervisor channel.
* `:a` - don't copy abstract registry to new thread (performance optimization)
* `:c` - don't copy cfunction registry to new thread (performance optimization)

Create a threaded channel. A threaded channel is a channel that can be shared between threads and used to communicate between any number of operating system threads.

Run a body of code with a deadline, such that if the code does not complete before
the deadline is up, it will be canceled.

Write data to a stream, suspending the current fiber until the write completes. Takes an optional timeout in seconds, after which will return nil. Returns nil, or raises an error if the write failed.

Evaluates a form in the current environment. If more control over the
environment is needed, use `run-context`.

(eval '(+ 1 2 3)) # -> 6
(eval '(error :oops)) # -> raises error :oops
(eval '(+ nil nil)) # -> raises error

Evaluates a string in the current environment. If more control over the
environment is needed, use `run-context`.

(eval-string "(+ 1 2 3 4)") # -> 10
(eval-string ")") # -> parse error
(eval-string "(bloop)") # -> compile error
(eval-string "(+ nil nil)") # -> runtime error

Check if x is even.

Returns true if each value in `ind` is truthy, otherwise returns the first
falsey value.

Returns the most extreme value in `args` based on the function `order`.
`order` should take two values and return true or false (a comparison).
Returns nil if `args` is empty.

Check if x is false.

Get the align of an ffi type in bytes.

Call a raw pointer as a function pointer. The function signature specifies how Janet values in `args` are converted to native machine types.

Free a native object. Dereferencing pointers to symbols in the object will have undefined behavior after freeing.

Set the path of the dynamic library to implictly bind, as well as other global state for ease of creating native bindings.

Generate bindings for native functions in a convenient manner.

Free memory allocated with `ffi/malloc`. Returns nil.

Create an abstract type that can be used as the pointer argument to `ffi/call`. The content of `bytes` is architecture specific machine code that will be copied into executable memory.

Lookup a symbol from a native object. All symbol lookups will return a raw pointer if the symbol is found, else nil.

Allocates memory directly using the janet memory allocator. Memory allocated in this way must be freed manually! Returns a raw pointer, or nil if size = 0.

Load a shared object or dll from the given path, and do not extract or run any code from it. This is different than `native`, which will run initialization code to get a module table. If `path` is nil, opens the current running binary. Returns a `core/native`.

Create a buffer from a pointer. The underlying memory of the buffer will not be reallocated or freed by the garbage collector, allowing unmanaged, mutable memory to be manipulated with buffer functions. Attempts to resize or extend the buffer beyond its initial capacity will raise an error. As with many FFI functions, this is memory unsafe and can potentially allow out of bounds memory access. Returns a new buffer.

Parse a native struct out of a buffer and convert it to normal Janet data structures. This function is the inverse of `ffi/write`. `bytes` can also be a raw pointer, although this is unsafe.

Create a function signature object that can be used to make calls with raw function pointers.

Get the size of an ffi type in bytes.

Create a struct type definition that can be used to pass structs into native functions. 

Get a native function pointer that can be used as a callback and passed to C libraries. This callback trampoline has the signature `void trampoline(void \*ctx, void \*userdata)` in the given calling convention. This is the only function signature supported. It is up to the programmer to ensure that the `userdata` argument contains a janet function the will be called with one argument, `ctx` which is an opaque pointer. This pointer can be further inspected with `ffi/read`.

Append a native type to a buffer such as it would appear in memory. This can be used to pass pointers to structs in the ffi, or send C/C++/native structs over the network or to files. Returns a modifed buffer or a new buffer if one is not supplied.

A wrapper for making fibers. Same as `(fiber/new (fn [] ;body) flags)`.

Check if a fiber is finished and cannot be resumed.

Returns the currently running fiber.

Gets the environment for a fiber. Returns nil if no such table is set yet.

Get the last value returned or signaled from the fiber.

Gets the maximum stack size in janet values allowed for a fiber. While memory for the fiber's stack is not allocated up front, the fiber will not allocated more than this amount and will throw a stack-overflow error if more memory is needed. 

Create a new fiber with function body func. Can optionally take a set of signals to block from the current parent fiber when called. The mask is specified as a keyword where each character is used to indicate a signal to block. If the ev module is enabled, and this fiber is used as an argument to `ev/go`, these "blocked" signals will result in messages being sent to the supervisor channel. The default sigmask is :y. For example,

 (fiber/new myfun :e123)

blocks error signals and user signals 1, 2 and 3. The signals are as follows:

* :a - block all signals
* :d - block debug signals
* :e - block error signals
* :t - block termination signals: error + user[0-4]
* :u - block user signals
* :y - block yield signals
* :0-9 - block a specific user signal

The sigmask argument also can take environment flags. If any mutually exclusive flags are present, the last flag takes precedence.

* :i - inherit the environment from the current fiber
* :p - the environment table's prototype is the current environment table

Returns the current root fiber. The root fiber is the oldest ancestor that does not have a parent.

Sets the environment table for a fiber. Set to nil to remove the current environment.

Sets the maximum stack size in janet values for a fiber. By default, the maximum stack size is usually 8192.

Get the status of a fiber. The status will be one of:

* :dead - the fiber has finished
* :error - the fiber has errored out
* :debug - the fiber is suspended in debug mode
* :pending - the fiber has been yielded
* :user(0-9) - the fiber is suspended by a user signal
* :alive - the fiber is currently running and cannot be resumed
* :new - the fiber has just been created and not yet run

Check if x is a fiber.

Close a file and release all related resources. When you are done reading a file, close it to prevent a resource leak and let other processes read the file.

Flush any buffered bytes to the file system. In most files, writes are buffered for efficiency reasons. Returns the file handle.

Open a file. `path` is an absolute or relative path, and `mode` is a set of flags indicating the mode to open the file in. `mode` is a keyword where each character represents a flag. If the file cannot be opened, returns nil, otherwise returns the new file handle. Mode flags:

* r - allow reading from the file

* w - allow writing to the file

* a - append to the file

Following one of the initial flags, 0 or more of the following flags can be appended:

* b - open the file in binary mode (rather than text mode)

* + - append to the file instead of overwriting it

* n - error if the file cannot be opened instead of returning nil

Read a number of bytes from a file `f` into a buffer. A buffer `buf` can be provided as an optional third argument, otherwise a new buffer is created. `what` can either be an integer or a keyword. Returns the buffer with file contents. Values for `what`:

* :all - read the whole file

* :line - read up to and including the next newline character

* n (integer) - read up to n bytes from the file

Jump to a relative location in the file `f`. `whence` must be one of:

* :cur - jump relative to the current file location

* :set - jump relative to the beginning of the file

* :end - jump relative to the end of the file

By default, `whence` is :cur. Optionally a value `n` may be passed for the relative number of bytes to seek in the file. `n` may be a real number to handle large files of more than 4GB. Returns the file handle.

Get the current value of the file position for file `f`.

Open an anonymous temporary file that is removed on close. Raises an error on failure.

Writes to a file. 'bytes' must be string, buffer, or symbol. Returns the file.

Given a predicate, take only elements from an array or tuple for
which `(pred element)` is truthy. Returns a new array.

Find the first value in an indexed collection that satisfies a predicate. Returns
`dflt` if not found.

Find the index of indexed type for which `pred` is true. Returns `dflt` if not found.

Get the first element from an indexed data structure.

Takes a nested array (tree) `xs` and returns the depth first traversal of
it. Returns a new array.

Takes a nested array (tree) `xs` and appends the depth first traversal of
`xs` to array `into`. Returns `into`.

Flush `(dyn :out stdout)` if it is a file, otherwise do nothing.

Check a file for errors without running the file. Found errors will be printed to stderr
in the usual format. Macros will still be executed, however, so
arbitrary execution is possible. Other arguments are the same as `dofile`. `path` can also be
a file value such as stdin. Returns nil.

Do a C-style for-loop for side effects. Returns nil.

Evaluate body forever in a loop, or until a break statement.

Do a C-style for-loop for side effects. The iteration variable `i`
can be mutated in the loop, unlike normal `for`. Returns nil.

Freeze an object (make it immutable) and do a deep copy, making
child values also immutable. Closures, fibers, and abstract types
will not be recursively frozen, but all other types will.

Get the number of occurrences of each value in an indexed data structure.

Takes a sequence of pairs and creates a table from each pair. It is the inverse of
`pairs` on a table. Returns a new table.

Check if x is a function (not a cfunction).

Run garbage collection. You should probably not call this manually.

Returns the integer number of bytes to allocate before running an iteration of garbage collection.

Set an integer number of bytes to allocate before running garbage collection. Low values for interval will be slower but use less memory. High values will be faster but use more memory.

Create a generator expression using the `loop` syntax. Returns a fiber
that yields all values inside the loop in order. See `loop` for details.

# An infinite stream of random numbers, but doubled.
(def g (generate [_ :iterate true :repeat 2] (math/random)))
# -> <fiber 0x5562863141E0>

(resume g) # -> 0.487181
(resume g) # -> 0.487181
(resume g) # -> 0.507917
(resume g) # -> 0.507917
# ...

Returns a new symbol that is unique across the runtime. This means it will not collide with any already created symbols during compilation, so it can be used in macros to generate automatic bindings.

Get the value mapped to key in data structure ds, and return dflt or nil if not found. Similar to in, but will not throw an error if the key is invalid for the data structure unless the data structure is an abstract type. In that case, the abstract type getter may throw an error.

Access a value in a nested data structure. Looks into the data structure via
a sequence of keys. If value is not found, and `dflt` is provided, returns `dflt`.

Reads a line of input into a buffer, including the newline character, using a prompt. An optional environment table can be provided for auto-complete. Returns the modified buffer. Use this function to implement a simple interface for a terminal program.

Get the prototype of a table or struct. Will return nil if `x` has no prototype.

Group elements of `ind` by a function `f` and put the results into a new table. The keys of
the table are the distinct return values from calling `f` on the elements of `ind`. The values
of the table are arrays of all elements of `ind` for which `f` called on the element equals
that corresponding key.

Gets a hash for any value. The hash is an integer can be used as a cheap hash function for all values. If two values are strictly equal, then they will have the same hash value.

Check if x is a value that evaluates to itself when compiled.

A function that returns its argument.

Make multiple bindings, and if all are truthy,
evaluate the `tru` form. If any are false or nil, evaluate
the `fal` form. Bindings have the same syntax as the `let` macro.

Shorthand for `(if (not condition) else then)`.

Similar to `with`, but if binding is false or nil, evaluates
the falsey path. Otherwise, evaluates the truthy path. In both cases,
`ctor` is bound to binding.

Import a module. First requires the module, and then merges its
symbols into the current environment, prepending a given prefix as needed.
(use the :as or :prefix option to set a prefix). If no prefix is provided,
use the name of the module as a prefix. One can also use "`:export true`"
to re-export the imported symbols. If "`:exit true`" is given as an argument,
any errors encountered at the top level in the module will cause `(os/exit 1)`
to be called. Dynamic bindings will NOT be imported. Use :fresh to bypass the
module cache.

Function form of `import`. Same parameters, but the path
and other symbol parameters should be strings instead.

Get value in ds at key, works on associative data structures. Arrays, tuples, tables, structs, strings, symbols, and buffers are all associative and can be used. Arrays, tuples, strings, buffers, and symbols must use integer keys that are in bounds or an error is raised. Structs and tables can take any value as a key except nil and will return nil or dflt if not found.

Returns x + 1.

Find the first key associated with a value x in a data structure, acting like a reverse lookup.
Will not look at table prototypes.
Returns `dflt` if not found.

Check if x is an array or tuple.

Create a boxed signed 64 bit integer from a string value.

Write the bytes of an `int/s64` or `int/u64` into a buffer.
The `buffer` parameter specifies an existing buffer to write to, if unset a new buffer will be created.
Returns the modified buffer.
The `endianness` paramater indicates the byte order:
- `nil` (unset): system byte order
- `:le`: little-endian, least significant byte first
- `:be`: big-endian, most significant byte first

Convert an int/u64 or int/s64 to a number. Fails if the number is out of range for an int32.

Create a boxed unsigned 64 bit integer from a string value.

Check if x can be exactly represented as a 32 bit signed two's complement integer.

Returns an array of the first elements of each col, then the second elements, etc.

Returns a sequence of the elements of `ind` separated by
`sep`. Returns a new array.

Given an associative data structure `ds`, returns a new table where the
keys of `ds` are the values, and the values are the keys. If multiple keys
in `ds` are mapped to the same value, only one of those values will
become a key in the returned table.

The build identifier of the running janet program.

The flag set of config options from janetconf.h which is used to check if native modules are compatible with the host program.

The version number of the running janet program.

Macro form of `juxt*`. Same behavior but more efficient.

Returns the juxtaposition of functions. In other words,
`((juxt* a b c) x)` evaluates to `[(a x) (b x) (c x)]`.

Given a predicate `pred`, return a new array containing the truthy results
of applying `pred` to each element in the indexed collection `ind`. This is
different from `filter` which returns an array of the original elements where
the predicate is truthy.

Get the keys of an associative data structure.

Creates a keyword by concatenating the elements of `xs` together. If an element is not a byte sequence, it is converted to bytes via `describe`. Returns the new keyword.

Same as string/slice, but returns a keyword.

Check if x is a keyword.

Takes a table or struct and returns and array of key value pairs
like `@[k v k v ...]`. Returns a new array.

Set a label point that is lexically scoped. `name` should be a symbol
that will be bound to the label.

Get the last element from an indexed data structure.

Returns the length or count of a data structure in constant time as an integer. For structs and tables, returns the number of key-value pairs in the data structure.

Create a scope and bind values to symbols. Each pair in `bindings` is
assigned as if with `def`, and the body of the `let` form returns the last
value.

The inverse operation to `make-image`. Returns an environment.

A table used in combination with `unmarshal` to unmarshal byte sequences created
by `make-image`, such that `(load-image bytes)` is the same as `(unmarshal bytes load-image-dict)`.

A general purpose loop macro. This macro is similar to the Common Lisp loop
macro, although intentionally much smaller in scope. The head of the loop
should be a tuple that contains a sequence of either bindings or
conditionals. A binding is a sequence of three values that define something
to loop over. Bindings are written in the format:

 binding :verb object/expression

where `binding` is a binding as passed to def, `:verb` is one of a set of
keywords, and `object` is any expression. Each subsequent binding creates a
nested loop within the loop created by the previous binding.

The available verbs are:

* `:iterate` -- repeatedly evaluate and bind to the expression while it is
 truthy.

* `:range` -- loop over a range. The object should be a two-element tuple with
 a start and end value, and an optional positive step. The range is half
 open, [start, end).

* `:range-to` -- same as :range, but the range is inclusive [start, end].

* `:down` -- loop over a range, stepping downwards. The object should be a
 two-element tuple with a start and (exclusive) end value, and an optional
 (positive!) step size.

* `:down-to` -- same as :down, but the range is inclusive [start, end].

* `:keys` -- iterate over the keys in a data structure.

* `:pairs` -- iterate over the key-value pairs as tuples in a data structure.

* `:in` -- iterate over the values in a data structure or fiber.

`loop` also accepts conditionals to refine the looping further. Conditionals are of
the form:

   :modifier argument

where `:modifier` is one of a set of keywords, and `argument` is keyword-dependent.
`:modifier` can be one of:

* `:while expression` -- breaks from the current loop if `expression` is
  falsey.

* `:until expression` -- breaks from the current loop if `expression` is
  truthy.

* `:let bindings` -- defines bindings inside the current loop as passed to the
  `let` macro.

* `:before form` -- evaluates a form for a side effect before the next inner
  loop.

* `:after form` -- same as `:before`, but the side effect happens after the
  next inner loop.

* `:repeat n` -- repeats the next inner loop `n` times.

* `:when condition` -- only evaluates the current loop body when `condition`
  is true.

The `loop` macro always evaluates to nil.

# -> prints 0123456789 (not followed by newline)
(loop [x :range [0 10]]
  (prin x))

# Cartesian product (nested loops)

# -> prints 00010203101112132021222330313233
# Same as (for x 0 4 (for y 0 4 (prin x y)))
(loop [x :range [0 4]
       y :range [0 4]]
  (prin x y))

# -> prints bytes of "hello, world" as numbers
(loop [character :in "hello, world"]
  (print character))

# -> prints 1, 2, and 3, in an unspecified order
(loop [value :in {:a 1 :b 2 :c 3}]
  (print value))

# -> prints 0 to 99 inclusive
(loop [x :in (range 100)]
  (print x))

# Complex body
(loop [x :in (range 10)]
  (print x)
  (print (inc c))
  (print (+ x 2)))

# Iterate over keys
(loop [k :keys {:a 1 :b 2 :c 3}]
  (print k))
# print a, b, and c in an unspecified order

(loop [index :keys [:a :b :c :d]]
  (print index))
#  print 0, 1, 2, and 3 in order.

(defn print-pairs
  [x]
  (loop [[k v] :pairs x]
    (printf "[%v]=%v" k v)))

(print-pairs [:a :b :c])
# [0]=:a
# [1]=:b
# [2]=:c

(print-pairs {:a 1 :b 2 :c 3})
# [:a]=1
# [:b]=2
# [:c]=3

# Some modifiers - allow early termination and conditional execution
# of the loop

(loop [x :range [0 100] :when (even? x)]
  (print x))
# prints even numbers 0, 2, 4, ..., 98

(loop [x :range [1 100] :while (pos? (% x 7))]
  (print x))
# prints 1, 2, 3, 4, 5, 6

# Consume fibers as generators
(def f
  (fiber/new
    (fn []
      (for i 0 100
        (yield i)))))

(loop [x :in f]
  (print x))
# print 0, 1, 2, ... 99

# Modifiers in nested loops

(loop [x :range [0 10]
      :after (print)
       y :range [0 x]]
  (prin y " "))
# 0
# 0 1
# 0 1 2
# 0 1 2 3
# 0 1 2 3 4
# 0 1 2 3 4 5
# 0 1 2 3 4 5 6
# 0 1 2 3 4 5 6 7
# 0 1 2 3 4 5 6 7 8

Expand macros completely.
`on-binding` is an optional callback for whenever a normal symbolic binding
is encountered. This allows macros to easily see all bindings used by their
arguments by calling `macex` on their contents. The binding itself is also
replaced by the value returned by `on-binding` within the expanded macro.

Expand macros in a form, but do not recursively expand macros.
See `macex` docs for info on `on-binding`.

When inside a macro, call this function to add a linter warning. Takes
a `fmt` argument like `string/format`, which is used to format the message.

Create a new environment table. The new environment
will inherit bindings from the parent environment, but new
bindings will not pollute the parent environment.

Create an image from an environment returned by `require`.
Returns the image source as a string.

A table used in combination with `marshal` to marshal code (images), such that
`(make-image x)` is the same as `(marshal x make-image-dict)`.

Map a function over every value in a data structure and
return an array of the results.

Map a function over every element in an array or tuple and
use `array/concat` to concatenate the results.

Marshal a value into a buffer and return the buffer. The buffer can then later be unmarshalled to reconstruct the initial value. Optionally, one can pass in a reverse lookup table to not marshal aliased values that are found in the table. Then a forward lookup table can be used to recover the original value when unmarshalling.

Pattern matching. Match an expression `x` against any number of cases.
Each case is a pattern to match against, followed by an expression to
evaluate to if that case is matched. Legal patterns are:

* symbol -- a pattern that is a symbol will match anything, binding `x`'s
 value to that symbol.

* array or bracket tuple -- an array or bracket tuple will match only if
 all of its elements match the corresponding elements in `x`.
 Use `& rest` at the end of an array or bracketed tuple to bind all remaining values to `rest`.

* table or struct -- a table or struct will match if all values match with
 the corresponding values in `x`.

* tuple -- a tuple pattern will match if its first element matches, and the
 following elements are treated as predicates and are true.

* `_` symbol -- the last special case is the `_` symbol, which is a wildcard
 that will match any value without creating a binding.

While a symbol pattern will ordinarily match any value, the pattern `(@ <sym>)`,
where <sym> is any symbol, will attempt to match `x` against a value
already bound to `<sym>`, rather than matching and rebinding it.

Any other value pattern will only match if it is equal to `x`.
Quoting a pattern with `'` will also treat the value as a literal value to match against.

The number representing negative infinity

Return the absolute value of x.

Returns the arccosine of x.

Returns the hyperbolic arccosine of x.

Returns the arcsin of x.

Returns the hyperbolic arcsine of x.

Returns the arctangent of x.

Returns the arctangent of y/x. Works even when x is 0.

Returns the hyperbolic arctangent of x.

Returns the cube root of x.

Returns the smallest integer value number that is not less than x.

Returns the cosine of x.

Returns the hyperbolic cosine of x.

The base of the natural log.

Returns the error function of x.

Returns the complementary error function of x.

Returns e to the power of x.

Returns 2 to the power of x.

Returns e to the power of x minus 1.

Returns the largest integer value number that is not greater than x.

Returns gamma(x).

Returns the greatest common divisor between x and y.

Returns c from the equation c^2 = a^2 + b^2.

The number representing positive infinity

The maximum contiguous integer represtenable by a double (-(2^53))

The minimum contiguous integer representable by a double (2^53)

The maximum contiguous integer represtenable by a 32 bit signed integer

The minimum contiguous integer representable by a 32 bit signed integer

Returns the least common multiple of x and y.

Returns the natural logarithm of x.

Returns log-gamma(x).

Returns the log base 10 of x.

Returns (log base e of x) + 1 more accurately than (+ (math/log x) 1)

Returns the log base 2 of x.

Not a number (IEEE-754 NaN)

Returns the next representable floating point value after x in the direction of y.

The value pi.

Returns a to the power of x.

Returns a uniformly distributed random number between 0 and 1.

Creates a Psuedo-Random number generator, with an optional seed. The seed should be an unsigned 32 bit integer or a buffer. Do not use this for cryptography. Returns a core/rng abstract type.

Get n random bytes and put them in a buffer. Creates a new buffer if no buffer is provided, otherwise appends to the given buffer. Returns the buffer.

Extract a random integer in the range [0, max) for max > 0 from the RNG. If max is 0, return 0. If no max is given, the default is 2^31 - 1.

Extract a random number in the range [0, 1) from the RNG.

Returns the integer nearest to x.

Set the seed for the random number generator. `seed` should be an integer or a buffer.

Returns the sine of x.

Returns the hyperbolic sine of x.

Returns the square root of x.

Returns the tangent of x.

Returns the hyperbolic tangent of x.

Returns the integer between x and 0 nearest to x.

Returns the numeric maximum of the arguments.

Returns the numeric maximum of the argument sequence.

Returns the mean of xs. If empty, returns NaN.

Compare memory. Takes two byte sequences `a` and `b`, and return 0 if they have identical contents, a negative integer if a is less than b, and a positive integer if a is greater than b. Optionally take a length and offsets to compare slices of the bytes sequences.

Merges multiple tables/structs into one new table. If a key appears in more than one
collection in `colls`, then later values replace any previous ones.
Returns the new table.

Merges multiple tables/structs into table `tab`. If a key appears in more than one
collection in `colls`, then later values replace any previous ones. Returns `tab`.

Merge a module source into the `target` environment with a `prefix`, as with the `import` macro.
This lets users emulate the behavior of `import` with a custom module table.
If `export` is truthy, then merged functions are not marked as private. Returns
the modified target environment.

Returns the numeric minimum of the arguments.

Returns the numeric minimum of the argument sequence.

Returns the modulo of dividend / divisor.

Add paths to `module/paths` for a given loader such that
the generated paths behave like other module types, including
relative imports and syspath imports. `ext` is the file extension
to associate with this module type, including the dot. `loader` is the
keyword name of a loader in `module/loaders`. Returns the modified `module/paths`.

A table, mapping loaded module identifiers to their environments.

Expands a path template as found in `module/paths` for `module/find`. This takes in a path (the argument to require) and a template string, to expand the path to a path that can be used for importing files. The replacements are as follows:

* :all: -- the value of path verbatim.

* :@all: -- Same as :all:, but if `path` starts with the @ character,
 the first path segment is replaced with a dynamic binding
           `(dyn <first path segment as keyword>)`.

* :cur: -- the current file, or (dyn :current-file)

* :dir: -- the directory containing the current file

* :name: -- the name component of path, with extension if given

* :native: -- the extension used to load natives, .so or .dll

* :sys: -- the system path, or (dyn :syspath)

Try to match a module or path name from the patterns in `module/paths`.
Returns a tuple (fullpath kind) where the kind is one of :source, :native,
or :image if the module is found, otherwise a tuple with nil followed by
an error message.

A table of loading method names to loading functions.
This table lets `require` and `import` load many different kinds
of files as modules.

A table, mapping currently loading modules to true. Used to prevent
circular dependencies.

The list of paths to look for modules, templated for `module/expand-path`.
Each element is a two-element tuple, containing the path
template and a keyword :source, :native, or :image indicating how
`require` should load files found at these paths.

A tuple can also
contain a third element, specifying a filter that prevents `module/find`
from searching that path template if the filter doesn't match the input
path. The filter can be a string or a predicate function, and
is often a file extension, including the period.

Given a module table, get the value bound to a symbol `sym`. If `private` is
truthy, will also resolve private module symbols. If no binding is found, will return
nil.

Check if x is NaN.

Check if x can be exactly represented as a non-negative 32 bit signed two's complement integer.

Load a native module from the given path. The path must be an absolute or relative path on the file system, and is usually a .so file on Unix systems, and a .dll file on Windows. Returns an environment table that contains functions and other values from the native module.

Check if x is less than 0.

Get the next connection on a server stream. This would usually be called in a loop in a dedicated fiber. Takes an optional timeout in seconds, after which will return nil. Returns a new duplex stream which represents a connection to the client.

Shorthand for running a server stream that will continuously accept new connections. Blocks the current fiber until the stream is closed, and will return the stream.

Look up the connection information for a given hostname, port, and connection type. Returns a handle that can be used to send datagrams over network without establishing a connection. On Posix platforms, you can use :unix for host to connect to a unix domain socket, where the name is given in the port argument. On Linux, abstract unix domain sockets are specified with a leading '@' character in port. If `multi` is truthy, will return all address that match in an array instead of just the first.

Given an address returned by net/address, return a host, port pair. Unix domain sockets will have only the path in the returned tuple.

Same a net/read, but will wait for all n bytes to arrive rather than return early. Takes an optional timeout in seconds, after which will return nil.

Alias for `ev/close`.

Open a connection to communicate with a server. Returns a duplex stream that can be used to communicate with the server. Type is an optional keyword to specify a connection type, either :stream or :datagram. The default is :stream. Bindhost is an optional string to select from what address to make the outgoing connection, with the default being the same as using the OS's preferred address. 

Make sure that a stream is not buffering any data. This temporarily disables Nagle's algorithm. Use this to make sure data is sent without delay. Returns stream.

Creates a server. Returns a new stream that is neither readable nor writeable. Use net/accept or net/accept-loop be to handle connections and start the server. The type parameter specifies the type of network connection, either a :stream (usually tcp), or :datagram (usually udp). If not specified, the default is :stream. The host and port arguments are the same as in net/address.

Gets the local address and port in a tuple in that order.

Gets the remote peer's address and port in a tuple in that order.

Read up to n bytes from a stream, suspending the current fiber until the bytes are available. `n` can also be the keyword `:all` to read into the buffer until end of stream. If less than n bytes are available (and more than 0), will push those bytes and return early. Takes an optional timeout in seconds, after which will return nil. Returns a buffer with up to n more bytes in it, or raises an error if the read failed.

Receives data from a server stream and puts it into a buffer. Returns the socket-address the packet came from. Takes an optional timeout in seconds, after which will return nil.

Writes a datagram to a server stream. dest is a the destination address of the packet. Takes an optional timeout in seconds, after which will return nil. Returns stream.

Start a server asynchronously with `net/listen` and `net/accept-loop`. Returns the new server stream.

Stop communication on this socket in a graceful manner, either in both directions or just reading/writing from the stream. The `mode` parameter controls which communication to stop on the socket. 

* `:wr` is the default and prevents both reading new data from the socket and writing new data to the socket.
* `:r` disables reading new data from the socket.
* `:w` disable writing data to the socket.

Returns the original socket.

Write data to a stream, suspending the current fiber until the write completes. Takes an optional timeout in seconds, after which will return nil. Returns nil, or raises an error if the write failed.

Gets the next key in a data structure. Can be used to iterate through the keys of a data structure in an unspecified order. Keys are guaranteed to be seen only once per iteration if they data structure is not mutated during iteration. If key is nil, next returns the first key. If next returns nil, there are no more keys to iterate through.

Check if x is nil.

Returns the boolean inverse of x.

Check if any values in xs are not equal. Returns a boolean.

Check if x is a number.

Check if x is odd.

Check if x is equal to 1.

Evaluates to the last argument if all preceding elements are falsey, otherwise
evaluates to the first truthy element.

Check the ISA that janet was compiled for. Returns one of:

* :x86

* :x64

* :arm

* :aarch64

* :riscv32

* :riscv64

* :sparc

* :wasm

* :unknown

Change current directory to path. Returns nil on success, errors on failure.

Change file permissions, where `mode` is a permission string as returned by `os/perm-string`, or an integer as returned by `os/perm-int`. When `mode` is an integer, it is interpreted as a Unix permission value, best specified in octal, like 8r666 or 8r400. Windows will not differentiate between user, group, and other permissions, and thus will combine all of these permissions. Returns nil.

Return the number of whole + fractional seconds since some fixed point in time. The clock is guaranteed to be non-decreasing in real time.

Get the compiler used to compile the interpreter. Returns one of:

* :gcc

* :clang

* :msvc

* :unknown

Get an approximate number of CPUs available on for this process to use. If unable to get an approximation, will return a default value dflt.

Get or append `n` bytes of good quality random data provided by the OS. Returns a new buffer or `buf`.

Returns the current working directory.

Returns the given time as a date struct, or the current time if `time` is not given. Returns a struct with following key values. Note that all numbers are 0-indexed. Date is given in UTC unless `local` is truthy, in which case the date is formatted for the local timezone.

* :seconds - number of seconds [0-61]

* :minutes - number of minutes [0-59]

* :hours - number of hours [0-23]

* :month-day - day of month [0-30]

* :month - month of year [0, 11]

* :year - years since year 0 (e.g. 2019)

* :week-day - day of the week [0-6]

* :year-day - day of the year [0-365]

* :dst - if Day Light Savings is in effect

Iterate over files and subdirectories in a directory. Returns an array of paths parts, with only the file name or directory name and no prefix.

Get a copy of the OS environment table.

Execute a program on the system and pass it string arguments. `flags` is a keyword that modifies how the program will execute.
* :e - enables passing an environment to the program. Without :e, the current environment is inherited.
* :p - allows searching the current PATH for the binary to execute. Without this flag, binaries must use absolute paths.
* :x - raise error if exit code is non-zero.
* :d - Don't try and terminate the process on garbage collection (allow spawning zombies).
`env` is a table or struct mapping environment variables to values. It can also contain the keys :in, :out, and :err, which allow redirecting stdio in the subprocess. These arguments should be core/file values. Returns the exit status of the program.

Exit from janet with an exit code equal to x. If x is not an integer, the exit with status equal the hash of x.

Get the string value of an environment variable.

Create a link at newpath that points to oldpath and returns nil. Iff symlink is truthy, creates a symlink. Iff symlink is falsey or not provided, creates a hard link. Does not work on Windows.

Like os/stat, but don't follow symlinks.

Create a new directory. The path will be relative to the current directory if relative, otherwise it will be an absolute path. Returns true if the directory was created, false if the directory already exists, and errors otherwise.

Get the broken down date-struct time expressed as the number of seconds since January 1, 1970, the Unix epoch. Returns a real number. Date is given in UTC unless `local` is truthy, in which case the date is computed for the local timezone.

Inverse function to os/date.

Create a stream from a file, like the POSIX open system call. Returns a new stream. `mode` should be a file mode as passed to `os/chmod`, but only if the create flag is given. The default mode is 8r666. Allowed flags are as follows:

 * :r - open this file for reading
 * :w - open this file for writing
 * :c - create a new file (O\_CREATE)
 * :e - fail if the file exists (O\_EXCL)
 * :t - shorten an existing file to length 0 (O\_TRUNC)

Posix-only flags:

 * :a - append to a file (O\_APPEND)
 * :x - O\_SYNC
 * :C - O\_NOCTTY

Windows-only flags:

 * :R - share reads (FILE\_SHARE\_READ)
 * :W - share writes (FILE\_SHARE\_WRITE)
  * :D - share deletes (FILE\_SHARE\_DELETE)
  * :H - FILE\_ATTRIBUTE\_HIDDEN
  * :O - FILE\_ATTRIBUTE\_READONLY
  * :F - FILE\_ATTRIBUTE\_OFFLINE
  * :T - FILE\_ATTRIBUTE\_TEMPORARY
  * :d - FILE\_FLAG\_DELETE\_ON\_CLOSE
  * :b - FILE\_FLAG\_NO\_BUFFERING

Parse a 9-character permission string and return an integer that can be used by chmod.

Convert a Unix octal permission value from a permission integer as returned by `os/stat` to a human readable string, that follows the formatting of Unix tools like `ls`. Returns the string as a 9-character string of r, w, x and - characters. Does not include the file/directory/symlink character as rendered by `ls`.

Create a readable stream and a writable stream that are connected. Returns a two-element tuple where the first element is a readable stream and the second element is the writable stream.

Wait on a process if it has not been waited on, and close pipes created by `os/spawn` if they have not been closed. Returns nil.

Kill a subprocess by sending SIGKILL to it on posix systems, or by closing the process handle on windows. If `wait` is truthy, will wait for the process to finish and returns the exit code. Otherwise, returns `proc`.

Block until the subprocess completes. Returns the subprocess return code.

Read the contents of a symbolic link. Does not work on Windows.

Get the absolute path for a given path, following ../, ./, and symlinks. Returns an absolute path as a string.

Rename a file on disk to a new path. Returns nil.

Delete a file. Returns nil.

Delete a directory. The directory must be empty to succeed.

Set an environment variable.

Pass a command string str directly to the system shell.

Suspend the program for `n` seconds. `n` can be a real number. Returns nil.

Execute a program on the system and return a handle to the process. Otherwise, takes the same arguments as `os/execute`. Does not wait for the process. For each of the :in, :out, and :err keys to the `env` argument, one can also pass in the keyword `:pipe` to get streams for standard IO of the subprocess that can be read from and written to. The returned value `proc` has the fields :in, :out, :err, :return-code, and the additional field :pid on unix-like platforms. Use `(os/proc-wait proc)` to rejoin the subprocess or `(os/proc-kill proc)`.

Gets information about a file or directory. Returns a table if the second argument is a keyword, returns only that information from stat. If the file or directory does not exist, returns nil. The keys are:

* :dev - the device that the file is on

* :mode - the type of file, one of :file, :directory, :block, :character, :fifo, :socket, :link, or :other

* :int-permissions - A Unix permission integer like 8r744

* :permissions - A Unix permission string like "rwxr--r--"

* :uid - File uid

* :gid - File gid

* :nlink - number of links to file

* :rdev - Real device of file. 0 on Windows

* :size - size of file in bytes

* :blocks - number of blocks in file. 0 on Windows

* :blocksize - size of blocks in file. 0 on Windows

* :accessed - timestamp when file last accessed

* :changed - timestamp when file last changed (permissions changed)

* :modified - timestamp when file last modified (content changed)

Create a symlink from oldpath to newpath, returning nil. Same as `(os/link oldpath newpath true)`.

Get the current time expressed as the number of whole seconds since January 1, 1970, the Unix epoch. Returns a real number.

Update the access time and modification times for a file. By default, sets times to the current time.

Set a new umask, returns the old umask.

Check the current operating system. Returns one of:

* :windows

* :mingw

* :cygwin

* :macos

* :web - Web assembly (emscripten)

* :linux

* :freebsd

* :openbsd

* :netbsd

* :posix - A POSIX compatible system (default)

May also return a custom keyword specified at build time.

Get the key-value pairs of an associative data structure.

Parse a string and return the first value. For complex parsing, such as for a repl with error handling,
use the parser api.

Parse a string and return all parsed values. For complex parsing, such as for a repl with error handling,
use the parser api.

Input a single byte `b` into the parser byte stream. Returns the parser.

Creates a deep clone of a parser that is identical to the input parser. This cloned parser can be used to continue parsing from a good checkpoint if parsing later fails. Returns a new parser.

Input bytes into the parser and parse them. Will not throw errors if there is a parse error. Starts at the byte index given by `index`. Returns the number of bytes read.

Indicate to the parser that the end of file was reached. This puts the parser in the :dead state.

If the parser is in the error state, returns the message associated with that error. Otherwise, returns nil. Also flushes the parser state and parser queue, so be sure to handle everything in the queue before calling `parser/error`.

Clears the parser state and parse queue. Can be used to reset the parser if an error was encountered. Does not reset the line and column counter, so to begin parsing in a new context, create a new parser.

Check if the parser has more values in the value queue.

Insert a value into the parser. This means that the parser state can be manipulated in between chunks of bytes. This would allow a user to add extra elements to arrays and tuples, for example. Returns the parser.

Creates and returns a new parser object. Parsers are state machines that can receive bytes and generate a stream of values.

Dequeue the next value in the parse queue. Will return nil if no parsed values are in the queue, otherwise will dequeue the next value. If `wrap` is truthy, will return a 1-element tuple that wraps the result. This tuple can be used for source-mapping purposes.

Returns a representation of the internal state of the parser. If a key is passed, only that information about the state is returned. Allowed keys are:

* :delimiters - Each byte in the string represents a nested data structure. For example, if the parser state is '(["', then the parser is in the middle of parsing a string inside of square brackets inside parentheses. Can be used to augment a REPL prompt.

* :frames - Each table in the array represents a 'frame' in the parser state. Frames contain information about the start of the expression being parsed as well as the type of that expression and some type-specific information.

Gets the current status of the parser state machine. The status will be one of:

* :pending - a value is being parsed.

* :error - a parsing error was encountered.

* :root - the parser can either read more values or safely terminate.

Returns the current line number and column of the parser's internal state. If line is provided, the current line number of the parser is first set to that value. If column is also provided, the current column number of the parser is also first set to that value.

Partial function application.

Partition an indexed data structure `ind` into tuples
of size `n`. Returns a new array.

Partition elements of a sequential data structure by a representative function `f`. Partitions
split when `(f x)` changes values when iterating to the next element `x` of `ind`. Returns a new array
of arrays.

Compiles a peg source data structure into a <core/peg>. This will speed up matching if the same peg will be used multiple times. Will also use `(dyn :peg-grammar)` to suppliment the grammar of the peg for otherwise undefined peg keywords.

Find first index where the peg matches in text. Returns an integer, or nil if not found.

Find all indexes where the peg matches in text. Returns an array of integers.

Match a Parsing Expression Grammar to a byte string and return an array of captured values. Returns nil if text does not match the language defined by peg. The syntax of PEGs is documented on the Janet website.

Replace first match of peg in text with repl, returning a new buffer. The peg does not need to make captures to do replacement. If no matches are found, returns the input string in a new buffer.

Replace all matches of peg in text with repl, returning a new buffer. The peg does not need to make captures to do replacement.

Check if x is greater than 0.

Do a post-order traversal of a data structure and call `(f x)`
on every visitation.

Pretty-print to stdout or `(dyn *out*)`. The format string used is `(dyn *pretty-format* "%q")`.

Similar to `postwalk`, but do pre-order traversal.

Same as `print`, but does not add trailing newline.

Like `printf` but with no trailing newline.

Print values to the console (standard out). Value are converted to strings if they are not already. After printing all values, a newline character is printed. Use the value of `(dyn :out stdout)` to determine what to push characters to. Expects `(dyn :out stdout)` to be either a core/file or a buffer. Returns nil.

Prints output formatted as if with `(string/format fmt ;xs)` to `(dyn :out stdout)` with a trailing newline.

Returns the product of xs. If xs is empty, returns 1.

(product []) # -> 1
(product @[1 2 3]) # -> 6
(product [0 1 2 3]) # -> 0
(product (range 1 10)) # -> 362880

# Product over byte values [0-255] in a string
(product "hello") # -> 1.35996e+10

# Product over values in a table or struct
(sum {:a 1 :b 2 :c 4}) # -> 8

Set up a checkpoint that can be returned to. `tag` should be a value
that is used in a `return` statement, like a keyword.

Propagate a signal from a fiber to the current fiber. The resulting stack trace from the current fiber will include frames from fiber. If fiber is in a state that can be resumed, resuming the current fiber will first resume fiber. This function can be used to re-raise an error without losing the original stack trace.

Evaluate expressions, while capturing any errors. Evaluates to a tuple
of two elements. The first element is true if successful, false if an
error, and the second is the return value or error.

Associate a key with a value in any mutable associative data structure. Indexed data structures (arrays and buffers) only accept non-negative integer keys, and will expand if an out of bounds value is provided. In an array, extra space will be filled with nils, and in a buffer, extra space will be filled with 0 bytes. In a table, putting a key that is contained in the table prototype will hide the association defined by the prototype, but will not mutate the prototype table. Putting a value nil into a table will remove the key from the table. Returns the data structure ds.

Put a value into a nested data structure `ds`. Looks into `ds` via
a sequence of keys. Missing data structures will be replaced with tables. Returns
the modified, original data structure.

Tries to exit from the current repl or run-context. Does not always exit the application.
Works by setting the :exit dynamic binding to true. Passing a non-nil `value` here will cause the outer
run-context to return that value.

Create an array of values [start, end) with a given step.
With one argument, returns a range [0, end). With two arguments, returns
a range [start, end). With three, returns a range with optional step size.

(range 10) # -> @[0 1 2 3 4  6 7 8 9]
(range 5 10) # -> @[5 6 7 8 9]
(range 5 10 2) # -> @[5 7 9]
(range 5 11 2) # -> @[5 7 9]
(range 10 0 -1) # -> @[10 9 8 7 6 5 4 3 2 1]

Reduce, also know as fold-left in many languages, transforms
an indexed type (array, tuple) with a function to produce a value by applying `f` to
each element in order. `f` is a function of 2 arguments, `(f accum el)`, where
`accum` is the initial value and `el` is the next value in the indexed type `ind`.
`f` returns a value that will be used as `accum` in the next call to `f`. `reduce`
returns the value of the final call to `f`.

The 2-argument version of `reduce` that does not take an initialization value.
Instead, the first element of the array is used for initialization.

Evaluate body n times. If n is negative, body will be evaluated 0 times. Evaluates to nil.

Run a repl. The first parameter is an optional function to call to
get a chunk of source code that should return nil for end of file.
The second parameter is a function that is called when a signal is
caught. One can provide an optional environment table to run
the repl in, as well as an optional parser or read function to pass
to `run-context`.

Require a module with the given name. Will search all of the paths in
`module/paths`. Returns the new environment
returned from compiling and running the file.

Resume a new or suspended fiber and optionally pass in a value to the fiber that will be returned to the last yield in the case of a pending fiber, or the argument to the dispatch function in the case of a new fiber. Returns either the return result of the fiber's dispatch function, or the value from the next yield call in fiber.

Return to a prompt point.

Reverses the order of the elements in a given array or tuple and returns
a new array. If a string or buffer is provided, returns an array of its
byte values, reversed.

(reverse [1 2 3]) # -> @[3 2 1]
(reverse "abcdef") # -> @[102 101 100 99 98 97]
(reverse :abc) # -> @[99 98 97]

Reverses the order of the elements in a given array or buffer and returns it
mutated.

The root environment used to create environments with (make-env).

Run a context. This evaluates expressions in an environment,
and encapsulates the parsing, compilation, and evaluation.
Returns `(in environment :exit-value environment)` when complete.
`opts` is a table or struct of options. The options are as follows:

 * `:chunks` -- callback to read into a buffer - default is getline

 * `:on-parse-error` -- callback when parsing fails - default is bad-parse

 * `:env` -- the environment to compile against - default is the current env

 * `:source` -- source path for better errors (use keywords for non-paths) - default
 is :<anonymous>

 * `:on-compile-error` -- callback when compilation fails - default is bad-compile

 * `:on-compile-warning` -- callback for any linting error - default is warn-compile

 * `:evaluator` -- callback that executes thunks. Signature is (evaluator thunk source
    env where)

  * `:on-status` -- callback when a value is evaluated - default is debug/stacktrace.

  * `:fiber-flags` -- what flags to wrap the compilation fiber with. Default is :ia.

  * `:expander` -- an optional function that is called on each top level form before
    being compiled.

  * `:parser` -- provide a custom parser that implements the same interface as Janet's
    built-in parser.

  * `:read` -- optional function to get the next form, called like `(read env source)`.
    Overrides all parsing.

Disable feature sets to prevent the interpreter from using certain system resources. Once a feature is disabled, there is no way to re-enable it. Capabilities can be:

* :all - disallow all (except IO to stdout, stderr, and stdin)
* :env - disallow reading and write env variables
* :ffi - disallow FFI (recommended if disabling anything else)
* :fs - disallow access to the file system
* :fs-read - disallow read access to the file system
* :fs-temp - disallow creating temporary files
* :fs-write - disallow write access to the file system
* :hrtime - disallow high-resolution timers
* :modules - disallow load dynamic modules (natives)
* :net - disallow network access
* :net-connect - disallow making outbound network connections
* :net-listen - disallow accepting inbound network connections
* :sandbox - disallow calling this function
* :subprocess - disallow running subprocesses

Parse a number from a byte sequence and return that number, either an integer or a real. The number must be in the same format as numbers in janet source code. Will return nil on an invalid number. Optionally provide a base - if a base is provided, no radix specifier is expected at the beginning of the number.

Similar to `loop`, but accumulates the loop body into an array and returns that.
See `loop` for details.

(seq [x :range [0 5]] (* 2 x)) # -> @[0 2 4 6 8]

Set a dynamic binding. Returns value.

Shorthand for `fn`. Arguments are given as `$n`, where `n` is the 0-indexed
argument of the function. `$` is also an alias for the first (index 0) argument.
The `$&` symbol will make the anonymous function variadic if it appears in the
body of the function, and can be combined with positional arguments.

Example usage:

 (short-fn (+ $ $)) # A function that doubles its arguments.
 (short-fn (string $0 $1)) # accepting multiple args.
 |(+ $ $) # use pipe reader macro for terse function literals.
   |(+ $&)  # variadic functions

Raise a signal with payload x. 

Extract a sub-range of an indexed data structure or byte sequence.

(slice @[1 2 3]) # -> (1 2 3) (a new array!)
(slice @[:a :b :c] 1) # -> (:b :c)
(slice [:a :b :c :d :e] 2 4) # -> (:c :d)
(slice [:a :b :d :d :e] 2 -1) # -> (:c :d :e)
(slice [:a :b :d :d :e] 2 -2) # -> (:c :d)
(slice [:a :b :d :d :e] 2 -4) # -> ()
(slice [:a :b :d :d :e] 2 -10) # -> error: range error
(slice "abcdefg" 0 2) # -> "ab"
(slice @"abcdefg" 0 2) # -> "ab"

Read all data from a file with name `path` and then close the file.

Returns nil if all `xs` are false or nil, otherwise returns the result of the
first truthy predicate, `(pred x)`.

Sorts `ind` in-place, and returns it. Uses quick-sort and is not a stable sort.
If a `before?` comparator function is provided, sorts elements using that,
otherwise uses `<`.

Sorts `ind` in-place by calling a function `f` on each element and
comparing the result with `<`.

Returns a new sorted array without modifying the old one.
If a `before?` comparator function is provided, sorts elements using that,
otherwise uses `<`.

Returns a new sorted array that compares elements by invoking
a function `f` on each element and comparing the result with `<`.

Write `contents` to a file at `path`. Can optionally append to the file.

The standard error file.

The standard input file.

The standard output file.

Creates a string by concatenating the elements of `xs` together. If an element is not a byte sequence, it is converted to bytes via `describe`. Returns the new string.

Returns a new string where all bytes are replaced with the lowercase version of themselves in ASCII. Does only a very simple case check, meaning no unicode support.

Returns a new string where all bytes are replaced with the uppercase version of themselves in ASCII. Does only a very simple case check, meaning no unicode support.

Returns a tuple of integers that are the byte values of the string.

Checks that the string `str` only contains bytes that appear in the string `set`. Returns true if all bytes in `str` appear in `set`, false if some bytes in `str` do not appear in `set`.

Searches for the first instance of pattern `patt` in string `str`. Returns the index of the first character in `patt` if found, otherwise returns nil.

Searches for all instances of pattern `patt` in string `str`. Returns an array of all indices of found patterns. Overlapping instances of the pattern are counted individually, meaning a byte in `str` may contribute to multiple found patterns.

Similar to C's `snprintf`, but specialized for operating with Janet values. Returns a new string.

Creates a string from integer parameters with byte values. All integers will be coerced to the range of 1 byte 0-255.

Tests whether `str` starts with `pfx`.

Tests whether `str` ends with `sfx`.

Joins an array of strings into one string, optionally separated by a separator string `sep`.

Returns a string that is `n` copies of `bytes` concatenated.

Replace the first occurrence of `patt` with `subst` in the string `str`. Will return the new string if `patt` is found, otherwise returns `str`.

Replace all instances of `patt` with `subst` in the string `str`. Overlapping matches will not be counted, only the first match in such a span will be replaced. Will return the new string if `patt` is found, otherwise returns `str`.

Returns a string that is the reversed version of `str`.

Returns a substring from a byte sequence. The substring is from index `start` inclusive to index `end`, exclusive. All indexing is from 0. `start` and `end` can also be negative to indicate indexing from the end of the string. Note that index -1 is synonymous with index `(length bytes)` to allow a full negative slice range. 

Splits a string `str` with delimiter `delim` and returns an array of substrings. The substrings will not contain the delimiter `delim`. If `delim` is not found, the returned array will have one element. Will start searching for `delim` at the index `start` (if provided), and return up to a maximum of `limit` results (if provided).

Trim leading and trailing whitespace from a byte sequence. If the argument `set` is provided, consider only characters in `set` to be whitespace.

Trim leading whitespace from a byte sequence. If the argument `set` is provided, consider only characters in `set` to be whitespace.

Trim trailing whitespace from a byte sequence. If the argument `set` is provided, consider only characters in `set` to be whitespace.

Check if x is a string.

Create a new struct from a sequence of key value pairs. kvs is a sequence k1, v1, k2, v2, k3, v3, ... If kvs has an odd number of elements, an error will be thrown. Returns the new struct.

Return the prototype of a struct, or nil if it doesn't have one.

Convert a struct with prototypes to a struct with no prototypes by merging all key value pairs from recursive prototypes into one new struct.

Convert a struct to a table. If recursive is true, also convert the table's prototypes into the new struct's prototypes as well.

Create a structure, as with the usual struct constructor but set the struct prototype as well.

Check if x a struct.

Returns the sum of xs. If xs is empty, returns 0.

(sum []) # -> 0
(sum @[1]) # -> 1
(sum (range 100)) # -> 4950

# Sum over bytes values [0-255] in a string
(sum "hello") # -> 532

# Sum over values in a table or struct
(sum {:a 1 :b 2 :c 4}) # -> 7

Creates a symbol by concatenating the elements of `xs` together. If an element is not a byte sequence, it is converted to bytes via `describe`. Returns the new symbol.

Same as string/slice, but returns a symbol.

Check if x is a symbol.

Creates a new table from a variadic number of keys and values. kvs is a sequence k1, v1, k2, v2, k3, v3, ... If kvs has an odd number of elements, an error will be thrown. Returns the new table.

Remove all key-value pairs in a table and return the modified table `tab`.

Create a copy of a table. Updates to the new table will not change the old table, and vice versa.

Get the prototype table of a table. Returns nil if the table has no prototype, otherwise returns the prototype.

Creates a new empty table with pre-allocated memory for `capacity` entries. This means that if one knows the number of entries going into a table on creation, extra memory allocation can be avoided. Returns the new table.

Create a new table that is the result of merging all prototypes into a new table.

Gets a value from a table `tab` without looking at the prototype table. If `tab` does not contain the key directly, the function will return nil without checking the prototype. Returns the value in the table.

Set the prototype of a table. Returns the original table `tab`.

Convert a table to a struct. Returns a new struct. This function does not take into account prototype tables.

Check if x a table.

Similar to `loop`, but accumulates key value pairs into a table.
See `loop` for details.

Take the first n elements of a fiber, indexed or bytes type. Returns a new array, tuple or string, respectively.

Same as `(take-while (complement pred) ind)`.

Given a predicate, take only elements from a fiber, indexed, or bytes type that satisfy
the predicate, and abort on first failure. Returns a new array, tuple, or string, respectively.

Set a value to its boolean inverse. Same as `(set value (not value))`.

Enable tracing on a function. Returns the function.

Print to stderr a value and a description of the form that produced that value.
Evaluates to x.

Check if x is true.

Check if x is truthy.

Try something and catch errors. `body` is any expression,
and `catch` should be a form, the first element of which is a tuple. This tuple
should contain a binding for errors and an optional binding for
the fiber wrapping the body. Returns the result of `body` if no error,
or the result of `catch` if an error.

Creates a new tuple that contains items. Returns the new tuple.

Creates a new bracketed tuple containing the elements xs.

Set the sourcemap metadata on a tuple. line and column indicate should be integers.

]])

Take a sub-sequence of an array or tuple from index `start` inclusive to index `end` exclusive. If `start` or `end` are not provided, they default to 0 and the length of `arrtup`, respectively. `start` and `end` can also be negative to indicate indexing from the end of the input. Note that index -1 is synonymous with index `(length arrtup)` to allow a full negative slice range. Returns the new tuple.

Returns the sourcemap metadata attached to a tuple, which is another tuple (line, column).

Checks how the tuple was constructed. Will return the keyword :brackets if the tuple was parsed with brackets, and :parens otherwise. The two types of tuples will behave the same most of the time, but will print differently and be treated differently by the compiler.

Check if x is a tuple.

Returns the type of `x` as a keyword. `x` is one of:

* :nil

* :boolean

* :number

* :array

* :tuple

* :table

* :struct

* :string

* :buffer

* :symbol

* :keyword

* :function

* :cfunction

* :fiber

or another keyword for an abstract type.

(type nil) # -> :nil
(type true) # -> :boolean
(type false) # -> :boolean
(type 1) # -> :number
(type :key) # -> :keyword
(type (int/s64 "100")) # -> :core/s64

Shorthand for `(when (not condition) ;body)`. 

Unmarshal a value from a buffer. An optional lookup table can be provided to allow for aliases to be resolved. Returns the value unmarshalled from the buffer.

Disables tracing on a function. Returns the function.

For a given key in data structure `ds`, replace its corresponding value with the
result of calling `func` on that value. If `args` are provided, they will be passed
along to `func` as well. Returns `ds`, updated.

Update a value in a nested data structure `ds`. Looks into `ds` via a sequence of keys,
and replaces the value found there with `f` applied to that value.
Missing data structures will be replaced with tables. Returns
the modified, original data structure.

Similar to `import`, but imported bindings are not prefixed with a module
identifier. Can also import multiple modules in one shot.

Get the values of an associative data structure.

Define a private var that will not be exported.

Create a function that can be rebound. `varfn` has the same signature
as `defn`, but defines functions in the environment as vars. If a var `name`
already exists in the environment, it is rebound to the new function. Returns
a function.

Dynamically create a global var.

Iterate over the values in ast and apply `f`
to them. Collect the results in a data structure. If ast is not a
table, struct, array, or tuple,
returns form.

Default handler for a compile warning.

Evaluates the body when the condition is true. Otherwise returns nil.

Same as `(if-let bindings (do ;body))`.

Similar to with, but if binding is false or nil, returns
nil without evaluating the body. Otherwise, the same as `with`.

Evaluate `body` with some resource, which will be automatically cleaned up
if there is an error in `body`. `binding` is bound to the expression `ctor`, and
`dtor` is a function or callable that is passed the binding. If no destructor
(`dtor`) is given, will call :close on the resource.

# Print all of poetry.txt, and close the file when done,
# even when there is an error.
(with [f (file/open "poetry.txt")]
  (print (:read f :all)))

Run a block of code in a new fiber that has some
dynamic bindings set. The fiber will not mask errors
or signals, but the dynamic bindings will be properly
unset, as dynamic bindings are fiber-local.

Evaluates `body` with each symbol in `syms` bound to a generated, unique symbol.

Evaluates `body` with each var in `vars` temporarily bound. Similar signature to
`let`, but each binding must be a var.

Print to a file or other value explicitly (no dynamic bindings). The value to print to is the first argument, and is otherwise the same as `prin`. Returns nil.

Like `prinf` but prints to an explicit file or value `to`. Returns nil.

Print to a file or other value explicitly (no dynamic bindings) with a trailing newline character. The value to print to is the first argument, and is otherwise the same as `print`. Returns nil.

Like `printf` but prints to an explicit file or value `to`. Returns nil.

Yield a value to a parent fiber. When a fiber yields, its execution is paused until another thread resumes it. The fiber will then resume, and the last yield call will return the value that was passed to resume.

Check if x is zero.

Creates a table from two arrays/tuples.
Returns a new table.