# Top Level Bindings

All of the core functions, macros, and bindings that are not part of any module.

## Index

% function
```(% dividend divisor)

Returns the remainder of dividend / divisor.```
EXAMPLES
``````(% 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
``````
Community Examples

%= macro source
```(%= x n)

Shorthand for (set x (% x n)).```
EXAMPLES
``````(var x 10) # -> 10
(%= x 3) # -> 1
x # -> 1
``````
Community Examples

* function
```(* & xs)

Returns the product of all elements in xs. If xs is empty, returns 1.```
EXAMPLES
``````(*) # -> 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
``````
Community Examples

*= macro source
```(*= x n)

Shorthand for (set x (* x n)).```
EXAMPLES
``````(var x 100) # -> 100
x # -> 100
(*= x 10) # -> 1000
x # -> 1000
``````
Community Examples

+ function
```(+ & xs)

Returns the sum of all xs. xs must be integers or real numbers only. If xs is empty, return 0.```
EXAMPLES
``````(+) # -> 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>

(+ nil 10) # -> error: could not find method :+ for nil, or :r+ for 10
``````
Community Examples

++ macro source
```(++ x)

Increments the var x by 1.```
Community Examples

+= macro source
```(+= x n)

Increments the var x by n.```
EXAMPLES
``````(var x 100) # -> 100
x # -> 100
(+= x 10) # -> 110
x # -> 110
``````
Community Examples

- function
```(- & xs)

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.```
EXAMPLES
``````(-) # -> 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>
``````
Community Examples

-- macro source
```(-- x)

Decrements the var x by 1.```
Community Examples

-= macro source
```(-= x n)

Decrements the var x by n.```
EXAMPLES
``````(var x 10) # -> 10
(-= x 20) # -> -10
x # -> -10
``````
Community Examples

-> macro source
```(-> x & forms)

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.```
Community Examples

->> macro source
```(->> x & forms)

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.```
Community Examples

-?> macro source
```(-?> x & forms)

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.```
Community Examples

-?>> macro source
```(-?>> x & forms)

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.```
Community Examples

/ function
```(/ & 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.```
Community Examples

/= macro source
```(/= x n)

Shorthand for (set x (/ x n)).```
Community Examples

< function
```(< & xs)

Check if xs is in ascending order. Returns a boolean.```
Community Examples

<= function
```(<= & xs)

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

= function
```(= & xs)

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

> function
```(> & xs)

Check if xs is in descending order. Returns a boolean.```
Community Examples

>= function
```(>= & xs)

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

abstract? cfunction
```(abstract? x)

Check if x is an abstract type.```
Community Examples

accumulate function source
```(accumulate f init ind)

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. Returns a new array.```
Community Examples

accumulate2 function source
```(accumulate2 f ind)

The 2 argument version of accumulate that does not take an initialization value.```
Community Examples

all function source
```(all pred xs)

Returns true if all xs are truthy, otherwise the result of first falsey predicate value, (pred x).```
Community Examples

all-bindings function source
```(all-bindings &opt env local)

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).```
Community Examples

all-dynamics function source
```(all-dynamics &opt env local)

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).```
Community Examples

and macro source
```(and & forms)

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

any? function source
```(any? ind)

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

apply function
```(apply f & args)

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.```
EXAMPLES
``````(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 ...
``````
Community Examples

array cfunction
```(array & items)

Create a new array that contains items. Returns the new array.```
Community Examples

array? function source
```(array? x)

Check if x is an array.```
Community Examples

as-> macro source
```(as-> x as & forms)

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

as?-> macro source
```(as?-> x as & forms)

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

asm cfunction
```(asm assembly)

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.```
Community Examples

assert function source
```(assert x &opt err)

Throw an error if x is not truthy.```
Community Examples

```(bad-compile msg macrof where)

Default handler for a compile error.```
Community Examples

```(bad-parse p where)

Default handler for a parse error.```
Community Examples

band function
```(band & xs)

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

blshift function
```(blshift x & shifts)

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.```
Community Examples

bnot function
```(bnot x)

Returns the bit-wise inverse of integer x.```
Community Examples

boolean? function source
```(boolean? x)

Check if x is a boolean.```
Community Examples

bor function
```(bor & xs)

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

brshift function
```(brshift x & shifts)

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.```
Community Examples

brushift function
```(brushift x & shifts)

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.```
Community Examples

buffer cfunction
```(buffer & xs)

Creates a new buffer by concatenating values together. Values are converted to bytes via describe if they are not byte sequences. Returns the new buffer.```
Community Examples

buffer? function source
```(buffer? x)

Check if x is a buffer.```
Community Examples

bxor function
```(bxor & xs)

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

bytes? function source
```(bytes? x)

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

cancel function
```(cancel fiber err)

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

case macro source
```(case dispatch & pairs)

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

cfunction? function source
```(cfunction? x)

Check if x a cfunction.```
Community Examples

chr macro source
```(chr c)

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

cli-main function source
```(cli-main args)

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

cmp function
```(cmp x y)

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.```
Community Examples

comment macro source
```(comment &)

Ignores the body of the comment.```
Community Examples

comp function source
```(comp & functions)

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

compare function source
```(compare x y)

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 compare method. If not, it delegates to the primitive comparators.```
Community Examples

compare< function source
```(compare< & xs)

Equivalent of '<' but using compare function instead of primitive comparator```
Community Examples

compare<= function source
```(compare<= & xs)

Equivalent of '<=' but using compare function instead of primitive comparator```
Community Examples

compare= function source
```(compare= & xs)

Equivalent of '=' but using compare function instead of primitive comparator```
Community Examples

compare> function source
```(compare> & xs)

Equivalent of '>' but using compare function instead of primitive comparator```
Community Examples

compare>= function source
```(compare>= & xs)

Equivalent of '>=' but using compare function instead of primitive comparator```
Community Examples

compile cfunction
```(compile ast &opt env source)

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.```
Community Examples

complement function source
```(complement f)

Returns a function that is the complement to the argument.```
Community Examples

comptime macro source
```(comptime x)

(comptime x)

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

cond macro source
```(cond & pairs)

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

coro macro source
```(coro & body)

A wrapper for making fibers. Same as (fiber/new (fn [] ;body) :yi).```
Community Examples

count function source
```(count pred ind)

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

curenv function source
```(curenv &opt n)

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

debug function
```(debug &opt x)

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.```
Community Examples

debugger-env table source
`An environment that contains dot prefixed functions for debugging.`
Community Examples

dec function source
```(dec x)

Returns x - 1.```
Community Examples

deep-not= function source
```(deep-not= x y)

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

deep= function source
```(deep= x y)

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

def- macro source
```(def- name & more)

Define a private value that will not be exported.```
EXAMPLES
``````# 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)
``````
Community Examples

default macro source
```(default sym val)

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

default-peg-grammar table source
`The default grammar used for pegs. This grammar defines several common patterns that should make it easier to write more complex patterns.`
Community Examples

defer macro source
```(defer form & body)

Run form unconditionally after body, even if the body throws an error. Will also run form if a user signal 0-4 is received.```
EXAMPLES
``````# 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))
``````
Community Examples

defglobal function source
```(defglobal name value)

Dynamically create a global def.```
Community Examples

defmacro macro source
```(defmacro name & more)

Define a macro.```
Community Examples

defmacro- macro source
```(defmacro- name & more)

Define a private macro that will not be exported.```
Community Examples

defn macro source
```(defn name & more)

Define a function. Equivalent to (def name (fn name [args] ...)).```
EXAMPLES
``````(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}

``````
Community Examples

defn- macro source
```(defn- name & more)

Define a private function that will not be exported.```
EXAMPLES
``````# 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))
``````
Community Examples

describe cfunction
```(describe x)

Returns a string that is a human readable description of a value x.```
Community Examples

dictionary? function source
```(dictionary? x)

Check if x a table or struct.```
Community Examples

disasm cfunction
```(disasm func &opt field)

Returns assembly that could be used be 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.
: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.
```
Community Examples

distinct function source
```(distinct xs)

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

doc macro source
```(doc &opt sym)

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 with that prefix (all bindings will be shown if no prefix is given).```
Community Examples

doc* function source
```(doc* &opt sym)

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

doc-format function source
```(doc-format text &opt width)

Reformat text to wrap at a given line.```
Community Examples

dofile function source
```(dofile path &keys {:source src :evaluator evaluator :expander expander :env env :exit exit})

Evaluate a file and return the resulting environment. :env, :expander, and :evaluator 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.```
Community Examples

drop function source
```(drop n ind)

Drop first n elements in an indexed type. Returns new indexed instance.```
Community Examples

drop-until function source
```(drop-until pred ind)

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

drop-while function source
```(drop-while pred ind)

Given a predicate, remove elements from an indexed type that satisfy the predicate, and abort on first failure. Returns a new array.```
Community Examples

dyn cfunction
```(dyn key &opt default)

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

each macro source
```(each x ds & body)

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

eachk macro source
```(eachk x ds & body)

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

eachp macro source
```(eachp x ds & body)

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

eachy macro source
```(eachy x fiber & body)

Resume a fiber in a loop until it has errored or died. Evaluate the body of the loop with binding set to the yielded value.```
Community Examples

edefer macro source
```(edefer form & body)

Run form after body in the case that body terminates abnormally (an error or user signal 0-4). Otherwise, return last form in body.```
EXAMPLES
``````# 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"))
``````
Community Examples

eflush cfunction
```(eflush)

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

empty? function source
```(empty? xs)

Check if xs is empty.```
Community Examples

env-lookup cfunction
```(env-lookup env)

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.```
Community Examples

eprin cfunction
```(eprin & xs)

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

eprinf cfunction
```(eprinf fmt & xs)

Like eprintf but with no trailing newline.```
Community Examples

eprint cfunction
```(eprint & xs)

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

eprintf cfunction
```(eprintf fmt & xs)

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

error function
```(error e)

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

errorf function source
```(errorf fmt & args)

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

eval function source
```(eval form)

Evaluates a form in the current environment. If more control over the environment is needed, use run-context.```
EXAMPLES
``````(eval '(+ 1 2 3)) # -> 6
(eval '(error :oops)) # -> raises error :oops
(eval '(+ nil nil)) # -> raises error
``````
Community Examples

eval-string function source
```(eval-string str)

Evaluates a string in the current environment. If more control over the environment is needed, use run-context.```
EXAMPLES
``````(eval-string "(+ 1 2 3 4)") # -> 10
(eval-string ")") # -> parse error
(eval-string "(bloop)") # -> compile error
(eval-string "(+ nil nil)") # -> runtime error
``````
Community Examples

even? function source
```(even? x)

Check if x is even.```
Community Examples

every? function source
```(every? ind)

Returns true if each value in is truthy, otherwise the first falsey value.```
Community Examples

extreme function source
```(extreme order args)

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.```
Community Examples

false? function source
```(false? x)

Check if x is false.```
Community Examples

fiber? function source
```(fiber? x)

Check if x is a fiber.```
Community Examples

filter function source
```(filter pred ind)

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

find function source
```(find pred ind)

Find the first value in an indexed collection that satisfies a predicate. Returns nil if not found. Note there is no way to differentiate a nil from the indexed collection and a not found. Consider find-index if this is an issue.```
Community Examples

find-index function source
```(find-index pred ind)

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

first function source
```(first xs)

Get the first element from an indexed data structure.```
Community Examples

flatten function source
```(flatten xs)

Takes a nested array (tree), and returns the depth first traversal of that array. Returns a new array.```
Community Examples

flatten-into function source
```(flatten-into into xs)

Takes a nested array (tree), and appends the depth first traversal of that array to an array 'into'. Returns array into.```
Community Examples

flush cfunction
```(flush)

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

for macro source
```(for i start stop & body)

Do a c style for loop for side effects. Returns nil.```
Community Examples

forever macro source
```(forever & body)

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

forv macro source
```(forv i start stop & body)

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

freeze function source
```(freeze x)

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.```
Community Examples

frequencies function source
```(frequencies ind)

Get the number of occurrences of each value in a indexed structure.```
Community Examples

function? function source
```(function? x)

Check if x is a function (not a cfunction).```
Community Examples

gccollect cfunction
```(gccollect)

Run garbage collection. You should probably not call this manually.```
Community Examples

gcinterval cfunction
```(gcinterval)

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

gcsetinterval cfunction
```(gcsetinterval interval)

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.```
Community Examples

generate macro source
```(generate head & body)

Create a generator expression using the loop syntax. Returns a fiber that yields all values inside the loop in order. See loop for details.```
EXAMPLES
``````# 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
# ...
``````
Community Examples

gensym cfunction
```(gensym)

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.```
Community Examples

get function
```(get ds key &opt dflt)

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.```
Community Examples

get-in function source
```(get-in ds ks &opt dflt)

Access a value in a nested data structure. Looks into the data structure via a sequence of keys.```
Community Examples

getline cfunction
```(getline &opt prompt buf env)

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.```
Community Examples

hash cfunction
```(hash value)

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.```
Community Examples

idempotent? function source
```(idempotent? x)

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

identity function source
```(identity x)

A function that returns its first argument.```
Community Examples

if-let macro source
```(if-let bindings tru &opt fal)

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.```
Community Examples

if-not macro source
```(if-not condition then &opt else)

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

if-with macro source
```(if-with [binding ctor dtor] truthy &opt falsey)

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.```
Community Examples

import macro source
```(import path & args)

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.```
Community Examples

import* function source
```(import* path & args)

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

in function
```(in ds key &opt dflt)

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.```
Community Examples

inc function source
```(inc x)

Returns x + 1.```
Community Examples

index-of function source
```(index-of x ind &opt dflt)

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.```
Community Examples

indexed? function source
```(indexed? x)

Check if x is an array or tuple.```
Community Examples

int? cfunction
```(int? x)

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

interleave function source
```(interleave & cols)

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

interpose function source
```(interpose sep ind)

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

invert function source
```(invert ds)

Returns a table where the keys of an associative data structure are the values, and the values of the keys. If multiple keys have the same value, one key will be ignored.```
Community Examples

juxt macro source
```(juxt & funs)

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

juxt* function source
```(juxt* & funs)

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

keep function source
```(keep pred ind)

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

keys function source
```(keys x)

Get the keys of an associative data structure.```
Community Examples

keyword cfunction
```(keyword & xs)

Creates a keyword by concatenating values together. Values are converted to bytes via describe if they are not byte sequences. Returns the new keyword.```
Community Examples

keyword? function source
```(keyword? x)

Check if x is a keyword.```
Community Examples

kvs function source
```(kvs dict)

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

label macro source
```(label name & body)

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

last function source
```(last xs)

Get the last element from an indexed data structure.```
Community Examples

length function
```(length ds)

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.```
Community Examples

let macro source
```(let bindings & body)

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.```
Community Examples

```(load-image image)

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

`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).`
Community Examples

loop macro source
```(loop head & body)

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. They are formatted like:

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. 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 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 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 keys value pairs as tuples in a data structure.
:in - iterate over the values in a data structure.
:generate - iterate over values yielded from a fiber. Can be paired with the generator  function for the producer/consumer pattern.

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 loop if expression is falsey.
:until expression - breaks from the loop if expression is truthy.
:let bindings - defines bindings inside the loop as passed to the let macro.
:before form - evaluates a form for a side effect before of 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 loop body when condition is true.

The loop macro always evaluates to nil.```
EXAMPLES
``````# -> 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])
# =:a
# =:b
# =: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 :generate 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
``````
Community Examples

macex function source
```(macex x &opt on-binding)

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

macex1 function source
```(macex1 x &opt on-binding)

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

make-env function source
```(make-env &opt parent)

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

make-image function source
```(make-image env)

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

make-image-dict table source
`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).`
Community Examples

map function source
```(map f & inds)

Map a function over every element in an indexed data structure and return an array of the results.```
Community Examples

mapcat function source
```(mapcat f ind)

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

marshal cfunction
```(marshal x &opt reverse-lookup buffer)

Marshal a value into a buffer and return the buffer. The buffer can the 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 forwardlookup table can be used to recover the original value when unmarshalling.```
Community Examples

match macro source
```(match x & cases)

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. A pattern that is a symbol will match anything, binding x's value to that symbol. An array will match only if all of it's elements match the corresponding elements in x. A table or struct will match if all values match with the corresponding values in x. A tuple pattern will match if it's first element matches, and the following elements are treated as predicates and are true. The last special case is the '_ symbol, which is a wildcard that will match any value without creating a binding. Any other value pattern will only match if it is equal to x.```
Community Examples

max function source
```(max & args)

Returns the numeric maximum of the arguments.```
Community Examples

mean function source
```(mean xs)

Returns the mean of xs. If empty, returns NaN.```
Community Examples

merge function source
```(merge & colls)

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

merge-into function source
```(merge-into tab & colls)

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

min function source
```(min & args)

Returns the numeric minimum of the arguments.```
Community Examples

mod function
```(mod dividend divisor)

Returns the modulo of dividend / divisor.```
Community Examples

nan? function source
```(nan? x)

Check if x is NaN```
Community Examples

nat? cfunction
```(nat? x)

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

native cfunction
```(native path &opt env)

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.```
Community Examples

neg? function source
```(neg? x)

Check if x is less than 0.```
Community Examples

next function
```(next ds &opt key)

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.```
Community Examples

nil? function source
```(nil? x)

Check if x is nil.```
Community Examples

not cfunction
```(not x)

Returns the boolean inverse of x.```
Community Examples

not= function
```(not= & xs)

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

number? function source
```(number? x)

Check if x is a number.```
Community Examples

odd? function source
```(odd? x)

Check if x is odd.```
Community Examples

one? function source
```(one? x)

Check if x is equal to 1.```
Community Examples

or macro source
```(or & forms)

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

pairs function source
```(pairs x)

Get the values of an associative data structure.```
Community Examples

parse function source
```(parse str)

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

partial function source
```(partial f & more)

Partial function application.```
Community Examples

partition function source
```(partition n ind)

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

pos? function source
```(pos? x)

Check if x is greater than 0.```
Community Examples

postwalk function source
```(postwalk f form)

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

pp function source
```(pp x)

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

prewalk function source
```(prewalk f form)

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

prin cfunction
```(prin & xs)

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

prinf cfunction
```(prinf fmt & xs)

Like printf but with no trailing newline.```
Community Examples

print cfunction
```(print & xs)

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.```
Community Examples

printf cfunction
```(printf fmt & xs)

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

product function source
```(product xs)

Returns the product of xs. If xs is empty, returns 1.```
EXAMPLES
``````(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
``````
Community Examples

prompt macro source
```(prompt tag & body)

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

propagate function
```(propagate x fiber)

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.```
Community Examples

protect macro source
```(protect & body)

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.```
Community Examples

put function
```(put ds key value)

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.```
Community Examples

put-in function source
```(put-in ds ks v)

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

quit function source
```(quit &opt value)

Tries to exit from the current repl or 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.```
Community Examples

range function source
```(range & args)

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.```
EXAMPLES
``````(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]
``````
Community Examples

reduce function source
```(reduce f init ind)

Reduce, also know as fold-left in many languages, transforms an indexed type (array, tuple) with a function to produce a value.```
Community Examples

reduce2 function source
```(reduce2 f ind)

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

repeat macro source
```(repeat n & body)

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

repl function source
```(repl &opt chunks onsignal env)

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.```
Community Examples

require function source
```(require path & args)

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.```
Community Examples

resume function
```(resume fiber &opt x)

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.```
Community Examples

return function source
```(return to &opt value)

Community Examples

reverse function source
```(reverse t)

Reverses the order of the elements in a given array or tuple and returns a new array. If string or buffer is provided function returns array of chars reversed.```
EXAMPLES
``````(reverse [1 2 3]) # -> @[3 2 1]
(reverse "abcdef") # -> @[102 101 100 99 98 97]
(reverse :abc) # -> @[99 98 97]

``````
Community Examples

reverse! function source
```(reverse! t)

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

root-env table source
`The root environment used to create environments with (make-env)`
Community Examples

run-context function source
```(run-context opts)

Run a context. This evaluates expressions in an environment, and is 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 - string path of source for better errors - default is "<anonymous>"
:on-compile-error - callback when compilation fails - default is bad-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.```
Community Examples

scan-number cfunction
```(scan-number str)

Parse a number from a byte sequence an return that number, either and 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.```
Community Examples

seq macro source
```(seq head & body)

Similar to loop, but accumulates the loop body into an array and returns that. See loop for details.```
EXAMPLES
``````(seq [x :range [0 5]] (* 2 x)) # -> @[0 2 4 6 8]
``````
Community Examples

setdyn cfunction
```(setdyn key value)

Set a dynamic binding. Returns value.```
Community Examples

short-fn macro source
```(short-fn arg)

fn shorthand.

usage:

(short-fn (+ \$ \$)) - A function that double's its arguments.
(short-fn (string \$0 \$1)) - accepting multiple args
|(+ \$ \$) - use pipe reader macro for terse function literals
Community Examples

signal cfunction
```(signal what x)

Raise a signal with payload x. ```
Community Examples

slice cfunction
```(slice x &opt start end)

Extract a sub-range of an indexed data structure or byte sequence.```
EXAMPLES
``````(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"

``````
Community Examples

slurp function source
```(slurp path)

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

some function source
```(some pred xs)

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

sort function source
```(sort a &opt by)

Sort an array in-place. Uses quick-sort and is not a stable sort.```
Community Examples

sort-by function source
```(sort-by f ind)

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

sorted function source
```(sorted ind &opt by)

Returns a new sorted array without modifying the old one.```
Community Examples

sorted-by function source
```(sorted-by f ind)

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

spit function source
```(spit path contents &opt mode)

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

stderr core/file
`The standard error file.`
Community Examples

stdin core/file
`The standard input file.`
Community Examples

stdout core/file
`The standard output file.`
Community Examples

string cfunction
```(string & parts)

Creates a string by concatenating values together. Values are converted to bytes via describe if they are not byte sequences. Returns the new string.```
Community Examples

string? function source
```(string? x)

Check if x is a string.```
Community Examples

struct cfunction
```(struct & kvs)

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.```
Community Examples

struct? function source
```(struct? x)

Check if x a struct.```
Community Examples

sum function source
```(sum xs)

Returns the sum of xs. If xs is empty, returns 0.```
EXAMPLES
``````(sum []) # -> 0
(sum @) # -> 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
``````
Community Examples

symbol cfunction
```(symbol & xs)

Creates a symbol by concatenating values together. Values are converted to bytes via describe if they are not byte sequences. Returns the new symbol.```
Community Examples

symbol? function source
```(symbol? x)

Check if x is a symbol.```
Community Examples

table cfunction
```(table & kvs)

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.```
Community Examples

table? function source
```(table? x)

Check if x a table.```
Community Examples

take function source
```(take n ind)

Take first n elements in an indexed type. Returns new indexed instance.```
Community Examples

take-until function source
```(take-until pred ind)

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

take-while function source
```(take-while pred ind)

Given a predicate, take only elements from an indexed type that satisfy the predicate, and abort on first failure. Returns a new array.```
Community Examples

trace cfunction
```(trace func)

Enable tracing on a function. Returns the function.```
Community Examples

tracev macro source
```(tracev x)

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

true? function source
```(true? x)

Check if x is true.```
Community Examples

truthy? function source
```(truthy? x)

Check if x is truthy.```
Community Examples

try macro source
```(try body catch)

Try something and catch errors. Body is any expression, and catch should be a form with the first element 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.```
Community Examples

tuple cfunction
```(tuple & items)

Creates a new tuple that contains items. Returns the new tuple.```
Community Examples

tuple? function source
```(tuple? x)

Check if x is a tuple.```
Community Examples

type cfunction
```(type x)

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

or another keyword for an abstract type.```
EXAMPLES
``````(type nil) # -> :nil
(type true) # -> :boolean
(type false) # -> :boolean
(type 1) # -> :number
(type :key) # -> :keyword
(type (int/s64 "100")) # -> :core/s64
``````
Community Examples

unless macro source
```(unless condition & body)

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

unmarshal cfunction
```(unmarshal buffer &opt lookup)

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.```
Community Examples

untrace cfunction
```(untrace func)

Disables tracing on a function. Returns the function.```
Community Examples

update function source
```(update ds key func & args)

Accepts a key argument and passes its associated value to a function. The key is the re-associated to the function's return value. Returns the updated data structure ds.```
Community Examples

update-in function source
```(update-in ds ks f & args)

Update a value in a nested data structure by applying f to the current value. Looks into the data structure via a sequence of keys. Missing data structures will be replaced with tables. Returns the modified, original data structure.```
Community Examples

use macro source
```(use & modules)

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

values function source
```(values x)

Get the values of an associative data structure.```
Community Examples

var- macro source
```(var- name & more)

Define a private var that will not be exported.```
Community Examples

varfn macro source
```(varfn name & body)

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.```
Community Examples

varglobal function source
```(varglobal name init)

Dynamically create a global var.```
Community Examples

walk function source
```(walk f form)

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.```
Community Examples

when macro source
```(when condition & body)

Evaluates the body when the condition is true. Otherwise returns nil.```
Community Examples

when-let macro source
```(when-let bindings & body)

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

when-with macro source
```(when-with [binding ctor dtor] & body)

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

with macro source
```(with [binding ctor dtor] & body)

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.```
EXAMPLES
``````# Print all of poetry.txt, and close the file when done,
# even when there is an error.
(with [f (file/open "poetry.txt")]
``````
Community Examples

with-dyns macro source
```(with-dyns bindings & body)

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.```
Community Examples

with-syms macro source
```(with-syms syms & body)

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

with-vars macro source
```(with-vars vars & body)

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

xprin cfunction
```(xprin to & xs)

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.```
Community Examples

xprinf cfunction
```(xprin to fmt & xs)

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

xprint cfunction
```(xprint to & xs)

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.```
Community Examples

xprintf cfunction
```(xprint to fmt & xs)

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

yield function
```(yield &opt x)

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.```
Community Examples

zero? function source
```(zero? x)

Check if x is zero.```
Community Examples

zipcoll function source
```(zipcoll ks vs)

Creates a table from two arrays/tuples. Returns a new table.```
Community Examples