Search

Filter by name or keyword. On JS-enabled browsers, press / or Ctrl+K anywhere for the search palette.

Pages

• Get Started: Install, build, and run your first mino program.
• Documentation: Hub page for all mino documentation.
• Embedding Guide: State lifecycle, value ownership, sandboxing, handles, sessions, and threading rules.
• Embedding Cookbook: Twelve worked embedding examples with full C source.
• Language Bindings: Embedding mino from C, C++, Java, Zig, Rust, C#, Go, and Swift.
• C API Reference: Every public function, type, enum, and macro in mino.h.
• Language Reference: Every built-in function, special form, and macro.
• Error Diagnostics: Structured errors with stable codes, source snippets, and programmatic access.
• Testing: Write and run tests with deftest, is, and testing.
• Coming from Clojure: What works the same, what differs, and intentional divergences.
• Compatibility Matrix: Clojure core functions: supported, differs, or absent in mino.
• Intentional Divergences: Where mino deliberately differs from Clojure and why.
• Bytes and Bit Syntax: Immutable binary data and Erlang-inspired bit-pattern matching.
• Task Runner: Define build tasks in mino.edn as ordinary functions.
• Tooling and Editors: tree-sitter grammar, LSP server, and nREPL server.
• Bytecode and VM: Register-based bytecode VM: opcodes, inline caches, fused loops.
• JIT: Copy-and-patch JIT: stencils, parity, deopt, runtime control.
• Garbage Collection: Two-generation tracing collector with incremental old-gen mark.
• Software Transactional Memory: Refs, dosync, alter, commute, ensure, ref-set, watches.
• Performance: Per-operation costs, collection throughput, and guidance.
• Platform Support: Operating systems, compilers, and language floors.
• Dependencies: Module resolver: bundled stdlib, on-disk lib/, git-fetched repos.
• Zero dependencies, vendored first: Single-file amalgamation, no transitive build dependencies.
• Use Cases: Worked examples sized as small applications.
• About: Design philosophy, trade-offs, and related projects.

C API

• MINO_VERSION_MAJOR macro: Compile-time version constants, bumped by the release process.
• MINO_VERSION_MINOR macro:
• MINO_VERSION_PATCH macro:
• MINO_VERSION macro:
• mino_version_string function: Human-readable version string of the *linked* runtime, e.g.
• mino_type enum:
• mino_typeof function: Return the effective type of a value.
• mino_prim_fn typedef:
• mino_prim_fn2 typedef: argv ABI: receives evaluated args as a flat C array instead of a cons spine.
• mino_finalizer_fn typedef:
• mino_host_fn typedef: Host interop callback.
• mino_nil function: Return the singleton nil value.
• mino_true function: Return the singleton true value.
• mino_false function: Return the singleton false value.
• mino_empty_list function: Return the singleton empty-list value `()`.
• mino_int function: Create an integer value from a signed long long.
• mino_float function: Create a floating-point value.
• mino_float32 function: Create a 32-bit single-precision floating-point value.
• mino_bigint_from_ll function: Create a bigint from a signed long long.
• mino_bigint_from_string function: Create a bigint by parsing a base-10 numeric string (optional leading '+' or '-').
• mino_ratio_from_ll function: Create a rational from numerator and denominator long longs.
• mino_bigdec_from_string function: Create a bigdec from a base-10 numeric string.
• mino_char function: Create a character value from a Unicode codepoint (0..0x10FFFF).
• mino_string function: Create a string from a NUL-terminated C string.
• mino_string_n function: Create a string from a buffer of length len.
• mino_symbol function: Intern a symbol from a NUL-terminated C string.
• mino_symbol_n function: Intern a symbol from a buffer of length len.
• mino_keyword function: Intern a keyword from a NUL-terminated C string (without the leading :).
• mino_keyword_n function: Intern a keyword from a buffer of length len (without the leading :).
• mino_keyword_ns_n function: Intern a keyword from explicit (ns, name) buffers.
• mino_symbol_ns_n function: Same shape for symbols.
• mino_cons function: Create a cons cell (list node) with the given car and cdr.
• mino_vector function: Create a persistent vector from a C array of values.
• mino_map function: Create a persistent hash map from parallel key and value arrays.
• mino_set function: Create a persistent hash set from a C array of values.
• mino_vec_builder typedef: Builders are an embedder-friendly facade over transients.
• mino_map_builder typedef:
• mino_set_builder typedef:
• mino_vector_builder_new function:
• mino_vector_builder_push function:
• mino_vector_builder_finish function:
• mino_map_builder_new function:
• mino_map_builder_put function:
• mino_map_builder_finish function:
• mino_set_builder_new function:
• mino_set_builder_add function:
• mino_set_builder_finish function:
• mino_iter typedef: One iterator type walks every sequential / associative collection mino exposes: vectors, maps (hashed and sorted), sets (hashed and sorted), cons lists, the empty-list singleton, lazy seqs, and chunked seqs.
• mino_iter_sizeof function:
• mino_iter_init function:
• mino_iter_next function:
• mino_iter_done function:
• mino_prim function: Create a primitive function value from a C function pointer.
• mino_prim_argv function: Create a primitive value backed by an argv-style C function.
• mino_handle function: Wrap a host pointer as an opaque handle with a type tag.
• mino_handle_ex function: Wrap a host pointer with a type tag and a finalizer called on GC.
• mino_atom function: Create a mutable atom initialized with val.
• mino_is_handle function: Return 1 if v is a handle, 0 otherwise.
• mino_handle_ptr function: Return the host pointer from a handle, or NULL if v is not a handle.
• mino_handle_tag function: Return the type tag from a handle, or NULL if v is not a handle.
• mino_text_data function: Return the byte content of a string, symbol, or keyword, or NULL for any other type.
• mino_text_len function: Return the byte length of a string, symbol, or keyword, or 0 for any other type.
• mino_is_atom function: Return 1 if v is an atom, 0 otherwise.
• mino_atom_deref function: Return the current value of an atom.
• mino_volatile function: Create a volatile cell initialized with val.
• mino_is_volatile function: Return 1 if v is a volatile, 0 otherwise.
• mino_volatile_deref function: Return the current value of a volatile, or NULL if v is not a volatile.
• mino_atom_reset function: Set the value of an atom.
• mino_map_entry function: Construct a map entry holding (k, v).
• mino_queue_empty function: Build an empty PersistentQueue.
• mino_is_queue function: Return 1 if v is a MINO_QUEUE, 0 otherwise.
• mino_queue_count function: count / conj / peek / pop / seq on a PersistentQueue.
• mino_queue_conj function:
• mino_queue_peek function:
• mino_queue_pop function:
• mino_queue_seq function:
• mino_bytes function: MINO_BYTES constructors and accessors. mino_bytes(S, src, n) copies n bytes from `src` into a fresh GC-managed MINO_BYTES value with bit_tail == 0.
• mino_bytes_from_array function:
• mino_is_bytes function:
• mino_is_bitstring function:
• mino_bytes_len function:
• mino_bytes_bit_len function:
• mino_bytes_data function:
• mino_bytes_get function:
• mino_tx_ref function: Construct an STM ref holding the given committed value.
• mino_agent function: Construct an asynchronous agent holding the given initial state. Watches, validator, and error handler all start NULL; install them via add-watch / set-validator! / set-error-handler! on the returned cell.
• mino_is_agent function: Return 1 if v is an agent, 0 otherwise.
• mino_agent_deref function: Return the agent's current state value (the most-recently committed action result, or the initial value if no action has applied).
• mino_send function: Enqueue (fn current-value arg1 arg2 ...) onto the agent's POOLED run-queue and return the agent immediately.
• mino_send_off function: Like mino_send but routes the action onto the SOLO pool.
• mino_await function: Block the calling thread until each named agent's in-flight count reaches zero.
• mino_await_for function: Like mino_await with a millisecond timeout.
• mino_agent_error function: Return the agent's most recent captured exception value, or NULL if the agent is in a clean state.
• mino_restart_agent function: Restart a failed agent: clears its captured error and resets its value to `new_state`.
• mino_is_tx_ref function: Return 1 if v is an STM ref (MINO_TX_REF), 0 otherwise.
• mino_tx_ref_deref function: Read a ref.
• mino_tx_ref_set function: Set the ref's in-transaction tentative value to val.
• mino_tx_xform_fn typedef: C-callable transformer used by mino_tx_alter_c / mino_tx_commute_c. `cur` is the in-tx effective value at call time; `user` is the caller-supplied opaque pointer.
• mino_tx_alter_c function: Apply (fn cur user) to ref's current in-tx value and store the result.
• mino_tx_commute_c function: Like mino_tx_alter_c but does NOT record a read (commute semantics). The fn is invoked once eagerly to produce the call-site value; if the ref did not also have an alter / ref-set in the same tx, the fn is replayed at commit time against the latest committed value (the fn must therefore be commutative).
• mino_tx_ensure function: Pin the ref against any concurrent committer until this transaction commits or aborts.
• mino_tx_body_fn typedef: C-callable transaction body, used by mino_tx_run.
• mino_tx_run function: Run body inside a transaction.
• mino_store_clock_fn typedef: Clock callback: returns the current instant as a monotonic-ish integer (typically milliseconds or nanoseconds).
• mino_store_val function: Construct a store connection from an initial db value (a persistent map).
• mino_is_store function: Return 1 if v is a store connection (MINO_STORE), 0 otherwise.
• mino_store_deref function: Return the store's current immutable db value (the snapshot). Equivalent to @conn / (store/db conn).
• mino_store_publish function: Atomically publish a new db value: write barrier, set the val, fire watches.
• mino_store_open function: Host-facing lifecycle: open a durable store at path, flush WAL (checkpoint), close file and release lock (close).
• mino_store_checkpoint function:
• mino_store_close function:
• mino_store_path function: Return the store's path string (NULL if in-memory).
• mino_save_image function: Save the full runtime state to an image file.
• mino_load_image_into function: Load an image into a pre-initialized state (mino_state_new + mino_install_all must be called first).
• mino_defrecord function: Define a record type.
• mino_is_record_type function: Return 1 if v is a record type (MINO_TYPE), 0 otherwise.
• mino_record function: Build a record.
• mino_record_field function: Read a declared field by name.
• mino_is_record function: Return 1 if v is a record (MINO_RECORD), 0 otherwise.
• mino_transient function: Wrap a persistent vector, map, or set in a new transient.
• mino_persistent function: Extract the current persistent value and invalidate the transient. Further *_bang calls on t will throw.
• mino_assoc_bang function: Transient mutators.
• mino_conj_bang function:
• mino_dissoc_bang function:
• mino_disj_bang function:
• mino_pop_bang function:
• mino_is_transient function: Transient predicates and accessors.
• mino_transient_count function:
• mino_is_nil function: Type-predicate grid.
• mino_is_truthy function:
• mino_is_bool function:
• mino_is_int function:
• mino_is_float function:
• mino_is_char function:
• mino_is_string function:
• mino_is_symbol function:
• mino_is_keyword function:
• mino_is_cons function:
• mino_is_empty_list function:
• mino_is_vector function:
• mino_is_map function:
• mino_is_set function:
• mino_is_fn function:
• mino_is_macro function:
• mino_is_prim function:
• mino_is_lazy function:
• mino_is_var function:
• mino_is_bigint function:
• mino_is_ratio function:
• mino_is_bigdec function:
• mino_is_uuid function:
• mino_is_regex function:
• mino_is_float32 function:
• mino_is_sorted_map function:
• mino_is_sorted_set function:
• mino_is_map_entry function:
• mino_is_host_array function:
• mino_is_record function:
• mino_is_queue function:
• mino_is_bytes function:
• mino_is_bitstring function:
• mino_is_record_type function:
• mino_is_handle function:
• mino_is_atom function:
• mino_is_volatile function:
• mino_is_agent function:
• mino_is_tx_ref function:
• mino_is_transient function:
• mino_is_future function:
• mino_eq function: Structural equality.
• mino_compare function: Three-way comparison.
• mino_hash function: Canonical 32-bit value hash matching Clojure's hash contract: for any pair where `mino_eq(a, b)` is 1, `mino_hash(a) == mino_hash(b)`. Tag-aware; NULL hashes the same as nil.
• mino_car function: Return the first element of a cons cell, or NULL.
• mino_cdr function: Return the rest of a cons cell, or NULL.
• mino_seq function: Universal seq abstraction matching Clojure's `seq` / `first` / `rest` / `next`: mino_seq(S, coll) -- coerce coll to a seq; returns NULL for an eval error, mino_nil() for an empty input. mino_first(coll) -- first element of the seq; mino_nil() if empty. mino_rest(S, coll) -- the seq of everything after the first; an empty list when there's nothing left. mino_next(S, coll) -- (seq (rest coll)): nil when empty, the forced seq otherwise.
• mino_first function:
• mino_rest function:
• mino_next function:
• mino_meta function: Metadata read / attach matching script-side `(meta x)` and `(with-meta x m)`.
• mino_with_meta function:
• mino_binding_frame typedef: Dynamic-binding push/pop from C, peer to script-side `(binding [...] ...)`.
• mino_push_bindings function:
• mino_pop_bindings function:
• mino_can_clone function: Cross-state transferability pre-flight.
• mino_length function: Return the number of cons cells in a list.
• mino_to_int function: Type-safe C extraction.
• mino_to_float function:
• mino_to_float32 function:
• mino_to_bool function:
• mino_to_char function:
• mino_to_string function:
• mino_to_keyword function:
• mino_to_symbol function:
• mino_to_bigint_str function: Bigint -> decimal-string serialiser.
• mino_to_ratio function: Ratio extractor for ratios whose numerator and denominator both fit in `long long`.
• mino_to_bigdec_str function: Bigdec -> string serialiser (canonical Clojure-style printing, e.g.
• mino_to_uuid_bytes function: UUID extractor.
• mino_to_regex_source function: Regex source extractor.
• mino_print function: Print a value to stdout in readable form.
• mino_println function: Print a value to stdout followed by a newline.
• mino_print_to function: Print a value to the given FILE stream.
• mino_print_to_buf function: Print a value's readable form into a sized buffer (NUL-terminated). Returns the number of bytes written excluding the trailing NUL, or -1 on error (NULL buf, zero capacity, or I/O failure).
• mino_read function: Read one form from `src`.
• mino_last_error function: Return the last error message, or NULL if no error occurred.
• mino_diag typedef: Opaque structured diagnostic type.
• mino_last_diag function: Return the last structured diagnostic, or NULL if no error occurred. The returned pointer is valid until the next error or clear_error.
• mino_last_error_map function: Return the last error as a mino map with :mino/kind, :mino/code, etc. Returns nil if no error occurred.
• mino_error_kind function: Return the last error's classified kind (e.g.
• mino_error_code function: Return the last error's stable code (e.g.
• mino_clear_error function: Clear the last error and diagnostic.
• MINO_DIAG_RENDER_COMPACT macro: Diagnostic rendering modes.
• MINO_DIAG_RENDER_PRETTY macro:
• mino_render_diag function: Render a diagnostic into buf.
• mino_state_new function: Create a new isolated runtime state.
• mino_state_free function: Free a runtime state and all resources owned by it.
• mino_jit_mode enum: JIT mode control (per-state).
• mino_jit_capability struct: JIT capability query.
• mino_state_jit_capability function:
• mino_env_new function: Allocate a fresh root environment and register it with the collector so every value reachable through it survives collection.
• mino_env_free function: Free an environment and unregister it from the collector.
• mino_env_clone function: Clone an environment: allocate a new root environment and copy all bindings from the source.
• mino_env_new_default function: Convenience: allocate a new env and install the sandbox preset. Equivalent to: mino_env *env = mino_env_new(S); mino_install_sandbox(S, env); Use this when getting a runnable env in one line matters and the sandbox surface is the right contract.
• mino_env_set function: Define or replace a binding in `env`.
• mino_env_get function: Look up `name`.
• mino_eval function: Evaluate one form.
• mino_eval_string function: Read and evaluate all forms in `src`.
• mino_load_file function: Read a file at `path` and evaluate all forms.
• mino_eval_ex function: Protected variants of mino_eval / mino_eval_string / mino_load_file. Return 0 on success (writing the result to *out) or -1 on error. Unlike the unsuffixed variants, the _ex form disambiguates "real nil result" from "error": a 0 return with *out == mino_nil() is genuine nil; a -1 return means a throw / OOM / parse failure was caught.
• mino_eval_string_ex function:
• mino_load_file_ex function:
• mino_register_fn function: Shorthand: bind a C function as a primitive in `env`. Equivalent to mino_env_set(S, env, name, mino_prim(S, name, fn)).
• mino_reg struct: Bulk-register an array of C primitives.
• mino_register_fns function:
• mino_call function: Call a callable value (fn, macro, prim) with an argument list. Returns the result, or NULL on error (via mino_last_error).
• mino_pcall function: Protected call: same as mino_call but returns 0 on success (writing the result to *out) or -1 on error.
• mino_throw function: Raise a mino exception carrying `ex` as the payload.
• mino_args_parse function: Type-check and destructure a primitive's argument list into C variables. The format string lists one character per expected positional argument; each variadic pointer receives the corresponding extracted value: "i" long long * -- MINO_INT "f" double * -- MINO_FLOAT or MINO_INT (promoted) "s" const char ** -- MINO_STRING; pointer into mino-owned data "S" const char **, -- MINO_STRING; pointer plus byte length size_t * (write both in order: "S" consumes two ptrs) "k" const char ** -- MINO_KEYWORD name (without the leading :) "y" const char ** -- MINO_SYMBOL name "b" int * -- MINO_BOOL (0 or 1) "c" int * -- MINO_CHAR codepoint (0..0x10FFFF) "v" mino_val ** -- any value (no type check) "V" mino_val ** -- MINO_VECTOR "M" mino_val ** -- MINO_MAP "L" mino_val ** -- MINO_CONS or MINO_NIL (a list) "H" mino_val ** -- MINO_HANDLE "A" mino_val ** -- MINO_ATOM Returns 0 on success, -1 on arity or type error.
• mino_host_enable function: Enable interop dispatch.
• mino_host_register_ctor function: Register host capabilities.
• mino_host_register_method function:
• mino_host_register_static function:
• mino_host_register_getter function:
• mino_resolve_fn typedef: Module resolver callback.
• mino_set_resolver function: Register a module resolver.
• mino_register_bundled_lib function: Register a bundled-stdlib source under `name`.
• MINO_CAP_FLOOR macro: Capabilities are addressable as bits.
• MINO_CAP_REGEX macro:
• MINO_CAP_BIGNUM macro:
• MINO_CAP_MULTIMETHODS macro:
• MINO_CAP_PROTOCOLS macro:
• MINO_CAP_TRANSDUCERS macro:
• MINO_CAP_IO macro:
• MINO_CAP_FS macro:
• MINO_CAP_PROC macro:
• MINO_CAP_STM macro:
• MINO_CAP_AGENT macro:
• MINO_CAP_HOST macro:
• MINO_CAP_ASYNC macro:
• MINO_CAP_STRING_LIB macro:
• MINO_CAP_SET_LIB macro:
• MINO_CAP_WALK macro:
• MINO_CAP_EDN macro:
• MINO_CAP_PPRINT macro:
• MINO_CAP_ZIP macro:
• MINO_CAP_DATA macro:
• MINO_CAP_TEST macro:
• MINO_CAP_REPL_LIB macro:
• MINO_CAP_DATAFY macro:
• MINO_CAP_INSTANT macro:
• MINO_CAP_SPEC macro:
• MINO_CAP_TOOLING macro:
• MINO_CAP_MATH_LIB macro:
• MINO_CAP_REDUCERS macro:
• MINO_CAP_UNIFY macro:
• MINO_CAP_CACHE macro:
• MINO_CAP_MATCH macro:
• MINO_CAP_LOGIC macro:
• MINO_CAP_STORE macro:
• MINO_CAP_ALL macro: Every defined capability bit.
• mino_install function: Install the given set of capabilities into env.
• mino_install_minimal function: Floor-only convenience.
• mino_install_sandbox function: Sandbox preset: equivalent to mino_install(S, env, MINO_CAP_DEFAULT). Names the recipe for "safe untrusted-script env" so embedders don't reinvent the threat model.
• mino_install_all function: Install every capability and every bundled stdlib namespace the standalone binary ships with.
• mino_capabilities function: Inspect installed capabilities.
• mino_capability_installed function:
• mino_capability_info struct: Enumerate the full capability registry.
• mino_capability_list function:
• mino_capability_for_symbol function: Look up the capability that owns a given symbol name, if any.
• mino_option enum: Per-state configuration knobs, set and read through one pair of calls.
• mino_set_option function:
• mino_get_option function: Read a configuration option.
• mino_interrupt function: Request interruption of a running eval.
• mino_thread_count function: Return the count of host threads currently spawned by this state. Decremented as threads complete and join.
• mino_quiesce_threads function: Wait for all in-flight host threads to finish.
• mino_quiesce_threads_timed function: Process-exit variant of mino_quiesce_threads: cancel in-flight futures, then wait up to grace_ms for their worker threads to drain. Returns 1 if every worker exited, 0 if the grace elapsed with a worker still running -- which happens only when a worker is inside an uninterruptible tight loop (a C-side reducer over a huge range, say) that never reaches a cooperative-cancel safepoint.
• mino_thread_pool struct: Function-pointer interface a host thread pool implements.
• mino_set_thread_pool function: Register a host thread pool for this state.
• mino_thread_lifecycle_fn typedef: Per-thread factory hooks for the spawn-per-future path.
• mino_set_thread_factory function:
• mino_gc_kind enum: UNSTABLE: GC tuning, kind enum, phase constants, and the stats struct stay UNSTABLE through the 0.x alpha series.
• mino_gc_collect function:
• mino_gc_param enum: Tunable parameters.
• mino_gc_set_param function:
• MINO_GC_PHASE_IDLE macro: Phase tag returned in mino_gc_stats_out.phase.
• MINO_GC_PHASE_MINOR macro:
• MINO_GC_PHASE_MAJOR_MARK macro:
• MINO_GC_PHASE_MAJOR_SWEEP macro:
• mino_gc_stats_out struct: Collector statistics.
• mino_gc_stats function:
• mino_gc_stats_pauses function: Pause-time distribution accessors.
• mino_gc_pause_hist function:
• mino_alloc_profile_enabled function: UNSTABLE: the allocation profiler is opt-in (compile-time gated on -DMINO_ALLOC_PROFILE=1) and stays UNSTABLE through the 0.x alpha series; its output format is in flux.
• mino_alloc_profile_reset function: Reset the profile counters to zero.
• mino_alloc_profile_dump_top function: Dump the top `top_n` call sites by allocation count to `out` (stderr if NULL).
• MINO_REPL_OK macro: Return codes for mino_repl_feed.
• MINO_REPL_MORE macro:
• MINO_REPL_ERROR macro:
• mino_repl typedef:
• mino_repl_new function: Create a REPL handle that evaluates forms in `env`.
• mino_repl_feed function: Feed one line of input to the REPL.
• mino_repl_free function: Free the REPL handle and its internal buffer.
• mino_ref_new function: Values returned by constructors and eval are borrowed: they survive until the next GC cycle but are not pinned.
• mino_deref function:
• mino_unref function:
• mino_clone function: Deep-copy a value from one state into another.

Language

• clojure.core/* function: Returns the product of the arguments.
• clojure.core/*' function: Returns the product of the arguments.
• clojure.core/*1 function:
• clojure.core/*2 function:
• clojure.core/*3 function:
• clojure.core/*agent* function:
• clojure.core/*assert* function: Controls assertion compilation.
• clojure.core/*clojure-version* function: The Clojure compatibility version for this runtime, as a map with :major :minor :incremental and :qualifier keys.
• clojure.core/*command-line-args* function:
• clojure.core/*compile-files* function:
• clojure.core/*compile-path* function:
• clojure.core/*data-readers* function:
• clojure.core/*default-data-reader-fn* function:
• clojure.core/*e function:
• clojure.core/*err* function:
• clojure.core/*file* function:
• clojure.core/*flush-on-newline* function: When true (the default), the I/O sink behind `*out*` is flushed automatically after any write that contains a newline.
• clojure.core/*in* function:
• clojure.core/*math-context* function: Precision/rounding-mode for bigdec division.
• clojure.core/*ns* function:
• clojure.core/*out* function:
• clojure.core/*print-dup* function: When true, the printer emits forms a reader can reconstruct exactly.
• clojure.core/*print-length* function: Maximum number of items printed in a single collection (vector, list, map, set, chunk, chunked-cons).
• clojure.core/*print-level* function: Maximum nesting depth printed.
• clojure.core/*print-meta* function: When true, every value carrying non-nil metadata is printed with its meta map prefixed as `^{...} `.
• clojure.core/*print-namespace-maps* function: When true, a map whose keys are keywords (or symbols) sharing a common non-empty namespace is printed as `#:ns{:k1 v1, :k2 v2}` instead of `{:ns/k1 v1, :ns/k2 v2}`.
• clojure.core/*print-readably* function: When true (the default), strings are emitted with their quote characters and characters with their escape form so the printed output round-trips through the reader.
• clojure.core/*repl* function: Bound to true in an interactive read-eval-print context, false in script execution.
• clojure.core/*source-path* function:
• clojure.core/*unchecked-math* function:
• clojure.core/*warn-on-reflection* function:
• clojure.core/+ function: Returns the sum of the arguments.
• clojure.core/+' function: Returns the sum of the arguments.
• clojure.core/- function: Returns the difference of the arguments.
• clojure.core/-' function: Returns the difference of the arguments.
• clojure.core/-> function: Thread-first.
• clojure.core/->> function: Thread-last.
• clojure.core/->Eduction function: Factory matching the value (eduction xform coll) returns.
• clojure.core/-empty-queue function: Internal: return an empty PersistentQueue.
• clojure.core/-thread-bound? function: (-thread-bound? var) — true iff the var has a thread-local binding on the current dyn-stack.
• clojure.core/-var-root-bound? function: Return true if the var has a root binding.
• clojure.core// function: Returns the quotient of the arguments.
• clojure.core/< function: Returns true if nums are in monotonically increasing order.
• clojure.core/<= function: Returns true if nums are in monotonically non-decreasing order.
• clojure.core/= function: Returns true if all arguments are equal.
• clojure.core/== function: Returns true if nums are numerically equal, treating ints and floats uniformly.
• clojure.core/> function: Returns true if nums are in monotonically decreasing order.
• clojure.core/>= function: Returns true if nums are in monotonically non-increasing order.
• clojure.core/Boolean/parseBoolean function: Parses "true" (case-insensitive) to true; everything else to false.
• clojure.core/Character/toString function: JVM Character.toString; routes to mino's str.
• clojure.core/CollReduce function:
• clojure.core/CollReduce--coll-reduce function:
• clojure.core/Datafiable function:
• clojure.core/Datafiable--datafy function:
• clojure.core/Double/isInfinite function: True when the argument is +inf or -inf.
• clojure.core/Double/isNaN function: True when the argument is NaN.
• clojure.core/Double/parseDouble function: Parses a floating-point string.
• clojure.core/Float/parseFloat function: Alias for Double/parseDouble; mino has one float tier.
• clojure.core/IKVReduce function:
• clojure.core/IKVReduce--kv-reduce function:
• clojure.core/Inst function:
• clojure.core/Inst--inst-ms* function:
• clojure.core/Integer/parseInt function: Alias for Long/parseLong; mino has one integer tier.
• clojure.core/Integer/toBinaryString function: JVM Integer.toBinaryString; unsigned base-2 digit string.
• clojure.core/Integer/toHexString function: JVM Integer.toHexString; unsigned base-16 digit string.
• clojure.core/Integer/toOctalString function: JVM Integer.toOctalString; unsigned base-8 digit string.
• clojure.core/Long/parseLong function: Parses an integer string.
• clojure.core/Long/toBinaryString function: JVM Long.toBinaryString; unsigned base-2 digit string.
• clojure.core/Long/toHexString function: JVM Long.toHexString; unsigned base-16 digit string.
• clojure.core/Long/toOctalString function: JVM Long.toOctalString; unsigned base-8 digit string.
• clojure.core/Math/abs function: Absolute value (preserves int/double type).
• clojure.core/Math/atan function: Arctangent.
• clojure.core/Math/atan2 function: Two-argument arctangent.
• clojure.core/Math/ceil function: Ceiling (rounds toward positive infinity).
• clojure.core/Math/cos function: Cosine (radians).
• clojure.core/Math/exp function: e^x.
• clojure.core/Math/floor function: Floor (rounds toward negative infinity).
• clojure.core/Math/log function: Natural log.
• clojure.core/Math/log10 function: Base-10 log.
• clojure.core/Math/max function: Numeric maximum of two values.
• clojure.core/Math/min function: Numeric minimum of two values.
• clojure.core/Math/pow function: Exponentiation.
• clojure.core/Math/round function: Round to nearest long.
• clojure.core/Math/sin function: Sine (radians).
• clojure.core/Math/sqrt function: Square root.
• clojure.core/Math/tan function: Tangent (radians).
• clojure.core/NaN? function: Returns true if x is NaN.
• clojure.core/Navigable function:
• clojure.core/Navigable--nav function:
• clojure.core/String/valueOf function: JVM String.valueOf; routes to mino's str.
• clojure.core/System/currentTimeMillis function: Epoch millis from the host clock.
• clojure.core/System/exit function: Exits the host process with the given status code.
• clojure.core/System/getProperty function: JVM system-properties lookup.
• clojure.core/System/getenv function: Reads an environment variable from the host process.
• clojure.core/System/nanoTime function: Monotonic nanosecond counter from the host clock.
• clojure.core/Thread/sleep function: Suspends the current thread for the given number of milliseconds.
• clojure.core/Throwable->map function: Constructs a data representation of an error value, shaped {:cause m :data d :via [...] :trace []}: :cause is the root cause's message, :data its ex-data (absent when nil), :via a vector of {:type <symbol> :message <str> :at [] :data <optional>} maps from the outermost error to the root, and :trace an empty vector (mino error values do not retain call-stack frames). Works on caught diagnostic maps and on ex-info values alike; the cause chain is walked via ex-cause.
• clojure.core/abs function: Returns the absolute value of x.
• clojure.core/add-load-path! function: Appends a directory to the runtime's extra-load-paths list (consulted by `require` after project paths).
• clojure.core/add-tap function: Registers f as a tap target.
• clojure.core/add-watch function: Adds a watch function to an atom, called on state changes.
• clojure.core/agent function: Creates an asynchronous agent holding the given initial state.
• clojure.core/agent-error function: Returns the exception captured by the agent's most recent failed action or watch, or nil if the agent is in a clean state. Capability: :agent
• clojure.core/agent? function: Returns true if x is an agent. Capability: :agent
• clojure.core/aget function: Reads slot `index` from a host array or a bytes value.
• clojure.core/alength function: Returns the slot count of a host array or the byte length of a bytes value.
• clojure.core/alias function: Add an alias to a namespace.
• clojure.core/all-ns function: Return a vector of all known namespace symbols.
• clojure.core/alloc-profile-dump! function: Dump the top-N allocation call sites to stderr.
• clojure.core/alloc-profile-enabled? function: Returns true if this binary was built with -DMINO_ALLOC_PROFILE=1.
• clojure.core/alloc-profile-reset! function: Zero the per-callsite allocation counters.
• clojure.core/alter function: Sets ref to (apply f current-value args).
• clojure.core/alter-meta! function: Atomically applies f to the metadata of a reference.
• clojure.core/alter-var-root function: Apply a function to a var's root and store the result.
• clojure.core/ancestors function: Returns all ancestors of tag in the hierarchy.
• clojure.core/and function: Returns the first falsy value, or the last value if all are truthy.
• clojure.core/any? function: Returns true for any argument.
• clojure.core/apply function: Applies f to the arguments, with the last argument spread as a sequence.
• clojure.core/array-map function: Creates a hash-map.
• clojure.core/as-> function: Binds expr to sym, then threads it through each form where sym can appear anywhere.
• clojure.core/aset function: Mutates the host array at index, storing val.
• clojure.core/assert function:
• clojure.core/assoc function: Returns a new map with the given key-value pairs added.
• clojure.core/assoc! function: Associates key with val in a transient map or vector.
• clojure.core/assoc-in function: Associates a value in a nested associative structure at the given key path.
• clojure.core/associative? function: Returns true if x supports assoc (maps and vectors).
• clojure.core/async-next-timer-ms* function: Milliseconds until the next pending timer, or nil when none. Capability: :async
• clojure.core/async-sched-enqueue* function: Enqueue a callback on the async scheduler run queue. Capability: :async
• clojure.core/async-schedule-timer* function: Schedule a callback to fire after ms milliseconds. Capability: :async
• clojure.core/atom function: Creates an atom with the given initial value.
• clojure.core/atom? function: Returns true if x is an atom.
• clojure.core/await function: Blocks the calling thread until every named agent's queued actions have finished.
• clojure.core/await-for function: Like await with a millisecond timeout.
• clojure.core/bigdec function: Coerces a value to an arbitrary-precision decimal. Capability: :bignum
• clojure.core/bigint function: Coerces a value to an arbitrary-precision integer.
• clojure.core/bigint? function: Returns true if x is an arbitrary-precision integer. Capability: :bignum
• clojure.core/biginteger function: Alias of bigint.
• clojure.core/binding function: Establishes thread-local bindings for dynamic vars over the extent of the body, restoring the prior roots when the body returns or unwinds.
• clojure.core/bit-and function: Returns the bitwise AND of the arguments.
• clojure.core/bit-and-not function: Returns the bitwise AND of x and the complement of y.
• clojure.core/bit-clear function: Returns x with bit n cleared.
• clojure.core/bit-flip function: Returns x with bit n flipped.
• clojure.core/bit-not function: Returns the bitwise complement of n.
• clojure.core/bit-or function: Returns the bitwise OR of the arguments.
• clojure.core/bit-set function: Returns x with bit n set.
• clojure.core/bit-shift-left function: Returns n shifted left by count bits.
• clojure.core/bit-shift-right function: Returns n arithmetically shifted right by count bits.
• clojure.core/bit-test function: Returns true if bit n of x is set.
• clojure.core/bit-xor function: Returns the bitwise XOR of the arguments.
• clojure.core/bits function: Pack a sequence of [value & options] segments into an immutable MINO_BYTES value.
• clojure.core/bits-get function: Read a bit field out of a bytes value.
• clojure.core/bitstring? function: Returns true if x is any mino bytes value -- byte-aligned or bit-aligned.
• clojure.core/boolean function: Coerces x to a boolean value.
• clojure.core/boolean-array function: Creates a host-style boolean array.
• clojure.core/boolean? function: Returns true if x is true or false.
• clojure.core/bound-fn function: Returns a function defined by the given fntail, which will install the same bindings in effect as in the thread at the time bound-fn was called.
• clojure.core/bound-fn* function: Returns a function which installs the same bindings in effect as in the thread at the time bound-fn* was called and then invokes f.
• clojure.core/bound? function: Returns true if all of the vars provided as arguments have any bindings — either a root binding or a thread-local binding.
• clojure.core/bounded-count function: Returns the count of coll, but stops counting at n.
• clojure.core/butlast function: Returns a seq of all but the last item in coll.
• clojure.core/byte function: Coerces x to a byte (8-bit integer).
• clojure.core/byte-array function: Creates a host-style byte array.
• clojure.core/bytes? function: Returns true if x is a byte-aligned mino bytes value (the immutable binary-data type returned by byte-array).
• clojure.core/car function: Returns the first element of a cons cell.
• clojure.core/case function: Dispatches on the value of expr.
• clojure.core/cat function: A transducer that concatenates the contents of each input.
• clojure.core/cdr function: Returns the rest of a cons cell.
• clojure.core/chan-buf-add function: Direct buffer push: (chan-buf-add ch val).
• clojure.core/chan-buf-count function: Number of buffered values. Capability: :async
• clojure.core/chan-buf-full? function: True if buffer is full (or unbuffered/promise-set). Capability: :async
• clojure.core/chan-close function: Close channel: (chan-close ch). Capability: :async
• clojure.core/chan-closed? function: True if channel is closed. Capability: :async
• clojure.core/chan-flush-buf-to-takers function: Wake every parked taker with a buffered value handoff. Capability: :async
• clojure.core/chan-get-ex-handler function: Read installed ex-handler, or nil if none. Capability: :async
• clojure.core/chan-get-xform function: Read installed transducer rf, or nil if none. Capability: :async
• clojure.core/chan-has-pending-putter? function: True if any non-committed putter is parked. Capability: :async
• clojure.core/chan-has-pending-taker? function: True if any non-committed taker is parked. Capability: :async
• clojure.core/chan-instance? function: True if x is a channel (MINO_CHAN tag).
• clojure.core/chan-new function: Construct a channel: (chan-new buf-kind buf-cap xform ex-handler). Capability: :async
• clojure.core/chan-offer function: Non-blocking put: (chan-offer ch val).
• clojure.core/chan-poll function: Non-blocking take: (chan-poll ch).
• clojure.core/chan-put function: Async put: (chan-put ch val cb-or-nil). Capability: :async
• clojure.core/chan-put-alts function: alts-flavoured put: (chan-put-alts ch val cb flag). Capability: :async
• clojure.core/chan-set-xform function: Install transducer rf: (chan-set-xform ch rf ex-handler). Capability: :async
• clojure.core/chan-take function: Async take: (chan-take ch cb-or-nil). Capability: :async
• clojure.core/chan-take-alts function: alts-flavoured take: (chan-take-alts ch cb flag). Capability: :async
• clojure.core/char function: Coerces x to a character: integer codepoint (0..0x10FFFF) becomes the Unicode scalar value, character is identity.
• clojure.core/char-array function: Creates a host-style char array.
• clojure.core/char-at function: Returns the character at the given index as a string.
• clojure.core/char-escape-string function: Returns escape string for char or nil if none.
• clojure.core/char-name-string function: Returns name string for char or nil if none.
• clojure.core/char? function: Returns true if x is a one-character string.
• clojure.core/chdir function: Changes the current working directory. Capability: :io
• clojure.core/chunk function: Seals chunk-buffer buf so no further appends are accepted, and returns the chunk.
• clojure.core/chunk-append function: Appends elem to chunk-buffer buf and returns buf.
• clojure.core/chunk-buffer function: Returns a fresh chunk-buffer of the given capacity.
• clojure.core/chunk-cons function: Returns a chunked seq prepending the given chunk to the seq more.
• clojure.core/chunk-first function: Returns the chunk at the head of a chunked seq.
• clojure.core/chunk-next function: Returns the rest of a chunked seq as a seq, or nil if empty.
• clojure.core/chunk-rest function: Returns the rest of a chunked seq after the head chunk, or () if none.
• clojure.core/chunked-seq? function: Returns true if x is a chunked seq.
• clojure.core/class function: Returns the concrete type tag keyword of a value, like type but ignoring :type metadata; (class nil) is nil.
• clojure.core/clojure-version function: Returns the Clojure compatibility version as a printable string.
• clojure.core/coll-reduce function:
• clojure.core/coll? function: Returns true if x is a collection.
• clojure.core/comment function: Ignores body, returns nil.
• clojure.core/commute function: Sets ref to (apply f current-value args).
• clojure.core/comp function: Returns a function that is the composition of the given functions.
• clojure.core/comparator function: Returns a comparator function from a two-arg predicate.
• clojure.core/compare function: Returns a negative, zero, or positive integer comparing x and y.
• clojure.core/compare-and-set! function: Atomically sets the atom to new-val if its current value equals expected.
• clojure.core/complement function: Returns a function that returns the logical opposite of f.
• clojure.core/completing function: Returns a reducing function with a completion step.
• clojure.core/concat function: Returns a lazy sequence of the concatenation of the given collections.
• clojure.core/cond function: Takes pairs of test/expr.
• clojure.core/cond-> function: Thread-first through forms whose tests are truthy.
• clojure.core/cond->> function: Thread-last through forms whose tests are truthy.
• clojure.core/condp function: Takes a binary predicate, an expression, and clauses.
• clojure.core/conj function: Returns a new collection with items added.
• clojure.core/conj! function: Conjoins val onto a transient vector, map, or set.
• clojure.core/cons function: Returns a new list with x prepended to coll.
• clojure.core/cons? function: Returns true if x is a list (cons cell).
• clojure.core/constantly function: Returns a function that always returns x.
• clojure.core/contains? function: Returns true if the collection contains the key.
• clojure.core/count function: Returns the number of items in a collection.
• clojure.core/counted? function: Returns true if (count x) is a constant-time operation.
• clojure.core/create-ns function: Ensure the namespace exists and return its symbol.
• clojure.core/cycle function: Returns a lazy infinite sequence of repetitions of the items in coll.
• clojure.core/datafy function:
• clojure.core/dec function: Returns x minus 1.
• clojure.core/dec' function: Returns x minus 1.
• clojure.core/decimal? function: Returns true if x is an arbitrary-precision decimal. Capability: :bignum
• clojure.core/declare function: Interns one or more names as unbound vars so they can be referred to before their defining form appears.
• clojure.core/dedupe function: Returns a lazy sequence removing consecutive duplicates.
• clojure.core/default-data-readers function: Default map of data reader functions keyed by tag symbol: 'inst and 'uuid.
• clojure.core/definterface function:
• clojure.core/defmacro function: Defines a macro: a named function, invoked at expansion time, whose return value replaces the calling form before it is evaluated.
• clojure.core/defmethod function: Defines a method for a multimethod.
• clojure.core/defmulti function: Defines a multimethod with the given dispatch function.
• clojure.core/defn function: Defines a named function.
• clojure.core/defn- function: Same as defn, yielding a non-public def.
• clojure.core/defonce function: Defines name only if it has no root binding.
• clojure.core/defprotocol function: Defines a protocol with the given method signatures.
• clojure.core/defrecord function: Defines a record type Name with the given fields and optional inline protocol specs.
• clojure.core/defrecord* function: Runtime constructor for record types.
• clojure.core/deftype function: Alias for defrecord.
• clojure.core/delay function: Creates a delay that evaluates body on first deref.
• clojure.core/delay? function: Returns true if x is a delay.
• clojure.core/deliver function: Deliver a value to a promise.
• clojure.core/denominator function: Returns the denominator of a rational number. Capability: :bignum
• clojure.core/deref function: Returns the current value of a reference (atom, delay, etc.).
• clojure.core/deref-delay function: Forces evaluation of a delay and returns its value.
• clojure.core/derive function: Establishes a parent/child relationship between child and parent in a hierarchy.
• clojure.core/descendants function: Returns all descendants of tag in the hierarchy.
• clojure.core/destructure function: Takes a binding-pairs vector [lhs1 rhs1 lhs2 rhs2 ...] and returns a flat vector of [name init ...] suitable as a let binding form.
• clojure.core/directory? function: Returns true if the path is a directory. Capability: :fs
• clojure.core/disj function: Returns a set with the given keys removed.
• clojure.core/disj! function: Removes key from a transient set.
• clojure.core/dissoc function: Returns a map with the given keys removed.
• clojure.core/dissoc! function: Removes key from a transient map.
• clojure.core/distinct function: Returns a lazy sequence of the distinct items in coll.
• clojure.core/distinct? function: Returns true if no two of the arguments are equal.
• clojure.core/doall function: Forces realization of a lazy sequence.
• clojure.core/dorun function: Forces realization of a lazy sequence.
• clojure.core/doseq function: Iterates over collections for side effects, evaluating body once per binding combination, and returns nil.
• clojure.core/dosync function: Runs body in an STM transaction.
• clojure.core/dosync* function: Runs a zero-arg thunk inside an STM transaction.
• clojure.core/dotimes function: Evaluates body n times with sym bound to 0 through n-1.
• clojure.core/doto function: Evaluates x, then calls each form with x as the first argument. Returns x.
• clojure.core/double function: Coerces x to a 64-bit double (returns a MINO_FLOAT).
• clojure.core/double-array function: Creates a host-style double array.
• clojure.core/double? function: Returns true if x is a 64-bit double (mino's `:float` tier). Distinct from `float?`, which also returns true for the 32-bit `:float32` tier produced by `(float x)`.
• clojure.core/drain! function: Drain the async run queue once. Capability: :async
• clojure.core/drain-loop! function: Drain until done-thunk returns truthy or no progress. Capability: :async
• clojure.core/drop function: Returns a lazy sequence of all but the first n items in coll.
• clojure.core/drop-last function: Returns a lazy sequence of all but the last n items in coll.
• clojure.core/drop-seq function: Internal fast path for eager drop.
• clojure.core/drop-while function: Returns a lazy sequence of items from coll after pred returns falsy.
• clojure.core/eduction function: Returns a lazy sequence of applying the given transducers to coll.
• clojure.core/empty function: Returns an empty collection of the same type.
• clojure.core/empty? function: Returns true if coll has no items.
• clojure.core/ensure function: Reads ref and prevents any other transaction from changing it before this transaction commits.
• clojure.core/ensure-reduced function: Wraps x in reduced if it is not already reduced.
• clojure.core/error-handler function: Returns the agent's current error-handler fn or nil. Capability: :agent
• clojure.core/error-mode function: Returns the agent's current error mode. Capability: :agent
• clojure.core/error? function: Returns true if the value is a diagnostic map.
• clojure.core/eval function: Evaluates the given form.
• clojure.core/even? function: Returns true if x is an even integer.
• clojure.core/every-pred function: Returns a function that returns true when all preds are satisfied by all its arguments.
• clojure.core/every? function: Returns true if (pred x) is truthy for every x in coll.
• clojure.core/ex-cause function: Returns the cause attached to the given exception, or nil.
• clojure.core/ex-data function: Extract the data map from an exception.
• clojure.core/ex-info function: Create an exception map with a message and data map.
• clojure.core/ex-message function: Extract the message from an exception.
• clojure.core/exit function: Exits the process with the given status code. Capability: :io
• clojure.core/extend function: Registers method implementations for one or more protocols on type t without generating wrapper code: (extend T P {:m (fn [x] ...)}). The fn-map keys are keywordized method names; values are the implementation fns.
• clojure.core/extend-protocol function: Extends a protocol with implementations for multiple types.
• clojure.core/extend-type function: Extends a protocol with method implementations for the given type.
• clojure.core/extenders function: Returns a seq of the types explicitly extended to proto, or nil when there are none.
• clojure.core/extends? function: Returns true if type t has been extended to proto (an explicit registration for at least one method; :default does not count).
• clojure.core/false? function: Returns true if x is the value false.
• clojure.core/ffirst function: Returns the first item of the first item in coll.
• clojure.core/file-exists? function: Returns true if the path exists (file or directory). Capability: :fs
• clojure.core/file-mtime function: Returns the file modification time in milliseconds, or nil. Capability: :fs
• clojure.core/file-seq function: Returns a vector of all file paths under a directory, recursively. Capability: :io
• clojure.core/filter function: Returns a lazy sequence of items in coll for which pred returns truthy.
• clojure.core/filterv function: Returns a vector of items in coll for which pred returns logical true.
• clojure.core/find function: Returns the map entry for the key, or nil.
• clojure.core/find-keyword function: Returns the keyword for the given string.
• clojure.core/find-ns function: Return the namespace symbol if it exists, else nil.
• clojure.core/find-var function: Return the var named by a qualified symbol, or nil.
• clojure.core/first function: Returns the first item in a collection, or nil if empty.
• clojure.core/flatten function: Returns a lazy sequence of the non-sequential items from a nested structure.
• clojure.core/float function: Coerces x to a 32-bit float (returns a MINO_FLOAT32).
• clojure.core/float-array function: Creates a host-style float array.
• clojure.core/float? function: Returns true if x is a float.
• clojure.core/flush function: Flushes pending output on *out* and *err*.
• clojure.core/fn function: Defines an anonymous function.
• clojure.core/fn? function: Returns true if x is callable as a function (fn or prim).
• clojure.core/fnext function: Same as (first (next coll)).
• clojure.core/fnil function: Returns a function like f, but replaces nil arguments with the given defaults.
• clojure.core/for function: List comprehension.
• clojure.core/force function: Forces evaluation of a delay.
• clojure.core/format function: Returns a formatted string using a format specifier and arguments.
• clojure.core/frequencies function: Returns a map from distinct items in coll to the number of times they appear.
• clojure.core/future function: Takes a body of expressions and yields a future object that will evaluate the body in another thread, blocking on deref until the value is available.
• clojure.core/future-call function: Spawn a worker thread to evaluate the given thunk; return a future.
• clojure.core/future-cancel function: Cancel a pending future.
• clojure.core/future-cancelled? function: Return true if the future was cancelled.
• clojure.core/future-deref function: Block until the future is realized; return result, rethrow exception, or throw :mino/cancelled.
• clojure.core/future-done? function: Return true if the future has reached a terminal state (resolved/failed/cancelled).
• clojure.core/future? function: Return true if x is a future or promise.
• clojure.core/gc! function: Forces a full garbage collection.
• clojure.core/gc-stats function: Returns a map of GC statistics. Capability: :io
• clojure.core/gen-class function:
• clojure.core/gensym function: Returns a new symbol with a unique name.
• clojure.core/get function: Returns the value mapped to key in a collection, or not-found.
• clojure.core/get-in function: Returns the value in a nested associative structure at the given key path.
• clojure.core/get-method function: Returns the method for dispatch-val, or nil.
• clojure.core/get-thread-bindings function: Returns a map of symbol->value for the active dynamic bindings, or nil if no binding frames are active.
• clojure.core/get-validator function: Returns the validator function of an atom, or nil.
• clojure.core/getcwd function: Returns the current working directory. Capability: :io
• clojure.core/getenv function: Returns the value of an environment variable, or nil. Capability: :io
• clojure.core/group-by function: Returns a map of the items in coll grouped by the result of f.
• clojure.core/halt-when function: Returns a transducer that halts reduction when pred is satisfied.
• clojure.core/hash function: Returns the hash code of the value.
• clojure.core/hash-combine function: Boost-style hash combiner: mixes seed and hash into a single 32-bit hash.
• clojure.core/hash-map function: Returns a new hash map with the given key-value pairs.
• clojure.core/hash-ordered-coll function: Computes a sequence-position-aware hash for an ordered collection.
• clojure.core/hash-set function: Returns a new hash set containing the arguments.
• clojure.core/hash-unordered-coll function: Computes a position-independent hash for an unordered collection.
• clojure.core/host/call function: Calls a method on a host handle. Capability: :host
• clojure.core/host/get function: Returns the value of a field on a host handle. Capability: :host
• clojure.core/host/new function: Creates a new instance of a host-registered type. Capability: :host
• clojure.core/host/static-call function: Calls a static method on a host-registered type. Capability: :host
• clojure.core/ident? function: Returns true if x is a symbol or keyword.
• clojure.core/identical? function: Returns true if the arguments are the same object.
• clojure.core/identity function: Returns its argument.
• clojure.core/if-let function: Binds the result of expr, evaluates then if truthy, else otherwise.
• clojure.core/if-not function: Evaluates then when test is falsy, else otherwise.
• clojure.core/if-some function: Binds the result of expr, evaluates then if non-nil, else otherwise.
• clojure.core/ifn? function: Returns true if x can be called as a function.
• clojure.core/import function:
• clojure.core/in-ns function: Set the current namespace, creating it if necessary.
• clojure.core/in-transaction? function: Returns true when called from inside a `dosync` body. Capability: :stm
• clojure.core/inc function: Returns x plus 1.
• clojure.core/inc' function: Returns x plus 1.
• clojure.core/indexed? function: Returns true if x supports nth in constant time (vectors).
• clojure.core/infinite? function: Returns true if x is positive or negative infinity.
• clojure.core/inst-ms function: Returns epoch millis (since 1970-01-01T00:00:00Z) for an inst value as returned by clojure.instant/read-instant-date or the `#inst "..."` reader literal.
• clojure.core/inst-ms* function:
• clojure.core/inst? function:
• clojure.core/instance? function: Returns true if x is an instance of t.
• clojure.core/int function: Coerces x to an int (32-bit integer).
• clojure.core/int-array function: Creates a host-style int array.
• clojure.core/int? function: Returns true if x is an integer.
• clojure.core/integer? function: Returns true if x is an integer (long or bigint).
• clojure.core/interleave function: Returns a lazy sequence of the first item in each collection, then the second, and so on.
• clojure.core/intern function: Intern a value into a namespace by name.
• clojure.core/internal-reduce function:
• clojure.core/internal-reduce-kv function:
• clojure.core/interpose function: Returns a lazy sequence of the items in coll separated by sep.
• clojure.core/into function: Adds all items from from into to.
• clojure.core/into-array function: Converts a collection to an Object array.
• clojure.core/io! function: If invoked within an STM transaction, throws an IllegalStateException-equivalent before evaluating body.
• clojure.core/io!-check function: Internal: throws when called inside a transaction.
• clojure.core/isa? function: Returns true if child is equal to or derives from parent.
• clojure.core/iterate function: Returns a lazy sequence of x, (f x), (f (f x)), and so on.
• clojure.core/iteration function: Creates a seqable via repeated calls to step, a function of some continuation token 'k'.
• clojure.core/java.util.List/of function: JVM List.of static; routes to mino's list constructor.
• clojure.core/java.util.Map/of function: JVM Map.of static; routes to mino's hash-map constructor.
• clojure.core/java.util.Set/of function: JVM Set.of static; routes to mino's hash-set constructor.
• clojure.core/java.util.UUID/fromString function: Parses a UUID from its canonical string form.
• clojure.core/java.util.UUID/randomUUID function: Generates a random UUID v4.
• clojure.core/juxt function: Returns a function that returns a vector of applying each f to its args.
• clojure.core/keep function: Returns a lazy sequence of non-nil results of (f item).
• clojure.core/keep-indexed function: Returns a lazy sequence of non-nil results of (f index item). When called with no collection, returns a transducer.
• clojure.core/key function: Returns the key of a map entry.
• clojure.core/keys function: Returns a sequence of the keys in a map.
• clojure.core/keyword function: Returns a keyword with the given name.
• clojure.core/keyword? function: Returns true if x is a keyword.
• clojure.core/kv-reduce function:
• clojure.core/last function: Returns the last item in coll.
• clojure.core/last-error function: Returns the last error as a diagnostic map, or nil.
• clojure.core/lazy-cat function: Expands to code that yields a lazy concatenation of the given collections.
• clojure.core/lazy-filter function: Internal fast path for lazy filter.
• clojure.core/lazy-map-1 function: Internal fast path for single-collection lazy map.
• clojure.core/lazy-seq function: Returns a sequence whose body is not evaluated until the first element is requested, then caches the realized sequence for later traversals.
• clojure.core/lazy-take function: Internal fast path for lazy take.
• clojure.core/let function: Evaluates the body with a sequence of local bindings established left to right from the binding vector; later bindings may refer to earlier ones.
• clojure.core/let-bits function: Destructure-shaped binding over a bytes value. (let-bits [bytes-val [sym & opts] ...] body...) See documentation in core.clj just above this definition.
• clojure.core/letfn function: Binds local functions.
• clojure.core/line-seq function: Returns the lines of text from rdr as a lazy sequence of strings. rdr is a string-cursor atom (the *in* model that read-line consumes from): each realized element takes one line off the cursor.
• clojure.core/list function: Returns a list of the supplied arguments; () with no args.
• clojure.core/list* function: Creates a new list containing the items prepended to the rest, the last of which will be treated as a sequence.
• clojure.core/list? function: Returns true if x is a list (cons chain or the empty-list singleton).
• clojure.core/load-file function: Reads and evaluates all forms in the file at the given path.
• clojure.core/load-image-into function: Load an image file into the current state. Capability: :fs
• clojure.core/load-string function: Reads and evaluates all forms in the given source string.
• clojure.core/loaded-libs function: Return a vector of names that have been required.
• clojure.core/locking function: Executes body while holding a monitor of x.
• clojure.core/long function: Coerces x to a long (64-bit integer).
• clojure.core/long-array function: Creates a host-style long array.
• clojure.core/loop function: Like let, but establishes a recursion point: a recur in tail position rebinds the loop locals and jumps back to the top without growing the stack.
• clojure.core/macroexpand function: Repeatedly expands a macro form until it is no longer a macro call.
• clojure.core/macroexpand-1 function: Expands a macro form once.
• clojure.core/make-hierarchy function: Returns an empty hierarchy.
• clojure.core/map function: Returns a lazy sequence of applying f to each item in coll.
• clojure.core/map-entry function: Constructs a (k, v) map entry.
• clojure.core/map-entry? function: Returns true if x is a map entry (mino represents entries as 2-vectors).
• clojure.core/map-indexed function: Returns a lazy sequence of (f index item) for each item in coll. When called with no collection, returns a transducer.
• clojure.core/map? function: Returns true if x is a map (including sorted-map).
• clojure.core/mapcat function: Returns the result of applying concat to the result of mapping f over coll.
• clojure.core/mapv function: Returns a vector of applying f to each item in one or more collections.
• clojure.core/math-acos function: Returns the arc-cosine of n; n in [-1, 1]; result in [0, PI].
• clojure.core/math-asin function: Returns the arc-sine of n; n in [-1, 1]; result in [-PI/2, PI/2].
• clojure.core/math-atan function: Returns the arc-tangent of n; result in [-PI/2, PI/2].
• clojure.core/math-atan2 function: Returns the angle in radians between the positive x-axis and the point (x, y).
• clojure.core/math-cbrt function: Returns the cube root of n.
• clojure.core/math-ceil function: Returns the smallest integer not less than n.
• clojure.core/math-copy-sign function: Returns a value with the magnitude of mag and the sign of sgn.
• clojure.core/math-cos function: Returns the cosine of n (in radians).
• clojure.core/math-cosh function: Returns the hyperbolic cosine of n.
• clojure.core/math-exp function: Returns e raised to the power of n.
• clojure.core/math-expm1 function: Returns exp(n) - 1, accurate for small n.
• clojure.core/math-floor function: Returns the largest integer not greater than n.
• clojure.core/math-get-exponent function: Returns the unbiased binary exponent of n.
• clojure.core/math-hypot function: Returns sqrt(a^2 + b^2) avoiding intermediate overflow.
• clojure.core/math-ieee-remainder function: Returns IEEE 754 remainder of a by b.
• clojure.core/math-log function: Returns the natural logarithm of n.
• clojure.core/math-log10 function: Returns the base-10 logarithm of n.
• clojure.core/math-log1p function: Returns the natural logarithm of (1 + n), accurate for small n.
• clojure.core/math-next-after function: Returns the adjacent double to start in the direction of direction.
• clojure.core/math-next-down function: Returns the next representable double less than n (toward -Inf).
• clojure.core/math-next-up function: Returns the next representable double greater than n (toward +Inf).
• clojure.core/math-pow function: Returns base raised to the power of exp.
• clojure.core/math-rint function: Returns the double closest to n and equal to a mathematical integer, ties to even.
• clojure.core/math-round function: Returns the closest integer to n.
• clojure.core/math-scalb function: Returns n scaled by 2 to the power of the integer scale factor.
• clojure.core/math-signum function: Returns -1.0, 0.0, or 1.0 depending on the sign of n (preserves -0.0).
• clojure.core/math-sin function: Returns the sine of n (in radians).
• clojure.core/math-sinh function: Returns the hyperbolic sine of n.
• clojure.core/math-sqrt function: Returns the square root of n.
• clojure.core/math-tan function: Returns the tangent of n (in radians).
• clojure.core/math-tanh function: Returns the hyperbolic tangent of n.
• clojure.core/math-to-degrees function: Converts the angle n (in radians) to degrees.
• clojure.core/math-to-radians function: Converts the angle n (in degrees) to radians.
• clojure.core/math-ulp function: Returns the size of an ulp (unit in last place) of n.
• clojure.core/max function: Returns the greatest of the given values.
• clojure.core/max-key function: Returns the x for which (k x) is greatest.
• clojure.core/memoize function: Returns a memoized version of f that caches return values by arguments.
• clojure.core/merge function: Returns a map that is the merge of the maps.
• clojure.core/merge-with function: Returns the merge of the given maps, calling f to combine values at shared keys.
• clojure.core/meta function: Returns the metadata map of the given value, or nil.
• clojure.core/methods function: Returns the method table of multimethod mm.
• clojure.core/min function: Returns the least of the given values.
• clojure.core/min-key function: Returns the x for which (k x) is least.
• clojure.core/mino-capability function: Return the install-group capability label for the named binding as a keyword, or nil when the binding is part of the always-installed core.
• clojure.core/mino-installed? function: Returns true if a named capability has been installed on this runtime.
• clojure.core/mino-thread-count function: Return the live host-thread count for this state.
• clojure.core/mino-thread-id* function: Stable identity of the calling thread's runtime context.
• clojure.core/mino-thread-limit function: Return the host-granted thread limit for this state.
• clojure.core/mix-collection-hash function: Combines a hash-basis with the collection's count.
• clojure.core/mkdir-p function: Creates a directory and any missing parent directories. Capability: :fs
• clojure.core/mod function: Returns the modulus of dividing num by div.
• clojure.core/monitor-exit function: Release one level of x for owner; drops the entry at depth zero.
• clojure.core/monitor-registry function:
• clojure.core/monitor-try-enter function: Claim x for owner, or reenter if owner already holds it.
• clojure.core/name function: Returns the name string of a symbol, keyword, or string.
• clojure.core/namespace function: Returns the namespace string of a symbol or keyword, or nil.
• clojure.core/nano-time function: Returns monotonic wall-clock time in nanoseconds. Capability: :io
• clojure.core/nat-int? function: Returns true if x is a non-negative integer (long tier).
• clojure.core/nav function:
• clojure.core/neg-int? function: Returns true if x is a negative integer (long tier).
• clojure.core/neg? function: Returns true if x is less than zero.
• clojure.core/newline function: Writes a line separator to *out*.
• clojure.core/next function: Returns a seq of the items after the first.
• clojure.core/nfirst function: Same as (next (first coll)).
• clojure.core/nil? function: Returns true if x is nil.
• clojure.core/nnext function: Same as (next (next coll)).
• clojure.core/not function: Returns true if x is logical false, false otherwise.
• clojure.core/not-any? function: Returns true if (pred x) is falsy for every x in coll.
• clojure.core/not-empty function: Returns coll if it has items, nil otherwise.
• clojure.core/not-every? function: Returns true if (pred x) is falsy for at least one x in coll.
• clojure.core/not= function: Returns true if the arguments are not equal.
• clojure.core/ns function: Selects or creates a namespace and applies its require / refer / import clauses, becoming the current namespace for the forms that follow.
• clojure.core/ns-aliases function: Return the alias map of a namespace.
• clojure.core/ns-imports function: Returns the import map of the namespace (always empty: no host classes).
• clojure.core/ns-interns function: Return the interned bindings of a namespace as a map.
• clojure.core/ns-map function: Return all bindings visible in a namespace as a map.
• clojure.core/ns-name function: Return the symbol name of a namespace.
• clojure.core/ns-publics function: Return the public bindings of a namespace as a map.
• clojure.core/ns-refers function: Return the refer'd bindings of a namespace as a map.
• clojure.core/ns-resolve function: Resolve a symbol to a var in the given namespace.
• clojure.core/ns-unalias function: Remove an alias from a namespace.
• clojure.core/ns-unmap function: Remove a binding from a namespace.
• clojure.core/nth function: Returns the item at index n in a collection.
• clojure.core/nthnext function: Returns the result of calling next n times on coll.
• clojure.core/nthrest function: Returns the result of calling rest n times on coll.
• clojure.core/num function: Returns x if it is a number, nil if x is nil, otherwise throws. Nil pass-through matches the cross-dialect convention used by the `:default` arm of `clojure.core-test.num` (no-op on numeric inputs plus nil), where JVM Clojure's NPE-on-nil is platform-specific.
• clojure.core/number? function: Returns true if x is a number (int or float).
• clojure.core/numerator function: Returns the numerator of a rational number. Capability: :bignum
• clojure.core/object-array function: Creates a host-style Object array.
• clojure.core/odd? function: Returns true if x is an odd integer.
• clojure.core/or function: Returns the first truthy value, or the last value if none are truthy.
• clojure.core/parents function: Returns the immediate parents of tag in the hierarchy.
• clojure.core/parse-boolean function: Parses 'true' or 'false' (case-sensitive) and returns the boolean. Returns nil for strings that don't match.
• clojure.core/parse-double function: Parses a string into a double, or returns nil on failure.
• clojure.core/parse-long function: Parses a string into a long integer, or returns nil on failure.
• clojure.core/parse-uuid function: Parses s as a UUID; returns a UUID value or nil if s is not a valid canonical UUID string.
• clojure.core/partial function: Returns a function that applies f with the given arguments prepended.
• clojure.core/partition function: Returns a lazy sequence of lists of n items each, at offsets step apart.
• clojure.core/partition-all function: Like partition, but includes a final partial group if items remain. The transducer arity emits each group as a vector (matching JVM Clojure's `(vec (.toArray buf))`); the seq arities emit lists per `partition`'s shape.
• clojure.core/partition-by function: Splits coll into lazy sequences of consecutive items with the same (f item) value.
• clojure.core/partitionv function: Like partition but returns a lazy seq of vectors instead of lists.
• clojure.core/partitionv-all function: Like partition-all but returns a lazy seq of vectors instead of lists.
• clojure.core/pcalls function: Executes the no-arg fns in parallel, returning a lazy sequence of their values.
• clojure.core/peek function: Returns the first item of a list or last item of a vector.
• clojure.core/persistent! function: Seals a transient and returns its persistent collection.
• clojure.core/pmap function: Like map, except f is applied in parallel via futures.
• clojure.core/pop function: Returns a collection without the peek item.
• clojure.core/pop! function: Removes the last element from a transient vector.
• clojure.core/pop-thread-bindings function: Pop the topmost dynamic-binding frame.
• clojure.core/pop-thread-bindings* function: (pop-thread-bindings*) — pop and free the top dynamic-binding frame.
• clojure.core/pos-int? function: Returns true if x is a positive integer (long tier).
• clojure.core/pos? function: Returns true if x is greater than zero.
• clojure.core/postwalk function: Walks form depth-first, applying f to each sub-form after its children.
• clojure.core/postwalk-replace function: Replaces items in form that appear as keys in smap, walking bottom-up.
• clojure.core/pr function: Prints the arguments readably to *out*, without a trailing newline.
• clojure.core/pr-builtin function: Prints a value readably via the built-in C formatter, bypassing print-method.
• clojure.core/pr-str function: Returns a readable string representation of the arguments.
• clojure.core/prefer-method function: Prefers dispatch-val x over y in multimethod mm.
• clojure.core/prefers function: Returns the prefer-table of multimethod mm.
• clojure.core/prewalk function: Walks form depth-first, applying f to each sub-form before its children.
• clojure.core/prewalk-replace function: Replaces items in form that appear as keys in smap, walking top-down.
• clojure.core/print function: Prints the arguments space-separated to *out*, without a trailing newline.
• clojure.core/print-method function:
• clojure.core/print-simple function: Writes the plain text form of o (its str form, bypassing the print-method dispatch) to w, a string-collecting atom like the one *out* is bound to inside with-out-str.
• clojure.core/print-str function: Returns the print-string of args, space-separated, no trailing newline.
• clojure.core/printf function: Formats and prints to *out*: equivalent to (print (apply format fmt args)).
• clojure.core/println function: Prints the arguments to *out*, followed by a newline.
• clojure.core/println-str function: Returns the print-string of args followed by a newline.
• clojure.core/prn function: Prints the arguments readably to *out*, followed by a newline.
• clojure.core/prn-str function: Returns the readable-string of args followed by a newline.
• clojure.core/promise function: Return a fresh promise that can be deliver'd a value once.
• clojure.core/protocol-dispatch function:
• clojure.core/proxy function:
• clojure.core/push-thread-bindings function: Push a fresh dynamic-binding frame whose entries come from the map. Symbols-or-strings are accepted as keys.
• clojure.core/push-thread-bindings* function: (push-thread-bindings* bindings-map) — push a fresh dynamic-binding frame.
• clojure.core/pvalues function: Returns a lazy sequence of the values of the exprs, which are evaluated in parallel via pcalls.
• clojure.core/qualified-ident? function: Returns true if x is a namespace-qualified symbol or keyword.
• clojure.core/qualified-keyword? function: Returns true if x is a namespace-qualified keyword.
• clojure.core/qualified-symbol? function: Returns true if x is a namespace-qualified symbol.
• clojure.core/queue? function: Returns true if x is a PersistentQueue.
• clojure.core/quot function: Returns the quotient of dividing num by div, truncated toward zero.
• clojure.core/rand function: Returns a random float between 0 inclusive and 1 exclusive, or between 0 and n.
• clojure.core/rand-int function: Returns a random integer between 0 (inclusive) and n (exclusive).
• clojure.core/rand-nth function: Returns a random element from coll.
• clojure.core/random-sample function: Returns items from coll with probability prob.
• clojure.core/random-seed! function: Seeds the per-state PRNG to a known integer value so subsequent rand calls produce a reproducible stream.
• clojure.core/random-uuid function: Returns a random UUID v4 string.
• clojure.core/range function: Returns a lazy sequence of nums from start (inclusive) to end (exclusive), by step.
• clojure.core/rangev function: Returns a vector of integers from start (inclusive) to end (exclusive).
• clojure.core/ratio? function: Returns true if x is a ratio. Capability: :bignum
• clojure.core/rational? function: Returns true if x is a rational number (int, bigint, or ratio). Capability: :bignum
• clojure.core/rationalize function: Returns the rational value nearest to the argument. Capability: :bignum
• clojure.core/re-find function: Find the first match.
• clojure.core/re-find-from function: Internal: finds the first match at or after a codepoint index; returns [match start end] or nil. Capability: :regex
• clojure.core/re-groups function: Returns the most recent match groups for matcher m: a vector [whole g1 g2 ...] when the pattern has groups, the whole-match string otherwise.
• clojure.core/re-matcher function: Returns a matcher value for repeated find/match operations on text using pattern.
• clojure.core/re-matches function: Like re-find but anchored to the whole string.
• clojure.core/re-pattern function: Returns a regex from a string pattern (no-op on an existing regex). Capability: :regex
• clojure.core/re-seq function: Returns a lazy sequence of all matches of pattern in string s.
• clojure.core/read function:
• clojure.core/read* function: Reads one form from *in*.
• clojure.core/read+string function: Like read: consumes one form from the source and returns [form text] where text is the exactly-consumed input, whitespace- trimmed.
• clojure.core/read-line function: Reads one line from *in*.
• clojure.core/read-string function: Reads one form from the string.
• clojure.core/reader-conditional function: Builds a reader-conditional record with form and splicing? fields. Predicate reader-conditional? returns true on the result.
• clojure.core/reader-conditional? function: Returns true if x is a reader-conditional record produced by reader-conditional.
• clojure.core/realized? function: Returns true if a delay, lazy sequence, future, or promise has been realized.
• clojure.core/realpath function: Resolves a path to its canonical absolute form, or nil. Capability: :fs
• clojure.core/record* function: Runtime constructor for record values.
• clojure.core/record-fields function: Returns the declared field-name vector for a record type.
• clojure.core/record-from-map function: Builds a record by reading declared fields from a map; non-field keys land in ext.
• clojure.core/record-type? function: Returns true if x is a record type (the value defrecord defines).
• clojure.core/record? function: Returns true if x is a record value.
• clojure.core/reduce function: Reduces coll using f.
• clojure.core/reduce-kv function: Reduces a map (or any associative source) with f taking accumulator, key, and value.
• clojure.core/reduced function: Wraps a value to signal early termination of reduce.
• clojure.core/reduced? function: Returns true if x is a reduced value.
• clojure.core/reductions function: Returns a lazy sequence of the intermediate values of a reduction.
• clojure.core/ref function: Creates an STM ref holding the given initial value.
• clojure.core/ref-history-count function: Returns the ref's current history-count.
• clojure.core/ref-max-history function: Returns the ref's max-history.
• clojure.core/ref-min-history function: Returns the ref's min-history.
• clojure.core/ref-set function: Sets the value of ref.
• clojure.core/ref? function: Returns true if x is an STM ref. Capability: :stm
• clojure.core/refer function: Bring all publics of a namespace into the current namespace.
• clojure.core/refer-clojure function: Refers public vars from clojure.core into the current namespace, accepting the same filter options as the ns :refer-clojure clause: :exclude, :only, :rename.
• clojure.core/regex? function: Returns true if x is a regex value.
• clojure.core/reify function: Returns an instance of a fresh anonymous record type that satisfies the named protocols.
• clojure.core/release-pending-sends function: Returns the count of sends queued by the current transaction and clears them so they will NOT fire on commit.
• clojure.core/rem function: Returns the remainder of dividing num by div.
• clojure.core/remove function: Returns a lazy sequence of items in coll for which pred returns falsy.
• clojure.core/remove-all-methods function: Removes all methods from multimethod mm.
• clojure.core/remove-method function: Removes the method for dispatch-val from multimethod mm.
• clojure.core/remove-ns function: Remove a namespace from the runtime.
• clojure.core/remove-tap function: Unregisters f from the tap registry.
• clojure.core/remove-watch function: Removes a watch function from an atom by key.
• clojure.core/repeat function: Returns a lazy sequence of xs.
• clojure.core/repeatedly function: Returns a lazy sequence of calls to f.
• clojure.core/replace function: Returns a collection with items in coll replaced by entries in smap.
• clojure.core/replicate function: Returns a lazy seq of n copies of x.
• clojure.core/require function: Loads and evaluates a mino source file.
• clojure.core/requiring-resolve function: Require the namespace if needed, then resolve a qualified symbol.
• clojure.core/reset! function: Sets the value of an atom to newval and returns newval.
• clojure.core/reset-meta! function: Atomically resets the metadata for a reference type to meta-map. Returns meta-map.
• clojure.core/reset-vals! function: Sets the value of an atom and returns [old new].
• clojure.core/resolve function: Returns the var to which a symbol resolves, or nil.
• clojure.core/rest function: Returns all but the first item in a collection.
• clojure.core/restart-agent function: Clears the agent's error and resets its state to the given value.
• clojure.core/reverse function: Returns a sequence of the items in coll in reverse order.
• clojure.core/reversible? function: Returns true if x supports rseq (vectors and sorted collections).
• clojure.core/rm-rf function: Recursively removes a file or directory. Capability: :fs
• clojure.core/rseq function: Returns a reverse sequence of a vector, or nil if empty.
• clojure.core/rsubseq function: Returns the entries of a sorted collection whose keys fall in the given range, descending.
• clojure.core/run function: Runs a command with separate stdout, stderr, and exit.
• clojure.core/run! function: Applies f to each item in coll for side effects.
• clojure.core/satisfies? function: Returns true if x's type has implementations for all methods of proto.
• clojure.core/save-image function: Save the full runtime state to an image file. Capability: :fs
• clojure.core/second function: Returns the second item in coll.
• clojure.core/select-keys function: Returns a map containing only the entries whose keys are in ks.
• clojure.core/send function: Dispatches an action onto the agent's POOLED run-queue and returns the agent immediately.
• clojure.core/send-off function: Dispatches an action onto the agent's SOLO run-queue.
• clojure.core/send-via function: JVM-canon dispatches the action through a host-supplied Executor.
• clojure.core/seq function: Returns a seq on the collection, or nil if empty.
• clojure.core/seq-to-map-for-destructuring function: Builds a map from a sequence of keyword/value pairs, possibly with a trailing override map.
• clojure.core/seq? function: Returns true if x is a cons cell or lazy-seq.
• clojure.core/seqable? function: Returns true if (seq x) is supported.
• clojure.core/seque function: Returns a seq with the same elements and order as s, where a producer running on another thread stays up to n elements (default 128) ahead of the consumer.
• clojure.core/sequence function: Coerces coll to a (possibly empty) sequence, if it is not already one.
• clojure.core/sequential? function: Returns true if x is a sequential collection (list, vector, lazy-seq, or queue).
• clojure.core/set function: Returns a set of the items in coll.
• clojure.core/set! function: Mutates a thread-local dynamic-var binding to the given value. The target must be a dynamic var with an enclosing (binding ...) form on the call stack; without one, throws "Can't change/establish root binding".
• clojure.core/set-dyn-binding! function: (set-dyn-binding! 'name value) — mutate the topmost active dynamic binding for `name`.
• clojure.core/set-error-handler! function: Sets the agent's error-handler fn (called with [agent ex] when an action throws). Capability: :agent
• clojure.core/set-error-mode! function: Sets the agent's error mode (:fail or :continue). Capability: :agent
• clojure.core/set-fail-alloc-at! function: Make the n-th GC allocation fail (simulated OOM).
• clojure.core/set-print-method! function: Installs a fn to dispatch pr / prn output; nil removes the hook.
• clojure.core/set-validator! function: Sets a validator function on an atom.
• clojure.core/set? function: Returns true if x is a set (including sorted-set).
• clojure.core/sh function: Runs an external command.
• clojure.core/sh! function: Runs an external command.
• clojure.core/sha256 function: Returns the hex-encoded SHA-256 digest of a string. Capability: :fs
• clojure.core/short function: Coerces x to a short (16-bit integer).
• clojure.core/short-array function: Creates a host-style short array.
• clojure.core/shuffle function: Returns a randomly shuffled vector of the items in coll.
• clojure.core/shutdown-agents function: Quiesces both per-state agent workers: signals each to drain its remaining queue, joins the pthreads, seals the agent surface so subsequent send / send-off throw MST008.
• clojure.core/simple-ident? function: Returns true if x is a non-namespace-qualified symbol or keyword.
• clojure.core/simple-keyword? function: Returns true if x is a keyword with no namespace.
• clojure.core/simple-symbol? function: Returns true if x is a symbol with no namespace.
• clojure.core/slurp function: Reads the entire contents of a file as a string. Capability: :io
• clojure.core/some function: Returns the first truthy value of (pred x) for any x in coll, else nil.
• clojure.core/some-> function: Thread-first through forms, short-circuiting on nil.
• clojure.core/some->> function: Thread-last through forms, short-circuiting on nil.
• clojure.core/some-fn function: Returns a function that returns the first truthy value from any pred applied to any argument.
• clojure.core/some? function: Returns true if x is not nil.
• clojure.core/sort function: Returns a sorted sequence of the items in coll.
• clojure.core/sort-by function: Returns a sorted sequence of the items in coll, ordered by (keyfn item).
• clojure.core/sorted-map function: Returns a new sorted map with the given key-value pairs.
• clojure.core/sorted-map-by function: Returns a sorted map using the given comparator function.
• clojure.core/sorted-set function: Returns a new sorted set containing the arguments.
• clojure.core/sorted-set-by function: Returns a sorted set using the given comparator function.
• clojure.core/sorted? function: Returns true if x is a sorted collection.
• clojure.core/special-symbol? function: Returns true if x is a symbol that names a special form.
• clojure.core/spit function: Writes the string content to a file. Capability: :io
• clojure.core/split-at function: Returns a vector of [(take n coll) (drop n coll)].
• clojure.core/split-with function: Returns a vector of [(take-while pred coll) (drop-while pred coll)].
• clojure.core/splitv-at function: Returns a vector [(vec (take n coll)) (vec (drop n coll))].
• clojure.core/store-checkpoint* function: Write the db value to disk and truncate the WAL if durable. Capability: :store
• clojure.core/store-clock* function: Return the current instant from the store's clock. Capability: :store
• clojure.core/store-close* function: Close the store, flushing if durable. Capability: :store
• clojure.core/store-commit* function: Publish a new db value to the store, optionally appending to WAL. Capability: :store
• clojure.core/store-open* function: Create a store connection from a db value and optional path. Capability: :store
• clojure.core/store-read-snapshot* function: Read a snapshot file and return the db value, or nil. Capability: :store
• clojure.core/store-read-wal* function: Read the WAL and return a vector of tx-info maps, or nil. Capability: :store
• clojure.core/store? function: Return true if x is a store connection. Capability: :store
• clojure.core/str function: Returns the string representation of the arguments concatenated.
• clojure.core/string? function: Returns true if x is a string.
• clojure.core/subbits function: Zero-copy-semantics slice of a bytes value over a half-open bit range [start..end).
• clojure.core/subs function: Returns a substring from start (inclusive) to end (exclusive).
• clojure.core/subseq function: Returns the entries of a sorted collection whose keys fall in the given range, ascending.
• clojure.core/subvec function: Returns a subvector from start (inclusive) to end (exclusive).
• clojure.core/swap! function: Atomically applies f to the current value of the atom and any additional args.
• clojure.core/swap-vals! function: Atomically applies f to the atom and returns [old new].
• clojure.core/symbol function: Returns a symbol with the given name.
• clojure.core/symbol? function: Returns true if x is a symbol.
• clojure.core/sync function: Like dosync: runs the exprs (which may be nil) in an STM transaction.
• clojure.core/tagged-literal function: Builds a tagged-literal record with tag and form fields.
• clojure.core/tagged-literal? function: Returns true if x is a tagged-literal record produced by tagged-literal.
• clojure.core/take function: Returns a lazy sequence of the first n items in coll.
• clojure.core/take-last function: Returns a seq of the last n items in coll.
• clojure.core/take-nth function: Returns a lazy sequence of every nth item in coll.
• clojure.core/take-while function: Returns a lazy sequence of items from coll while pred returns truthy.
• clojure.core/tap> function: Sends x to every registered tap.
• clojure.core/test function: Finds fn at key :test in v's metadata, calls it (presumably with no side effects on the wider system), and reports :ok when it returns, :no-test when no :test fn is present.
• clojure.core/the-ns function: Return the namespace symbol or throw if not found.
• clojure.core/thread function: Executes the body in another thread, returning a future-like value that can be deref'd.
• clojure.core/thread-bound? function: Returns true if all of the vars provided as arguments have thread-local bindings active on the current dyn-stack.
• clojure.core/thread-sleep function: Blocks the current thread for the given number of milliseconds.
• clojure.core/throw function: Throws an exception with the given value.
• clojure.core/time function: Evaluates body, prints elapsed time, and returns the result.
• clojure.core/time-ms function: Returns the current time in milliseconds. Capability: :io
• clojure.core/to-array function: Converts a collection to an Object array (host-style).
• clojure.core/trampoline function: Calls f with args, then repeatedly calls the result if it is a function.
• clojure.core/transduce function: Reduces coll using the transducer xf applied to the reducing function f.
• clojure.core/transient function: Returns a transient view of coll for batch mutation.
• clojure.core/transient? function: Returns true if x is a transient.
• clojure.core/tree-seq function: Returns a lazy depth-first sequence of nodes in a tree.
• clojure.core/true? function: Returns true if x is the value true.
• clojure.core/type function: Returns a keyword indicating the type of the value.
• clojure.core/unchecked-add function: Returns x + y as a long with two's-complement wraparound.
• clojure.core/unchecked-add-int function: Returns x + y with 32-bit two's-complement wraparound.
• clojure.core/unchecked-byte function: Coerce x to an 8-bit signed byte (stored in a long with sign extension).
• clojure.core/unchecked-char function: Coerce x to a Unicode char by truncating to 16 bits (matching JVM char).
• clojure.core/unchecked-dec function: Returns x - 1 as a long with two's-complement wraparound.
• clojure.core/unchecked-dec-int function: Returns x - 1 with 32-bit two's-complement wraparound.
• clojure.core/unchecked-divide-int function: Returns the truncating integer division of x by y.
• clojure.core/unchecked-double function: Coerce x to a 64-bit double.
• clojure.core/unchecked-float function: Coerce x to a 32-bit float.
• clojure.core/unchecked-inc function: Returns x + 1 as a long with two's-complement wraparound.
• clojure.core/unchecked-inc-int function: Returns x + 1 with 32-bit two's-complement wraparound.
• clojure.core/unchecked-int function: Coerce x to a 32-bit signed int (stored in a long with sign extension).
• clojure.core/unchecked-long function: Coerce x to a 64-bit long by truncating toward zero.
• clojure.core/unchecked-multiply function: Returns x * y as a long with two's-complement wraparound.
• clojure.core/unchecked-multiply-int function: Returns x * y with 32-bit two's-complement wraparound.
• clojure.core/unchecked-negate function: Returns -x as a long with two's-complement wraparound.
• clojure.core/unchecked-negate-int function: Returns -x with 32-bit two's-complement wraparound.
• clojure.core/unchecked-remainder-int function: Returns the 32-bit signed remainder of x divided by y.
• clojure.core/unchecked-short function: Coerce x to a 16-bit signed short (stored in a long with sign extension).
• clojure.core/unchecked-subtract function: Returns x - y as a long with two's-complement wraparound.
• clojure.core/unchecked-subtract-int function: Returns x - y with 32-bit two's-complement wraparound.
• clojure.core/underive function: Removes a parent/child relationship between child and parent.
• clojure.core/unquote function: Placeholder for the ~ reader form.
• clojure.core/unquote-splicing function: Placeholder for the ~@ reader form.
• clojure.core/unreduced function: Unwraps a reduced value.
• clojure.core/unsigned-bit-shift-right function: Returns n logically shifted right by count bits.
• clojure.core/update function: Updates the value at key k in map m by applying f to the old value and any args.
• clojure.core/update-in function: Updates a value in a nested associative structure by applying f at the given key path.
• clojure.core/update-keys function: Returns a map with f applied to each key.
• clojure.core/update-vals function: Returns a map with f applied to each value.
• clojure.core/uri? function:
• clojure.core/use function: Loads a module and refers all of its public names by default.
• clojure.core/uuid? function: Returns true if x is a UUID value.
• clojure.core/val function: Returns the value of a map entry.
• clojure.core/vals function: Returns a sequence of the values in a map.
• clojure.core/var-get function: Return the current value of a var: the thread-local binding if one is active, otherwise the root value.
• clojure.core/var-set function: Set the root value of a var.
• clojure.core/var? function: Returns true if x is a var.
• clojure.core/vary-meta function: Returns a copy of the value with (apply f meta args) as its metadata.
• clojure.core/vec function: Converts coll into a vector.
• clojure.core/vector function: Returns a new vector containing the arguments.
• clojure.core/vector? function: Returns true if x is a vector.
• clojure.core/volatile! function: Creates a volatile cell with the given initial value.
• clojure.core/volatile? function: Returns true if x is a volatile.
• clojure.core/vreset! function: Sets the value of a volatile to newval and returns newval.
• clojure.core/vswap! function: Non-atomically swaps the value of the volatile to be: (apply f current-value-of-vol args).
• clojure.core/walk function: Traverses form, applying inner to each element and outer to the result.
• clojure.core/when function: Evaluates body when test is truthy.
• clojure.core/when-first function: Binds the first element of a collection, evaluates body if the collection is non-empty.
• clojure.core/when-let function: Binds the result of expr, evaluates body if truthy.
• clojure.core/when-not function: Evaluates body when test is falsy.
• clojure.core/when-some function: Binds the result of expr, evaluates body if non-nil.
• clojure.core/which function: Searches PATH for an executable, returns its absolute path or nil. Capability: :fs
• clojure.core/while function: Repeatedly evaluates body while test is truthy.
• clojure.core/with-bindings function: Takes a map of var->value pairs.
• clojure.core/with-bindings* function: (with-bindings* bindings-map fn) — pushes the bindings as a dynamic frame and invokes fn with no args.
• clojure.core/with-in-str function: Evaluates body with *in* bound to a string-cursor atom holding s.
• clojure.core/with-local-vars function: Binds names to fresh, lexically-scoped vars holding init values. Within body the names refer to vars: read with @name, mutate with (var-set name val).
• clojure.core/with-meta function: Returns a copy of the value with the given metadata map.
• clojure.core/with-open function: Binds resources, evaluates body, then closes each resource.
• clojure.core/with-out-str function: Evaluates body with *out* bound to a fresh string-collecting atom, and returns the accumulated string.
• clojure.core/with-precision function: Sets *math-context* to {:precision precision :rounding-mode mode} around body.
• clojure.core/with-redefs function: Temporarily rebinds the root bindings of vars while body executes, restoring them in a finally clause.
• clojure.core/with-redefs-fn function: Temporarily rebinds the root values of vars to new-values while thunk runs, restoring originals afterward.
• clojure.core/xml-seq function: A tree seq on the xml elements as per xml/parse: nodes are maps with :tag and :content keys, leaves are strings.
• clojure.core/zero? function: Returns true if x is zero.
• clojure.core/zipmap function: Returns a map with keys mapped to corresponding vals.
• clojure.lang.PersistentQueue/EMPTY function:
• clojure.repl/apropos function: Given a regular expression or stringable thing, return a sorted seq of all public definitions in all currently-loaded namespaces whose names match str-or-pattern (substring for strings, re-find for regexes), as namespace-qualified symbols.
• clojure.repl/dir function: Prints a sorted list of public names in the given namespace symbol.
• clojure.repl/dir-fn function: Returns a sorted seq of symbols for public names in the namespace named by `ns-sym`.
• clojure.repl/doc function: Prints documentation for the named var.
• clojure.repl/doc-string function: Returns the documentation string for the named var, or nil.
• clojure.repl/find-doc function: Prints documentation for any var whose documentation or name contains a match for `re-string-or-pattern`, where the pattern is a regex or a plain substring (substring matches case-sensitively).
• clojure.repl/pst function: Prints the most recent exception (`*e`) as a formatted summary.
• clojure.repl/source function: Prints the source form of the named var.
• clojure.repl/source-form function: Returns the source form for the named var, or nil.
• clojure.string/ends-with? function: Returns true if the string ends with the given suffix.
• clojure.string/includes? function: Returns true if the string contains the given substring.
• clojure.string/join function: Returns a string of the items in coll joined by separator.
• clojure.string/lower-case function: Returns the string converted to lower case.
• clojure.string/replace function: Returns a collection with items in coll replaced by entries in smap.
• clojure.string/replace-first function: Replaces the first occurrence of match in s with replacement.
• clojure.string/split function: Splits a string on a regex pattern.
• clojure.string/starts-with? function: Returns true if the string starts with the given prefix.
• clojure.string/trim function: Returns the string with leading and trailing whitespace removed.
• clojure.string/upper-case function: Returns the string converted to upper case.
• when macro: Evaluates body when test is truthy.
• cond macro: Takes pairs of test/expr.
• and macro: Returns the first falsy value, or the last value if all are truthy.
• or macro: Returns the first truthy value, or the last value if none are truthy.
• -> macro: Thread-first.
• ->> macro: Thread-last.
• dosync macro: Runs body in an STM transaction.
• sync macro: Like dosync: runs the exprs (which may be nil) in an STM transaction.
• io! macro: If invoked within an STM transaction, throws an IllegalStateException-equivalent before evaluating body.
• ^:private function:
• defn macro: Defines a named function.
• defn- macro: Same as defn, yielding a non-public def.
• defonce macro: Defines name only if it has no root binding.
• vswap! macro: Non-atomically swaps the value of the volatile to be: (apply f current-value-of-vol args).
• ^:private function:
• lazy-cat macro: Expands to code that yields a lazy concatenation of the given collections.
• interleave function: Returns a lazy sequence of the first item in each collection, then the second, and so on.
• partition function: Returns a lazy sequence of lists of n items each, at offsets step apart.
• array-map function: Creates a hash-map.
• delay macro: Creates a delay that evaluates body on first deref.
• monitor-registry function:
• locking macro: Executes body while holding a monitor of x.
• if-not macro: Evaluates then when test is falsy, else otherwise.
• when-not macro: Evaluates body when test is falsy.
• if-let macro: Binds the result of expr, evaluates then if truthy, else otherwise.
• when-let macro: Binds the result of expr, evaluates body if truthy.
• when-first macro: Binds the first element of a collection, evaluates body if the collection is non-empty.
• letfn macro: Binds local functions.
• set! macro: Mutates a thread-local dynamic-var binding to the given value. The target must be a dynamic var with an enclosing (binding ...) form on the call stack; without one, throws \
• comment macro: Ignores body, returns nil.
• if-some macro: Binds the result of expr, evaluates then if non-nil, else otherwise.
• when-some macro: Binds the result of expr, evaluates body if non-nil.
• ^:private function:
• ^:private function:
• get-in function: Returns the value in a nested associative structure at the given key path.
• as-> macro: Binds expr to sym, then threads it through each form where sym can appear anywhere.
• cond-> macro: Thread-first through forms whose tests are truthy.
• cond->> macro: Thread-last through forms whose tests are truthy.
• some-> macro: Thread-first through forms, short-circuiting on nil.
• some->> macro: Thread-last through forms, short-circuiting on nil.
• doto macro: Evaluates x, then calls each form with x as the first argument. Returns x.
• dotimes macro: Evaluates body n times with sym bound to 0 through n-1.
• while macro: Repeatedly evaluates body while test is truthy.
• doseq macro: Iterates over collections for side effects, evaluating body once per binding combination, and returns nil.
• time macro: Evaluates body, prints elapsed time, and returns the result.
• ^:private function:
• ^:private function:
• condp macro: Takes a binary predicate, an expression, and clauses.
• case macro: Dispatches on the value of expr.
• for macro: List comprehension.
• future macro: Takes a body of expressions and yields a future object that will evaluate the body in another thread, blocking on deref until the value is available.
• thread macro: Executes the body in another thread, returning a future-like value that can be deref'd.
• pvalues macro: Returns a lazy sequence of the values of the exprs, which are evaluated in parallel via pcalls.
• defprotocol macro: Defines a protocol with the given method signatures.
• extend-type macro: Extends a protocol with method implementations for the given type.
• extend-protocol macro: Extends a protocol with implementations for multiple types.
• internal-reduce function:
• internal-reduce-kv function:
• ^:private function:
• ^:private function:
• defmulti macro: Defines a multimethod with the given dispatch function.
• defmethod macro: Defines a method for a multimethod.
• with-out-str macro: Evaluates body with *out* bound to a fresh string-collecting atom, and returns the accumulated string.
• with-in-str macro: Evaluates body with *in* bound to a string-cursor atom holding s.
• char-escape-string function: Returns escape string for char or nil if none.
• char-name-string function: Returns name string for char or nil if none.
• with-open macro: Binds resources, evaluates body, then closes each resource.
• ^:private function:
• ^:dynamic function:
• ^:dynamic function:
• ^:dynamic function:
• ^:dynamic function:
• ^:dynamic function:
• ^:dynamic function:
• ^:dynamic function:
• assert macro:
• ^:dynamic function:
• ^:dynamic function:
• ^:dynamic function:
• ^:dynamic function:
• ^:dynamic function:
• ^:dynamic function:
• ^:dynamic function:
• ^:dynamic function:
• ^:dynamic function:
• ^:private function:
• with-precision macro: Sets *math-context* to {:precision precision :rounding-mode mode} around body.
• ^:private function:
• refer-clojure macro: Refers public vars from clojure.core into the current namespace, accepting the same filter options as the ns :refer-clojure clause: :exclude, :only, :rename.
• let-bits macro: Destructure-shaped binding over a bytes value. (let-bits [bytes-val [sym & opts] ...] body...) See documentation in core.clj just above this definition.
• ^:private function:
• with-bindings macro: Takes a map of var->value pairs.
• bound-fn macro: Returns a function defined by the given fntail, which will install the same bindings in effect as in the thread at the time bound-fn was called.
• ^:private function:
• EMPTY function:
• defrecord macro: Defines a record type Name with the given fields and optional inline protocol specs.
• deftype macro: Alias for defrecord.
• reify macro: Returns an instance of a fresh anonymous record type that satisfies the named protocols.
• proxy macro:
• gen-class macro:
• definterface macro:
• import macro:
• with-redefs macro: Temporarily rebinds the root bindings of vars while body executes, restoring them in a finally clause.
• with-local-vars macro: Binds names to fresh, lexically-scoped vars holding init values. Within body the names refer to vars: read with @name, mutate with (var-set name val).
• quote special form:
• quasiquote special form:
• unquote special form:
• unquote-splicing special form:
• def special form:
• defmacro special form:
• if special form:
• do special form:
• let special form:
• fn special form:
• loop special form:
• recur special form:
• try special form: