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_find_keyword_n function: Lookup-only keyword probes: return the already-interned keyword for the given name (or ns/name), or NULL when it was never interned. They never intern, so a caller can observe the intern table without mutating it.
• mino_find_keyword_ns_n function:
• 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_jit_available function: Stateless build-identity query: non-zero when this binary was compiled with JIT support AND the host arch / OS is a supported target (the same condition as mino_jit_capability.available, without needing a state). Always 0 on mino-lean.
• 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 or MINO_SORTED_MAP "L" mino_val ** -- MINO_CONS or MINO_NIL (a list) "H" mino_val ** -- MINO_HANDLE "A" mino_val ** -- MINO_ATOM "B" mino_val ** -- MINO_BIGINT "r" mino_val ** -- MINO_RATIO "d" mino_val ** -- MINO_BIGDEC "R" mino_val ** -- MINO_RECORD "X" mino_val ** -- MINO_SET or MINO_SORTED_SET "F" mino_val ** -- callable: MINO_FN, MINO_PRIM, or MINO_MACRO Every directive that yields a `mino_val **` writes the argument value itself (borrowed, mino-owned) after checking its type; only "S" and the scalar directives ("i" "f" "s" "k" "y" "b" "c") decode into a plain C value. 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_add_load_path function: Append `path` to the runtime require search path (the list (add-load-path! ...) grows from mino code).
• mino_load_path_count function: Number of runtime load paths registered so far.
• mino_load_path_get function: The load path at index i (0 <= i < mino_load_path_count), or NULL if out of range.
• mino_ns_env function: Return the environment backing namespace `ns`, creating it if it does not yet exist.
• mino_intern_var function:
• mino_var_set_dynamic function: Mark `var` dynamic (thread-bindable) when `dynamic` is non-zero, or static when zero.
• mino_var_set_root function: Set the root binding of `var` to `val` (NULL is stored as nil).
• mino_var_get_root function: Read the current root binding of `var`, or NULL if `var` is not a var or is unbound.
• mino_source_cache_feed function: Feed `len` bytes of source text under the name `file` into the diagnostic source cache, so a subsequent error whose location falls in that file can quote the offending line.
• mino_reader_file function: The file name the reader is currently attributing source positions to (the value set by the last read entry point, e.g.
• 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_JSON macro:
• MINO_CAP_NET macro:
• MINO_CAP_CSV macro:
• MINO_CAP_TIME macro: Pure-data / info-only bundled libraries.
• MINO_CAP_DIGEST macro:
• MINO_CAP_HTML macro:
• MINO_CAP_XML macro:
• MINO_CAP_YAML macro:
• MINO_CAP_TOML macro:
• MINO_CAP_COMPRESS macro:
• MINO_CAP_ARCHIVE macro:
• MINO_CAP_TEMPLATE macro:
• MINO_CAP_TERM macro:
• MINO_CAP_ENV macro:
• MINO_CAP_LOG macro:
• MINO_CAP_CLI macro:
• MINO_CAP_PATH macro:
• MINO_CAP_CODEC macro:
• MINO_CAP_RANDOM macro:
• MINO_CAP_SIGNAL macro:
• MINO_CAP_WEBSOCKET macro:
• MINO_CAP_TAR macro:
• MINO_CAP_UDP macro:
• MINO_CAP_UTIL macro:
• MINO_CAP_IMAGE 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_root_new function: Values returned by constructors and eval are borrowed: they survive until the next GC cycle but are not pinned.
• mino_root_get function:
• mino_unroot function:
• mino_clone function: Deep-copy a value from one state into another.

Language

• clojure.core/* function: * ([] [x] [x y] [x y & more]) Returns the product of the arguments.
• clojure.core/*' function: *' ([] [x] [x y] [x y & more]) 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 version of 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: + ([] [x] [x y] [x y & more]) Returns the sum of the arguments.
• clojure.core/+' function: +' ([] [x] [x y] [x y & more]) Returns the sum of the arguments.
• clojure.core/- function: - ([x] [x y] [x y & more]) Returns the difference of the arguments.
• clojure.core/-' function: -' ([x] [x y] [x y & more]) Returns the difference of the arguments.
• clojure.core/-> function: -> ([x & forms]) Thread-first.
• clojure.core/->> function: ->> ([x & forms]) Thread-last.
• clojure.core/->Eduction function: ->Eduction ([xform coll]) 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 function: Return the var's root value, bypassing thread bindings.
• clojure.core/-var-root-bound? function: Return true if the var has a root binding.
• clojure.core// function: / ([x] [x y] [x y & more]) Returns the quotient of the arguments.
• clojure.core/< function: < ([x] [x y] [x y & more]) Returns true if nums are in monotonically increasing order.
• clojure.core/<= function: <= ([x] [x y] [x y & more]) Returns true if nums are in monotonically non-decreasing order.
• clojure.core/= function: = ([x] [x y] [x y & more]) Returns true if all arguments are equal.
• clojure.core/== function: == ([x] [x y] [x y & more]) Returns true if nums are numerically equal, treating ints and floats uniformly.
• clojure.core/> function: > ([x] [x y] [x y & more]) Returns true if nums are in monotonically decreasing order.
• clojure.core/>= function: >= ([x] [x y] [x y & more]) 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: Parses an int string, bounded to the signed 32-bit range.
• 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: NaN? ([num]) 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: Throwable->map ([o]) 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: abs ([a]) Returns the absolute value of x.
• clojure.core/add-days function: Adds n exact 86400000-ms days to an epoch-ms (the model has no DST, so a day is always exact).
• 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-months function: Adds n calendar months to an epoch-ms or a time map, returning the same kind.
• clojure.core/add-tap function: add-tap ([f]) Registers f as a tap target.
• clojure.core/add-watch function: add-watch ([reference key fn]) Adds a watch function to an atom, called on state changes.
• clojure.core/agent function: agent ([state & options]) Creates an asynchronous agent holding the given initial state.
• clojure.core/agent-error function: agent-error ([a]) 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: aget ([array idx]) Reads slot `index` from a host array or a bytes value.
• clojure.core/alength function: alength ([array]) Returns the slot count of a host array or the byte length of a bytes value.
• clojure.core/alias function: alias ([alias namespace-sym]) Add an alias to a namespace.
• clojure.core/all-ns function: all-ns ([]) 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: alter ([ref fun & args]) Sets ref to (apply f current-value args).
• clojure.core/alter-meta! function: alter-meta! ([iref f & args]) Atomically applies f to the metadata of a reference.
• clojure.core/alter-var-root function: alter-var-root ([v f & args]) Apply a function to a var's root and store the result.
• clojure.core/ancestors function: ancestors ([tag] [h tag]) Returns all ancestors of tag in the hierarchy.
• clojure.core/and function: and ([& xs]) Returns the first falsy value, or the last value if all are truthy.
• clojure.core/any? function: any? ([x]) Returns true for any argument.
• clojure.core/apply function: apply ([f args] [f x args] [f x y args] [f x y z args] [f a b c d & args]) Applies f to the arguments, with the last argument spread as a sequence.
• clojure.core/array-map function: array-map ([] [& keyvals]) Creates a hash-map.
• clojure.core/as-> function: as-> ([expr name & forms]) Binds expr to sym, then threads it through each form where sym can appear anywhere.
• clojure.core/aset function: aset ([array idx val]) Mutates the host array at index, storing val.
• clojure.core/assert function: assert ([x] [x message])
• clojure.core/assoc function: assoc ([map key val] [map key val & kvs]) Returns a new map with the given key-value pairs added.
• clojure.core/assoc! function: assoc! ([coll key val] [coll key val & kvs]) Associates key with val in a transient map or vector.
• clojure.core/assoc-in function: assoc-in ([m ks v]) Associates a value in a nested associative structure at the given key path.
• clojure.core/associative? function: associative? ([coll]) 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/at-exit function: Registers a zero-argument function to run when the process exits.
• clojure.core/atom function: atom ([x] [x & options]) Creates an atom with the given initial value.
• clojure.core/atom? function: Returns true if x is an atom.
• clojure.core/await function: await ([& agents]) Blocks the calling thread until every named agent's queued actions have finished.
• clojure.core/await-for function: await-for ([timeout-ms & agents]) Like await with a millisecond timeout.
• clojure.core/base64-decode function: Decodes base64 (RFC 4648) from a string or bytes value.
• clojure.core/base64-encode function: Encodes a string or bytes value as base64 (RFC 4648) with padding.
• clojure.core/bigdec function: bigdec ([x]) Coerces a value to an arbitrary-precision decimal. Capability: :bignum
• clojure.core/bigint function: bigint ([x]) 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: biginteger ([x]) Alias of bigint.
• clojure.core/binding function: binding ([bindings & body]) 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: bit-and ([x y] [x y & more]) Returns the bitwise AND of the arguments.
• clojure.core/bit-and-not function: bit-and-not ([x] [x y] [x y & more]) Returns the bitwise AND of x and the complement of each remaining argument, folded left to right.
• clojure.core/bit-clear function: bit-clear ([x n]) Returns x with bit n cleared.
• clojure.core/bit-flip function: bit-flip ([x n]) Returns x with bit n flipped.
• clojure.core/bit-not function: bit-not ([x]) Returns the bitwise complement of n.
• clojure.core/bit-or function: bit-or ([x y] [x y & more]) Returns the bitwise OR of the arguments.
• clojure.core/bit-set function: bit-set ([x n]) Returns x with bit n set.
• clojure.core/bit-shift-left function: bit-shift-left ([x n]) Returns n shifted left by count bits.
• clojure.core/bit-shift-right function: bit-shift-right ([x n]) Returns n arithmetically shifted right by count bits.
• clojure.core/bit-test function: bit-test ([x n]) Returns true if bit n of x is set.
• clojure.core/bit-xor function: bit-xor ([x y] [x y & more]) 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: boolean ([x]) Coerces x to a boolean value.
• clojure.core/boolean-array function: boolean-array ([size-or-seq] [size init-val-or-seq]) Creates a host-style boolean array.
• clojure.core/boolean? function: boolean? ([x]) Returns true if x is true or false.
• clojure.core/bound-fn function: bound-fn ([& fntail]) 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: bound-fn* ([f]) 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: bound? ([& vars]) 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: bounded-count ([n coll]) Returns the count of coll, but stops counting at n.
• clojure.core/butlast function: butlast ([coll]) Returns a seq of all but the last item in coll.
• clojure.core/byte function: byte ([x]) Coerces x to a byte (8-bit integer).
• clojure.core/byte-array function: byte-array ([size-or-seq] [size init-val-or-seq]) Creates a host-style byte array.
• clojure.core/bytes->string function: Decodes a string or bytes value as strict UTF-8 into a string.
• clojure.core/bytes? function: bytes? ([x]) 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: case ([e & clauses]) Dispatches on the value of expr.
• clojure.core/cat function: cat ([rf]) 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: char ([x]) Coerces x to a character: integer codepoint (0..0x10FFFF) becomes the Unicode scalar value, character is identity.
• clojure.core/char-array function: char-array ([size-or-seq] [size init-val-or-seq]) 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: char? ([x]) Returns true if x is a one-character string.
• clojure.core/chdir function: Changes the current working directory. Capability: :io
• clojure.core/chmod function: Sets the permission bits (an int) on a path.
• clojure.core/chunk function: chunk ([b]) Seals chunk-buffer buf so no further appends are accepted, and returns the chunk.
• clojure.core/chunk-append function: chunk-append ([b x]) Appends elem to chunk-buffer buf and returns buf.
• clojure.core/chunk-buffer function: chunk-buffer ([capacity]) Returns a fresh chunk-buffer of the given capacity.
• clojure.core/chunk-cons function: chunk-cons ([chunk rest]) Returns a chunked seq prepending the given chunk to the seq more.
• clojure.core/chunk-first function: chunk-first ([s]) Returns the chunk at the head of a chunked seq.
• clojure.core/chunk-next function: chunk-next ([s]) Returns the rest of a chunked seq as a seq, or nil if empty.
• clojure.core/chunk-rest function: chunk-rest ([s]) Returns the rest of a chunked seq after the head chunk, or () if none.
• clojure.core/chunked-seq? function: chunked-seq? ([s]) Returns true if x is a chunked seq.
• clojure.core/class function: class ([x]) Returns the concrete type tag keyword of a value, like type but ignoring :type metadata; (class nil) is nil.
• clojure.core/clojure-version function: clojure-version ([]) Returns the runtime version as a printable string.
• clojure.core/coll-reduce function: coll-reduce ([coll f init])
• clojure.core/coll? function: coll? ([x]) Returns true if x is a collection.
• clojure.core/comment function: comment ([& body]) Ignores body, returns nil.
• clojure.core/commute function: commute ([ref fun & args]) Sets ref to (apply f current-value args).
• clojure.core/comp function: comp ([] [f] [f g] [f g & fs]) Returns a function that is the composition of the given functions.
• clojure.core/comparator function: comparator ([pred]) Returns a comparator function from a two-arg predicate.
• clojure.core/compare function: compare ([x y]) Returns a negative, zero, or positive integer comparing x and y.
• clojure.core/compare-and-set! function: compare-and-set! ([atom oldval newval]) Atomically sets the atom to new-val if its current value equals expected.
• clojure.core/complement function: complement ([f]) Returns a function that returns the logical opposite of f.
• clojure.core/completing function: completing ([f] [f cf]) Returns a reducing function with a completion step.
• clojure.core/concat function: concat ([& colls]) Returns a lazy sequence of the concatenation of the given collections.
• clojure.core/cond function: cond ([& clauses]) Takes pairs of test/expr.
• clojure.core/cond-> function: cond-> ([expr & clauses]) Thread-first through forms whose tests are truthy.
• clojure.core/cond->> function: cond->> ([expr & clauses]) Thread-last through forms whose tests are truthy.
• clojure.core/condp function: condp ([pred expr & clauses]) Takes a binary predicate, an expression, and clauses.
• clojure.core/conj function: conj ([] [coll] [coll x] [coll x & xs]) Returns a new collection with items added.
• clojure.core/conj! function: conj! ([] [coll] [coll x]) Conjoins val onto a transient vector, map, or set.
• clojure.core/cons function: cons ([x seq]) 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: constantly ([x]) Returns a function that always returns x.
• clojure.core/contains? function: contains? ([coll key]) Returns true if the collection contains the key.
• clojure.core/copy function: Copies a regular file, preserving its mode.
• clojure.core/copy-tree function: Recursively copies a directory tree, keeping symlink entries as symlinks rather than following them. Capability: :fs
• clojure.core/count function: count ([coll]) Returns the number of items in a collection.
• clojure.core/counted? function: counted? ([coll]) Returns true if (count x) is a constant-time operation.
• clojure.core/cpu-ms function: Returns process CPU time in milliseconds (user plus kernel on Windows, clock() elsewhere).
• clojure.core/crc32 function: Computes the gzip-spec CRC-32 of a string or bytes value and returns it as an unsigned integer, 0 to 2^32-1. Capability: :digest
• clojure.core/create-ns function: create-ns ([sym]) Ensure the namespace exists and return its symbol.
• clojure.core/csv-parse function: Parses CSV text into a vector of vector rows of strings.
• clojure.core/cycle function: cycle ([coll]) Returns a lazy infinite sequence of repetitions of the items in coll.
• clojure.core/datafy function: datafy ([o])
• clojure.core/days-between function: Whole civil days from a to b, floored; the sign follows b - a.
• clojure.core/days-in-month function: Returns the number of days in the month (1..12) of the year; February answers 29 in leap years. Capability: :time
• clojure.core/dec function: dec ([x]) Returns x minus 1.
• clojure.core/dec' function: dec' ([x]) Returns x minus 1.
• clojure.core/decimal? function: decimal? ([n]) Returns true if x is an arbitrary-precision decimal. Capability: :bignum
• clojure.core/declare function: declare ([& names]) Interns one or more names as unbound vars so they can be referred to before their defining form appears.
• clojure.core/dedupe function: dedupe ([] [coll]) 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: definterface ([& _])
• clojure.core/deflate-compress function: Compresses a bytes value into one raw deflate stream (RFC 1951, no container) and returns the bytes.
• clojure.core/deflate-decompress function: Decodes one raw deflate stream (RFC 1951, no container) from a bytes value and returns the decompressed bytes.
• clojure.core/defmacro function: defmacro ([name doc-string? attr-map? [params*] body] [name doc-string? attr-map? ([params*] body) + attr-map?]) 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: defmethod ([multifn dispatch-val & fn-tail]) Defines a method for a multimethod.
• clojure.core/defmulti function: defmulti ([mm-name & options]) Defines a multimethod with the given dispatch function.
• clojure.core/defn function: defn ([name & fdecl]) Defines a named function.
• clojure.core/defn- function: defn- ([name & decls]) Same as defn, yielding a non-public def.
• clojure.core/defonce function: defonce ([name expr]) Defines name only if it has no root binding.
• clojure.core/defprotocol function: defprotocol ([name & opts+sigs]) Defines a protocol with the given method signatures.
• clojure.core/defrecord function: defrecord ([name fields & specs]) 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: deftype ([name fields & specs]) Alias for defrecord.
• clojure.core/delay function: delay ([& body]) Creates a delay that evaluates body on first deref.
• clojure.core/delay* function: Creates a delay from a fn of no arguments.
• clojure.core/delay? function: delay? ([x]) Returns true if x is a delay.
• clojure.core/deliver function: deliver ([promise val]) Deliver a value to a promise.
• clojure.core/denominator function: denominator ([r]) Returns the denominator of a rational number. Capability: :bignum
• clojure.core/deref function: deref ([ref] [ref timeout-ms timeout-val]) Returns the current value of a reference (atom, delay, etc.).
• clojure.core/derive function: derive ([tag parent] [h tag parent]) Establishes a parent/child relationship between child and parent in a hierarchy.
• clojure.core/descendants function: descendants ([tag] [h tag]) Returns all descendants of tag in the hierarchy.
• clojure.core/destructure function: destructure ([bindings]) 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: disj ([set] [set key] [set key & ks]) Returns a set with the given keys removed.
• clojure.core/disj! function: disj! ([set] [set key] [set key & ks]) Removes key from a transient set.
• clojure.core/dissoc function: dissoc ([map] [map key] [map key & ks]) Returns a map with the given keys removed.
• clojure.core/dissoc! function: dissoc! ([map key] [map key & ks]) Removes key from a transient map.
• clojure.core/distinct function: distinct ([] [coll]) Returns a lazy sequence of the distinct items in coll.
• clojure.core/distinct? function: distinct? ([x] [x y] [x y & more]) Returns true if no two of the arguments are equal.
• clojure.core/dns-lookup function: Resolves a host to a vector of address maps {:address ip-string :family :inet|:inet6}.
• clojure.core/doall function: doall ([coll] [n coll]) Forces realization of a lazy sequence.
• clojure.core/dorun function: dorun ([coll] [n coll]) Forces realization of a lazy sequence.
• clojure.core/doseq function: doseq ([seq-exprs & body]) Iterates over collections for side effects, evaluating body once per binding combination, and returns nil.
• clojure.core/dosync function: dosync ([& exprs]) Runs body in an STM transaction.
• clojure.core/dosync* function: Runs a zero-arg thunk inside an STM transaction.
• clojure.core/dotimes function: dotimes ([bindings & body]) Evaluates body n times with sym bound to 0 through n-1.
• clojure.core/doto function: doto ([x & forms]) Evaluates x, then calls each form with x as the first argument. Returns x.
• clojure.core/double function: double ([x]) Coerces x to a 64-bit double (returns a MINO_FLOAT).
• clojure.core/double-array function: double-array ([size-or-seq] [size init-val-or-seq]) Creates a host-style double array.
• clojure.core/double? function: double? ([x]) 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: drop ([n] [n coll]) Returns a lazy sequence of all but the first n items in coll.
• clojure.core/drop-last function: drop-last ([coll] [n coll]) 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: drop-while ([pred] [pred coll]) Returns a lazy sequence of items from coll after pred returns falsy.
• clojure.core/eduction function: eduction ([& args]) Returns a lazy sequence of applying the given transducers to coll.
• clojure.core/empty function: empty ([coll]) Returns an empty collection of the same type.
• clojure.core/empty? function: empty? ([coll]) Returns true if coll has no items.
• clojure.core/ensure function: ensure ([ref]) Reads ref and prevents any other transaction from changing it before this transaction commits.
• clojure.core/ensure-reduced function: ensure-reduced ([x]) Wraps x in reduced if it is not already reduced.
• clojure.core/epoch->time-map function: Converts epoch milliseconds to a plain time map {:year :month :day :hour :min :sec :ms :wday :offset-min} with 1-based months and :wday 0=Sunday.
• clojure.core/error-handler function: error-handler ([a]) Returns the agent's current error-handler fn or nil. Capability: :agent
• clojure.core/error-mode function: error-mode ([a]) 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: eval ([form]) Evaluates the given form.
• clojure.core/even? function: even? ([n]) Returns true if x is an even integer.
• clojure.core/every-pred function: every-pred ([p] [p1 p2] [p1 p2 p3] [p1 p2 p3 & ps]) Returns a function that returns true when all preds are satisfied by all its arguments.
• clojure.core/every? function: every? ([pred coll]) Returns true if (pred x) is truthy for every x in coll.
• clojure.core/ex-cause function: ex-cause ([ex]) Returns the cause attached to the given exception, or nil.
• clojure.core/ex-data function: ex-data ([ex]) Extract the data map from an exception.
• clojure.core/ex-info function: ex-info ([msg map] [msg map cause]) Create an exception map with a message and data map.
• clojure.core/ex-message function: ex-message ([ex]) Extract the message from an exception.
• clojure.core/exit function: Exits the process with the given status code. Capability: :io
• clojure.core/extend function: extend ([atype & proto+mmaps]) 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: extend-protocol ([p & specs]) Extends a protocol with implementations for multiple types.
• clojure.core/extend-type function: extend-type ([t & specs]) Extends a protocol with method implementations for the given type.
• clojure.core/extenders function: extenders ([protocol]) Returns a seq of the types explicitly extended to proto, or nil when there are none.
• clojure.core/extends? function: extends? ([protocol atype]) 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: false? ([x]) Returns true if x is the value false.
• clojure.core/ffirst function: ffirst ([x]) 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: file-seq ([dir]) Returns a vector of all file paths under a directory, recursively. Capability: :io
• clojure.core/file-size function: Returns the file size in bytes, or nil when the path is missing. Capability: :fs
• clojure.core/filter function: filter ([pred] [pred coll]) Returns a lazy sequence of items in coll for which pred returns truthy.
• clojure.core/filterv function: filterv ([pred coll]) Returns a vector of items in coll for which pred returns logical true.
• clojure.core/find function: find ([map key]) Returns the map entry for the key, or nil.
• clojure.core/find-keyword function: find-keyword ([name] [ns name]) Returns the already-interned keyword with the given name, or nil when it was never interned.
• clojure.core/find-ns function: find-ns ([sym]) Return the namespace symbol if it exists, else nil.
• clojure.core/find-var function: find-var ([sym]) Return the var named by a qualified symbol, or nil.
• clojure.core/first function: first ([coll]) Returns the first item in a collection, or nil if empty.
• clojure.core/flatten function: flatten ([x]) Returns a lazy sequence of the non-sequential items from a nested structure.
• clojure.core/float function: float ([x]) Coerces x to a 32-bit float (returns a MINO_FLOAT32).
• clojure.core/float-array function: float-array ([size-or-seq] [size init-val-or-seq]) Creates a host-style float array.
• clojure.core/float? function: float? ([n]) Returns true if x is a float.
• clojure.core/flock function: Acquires an advisory lock on a lockfile and returns a handle.
• clojure.core/flush function: flush ([]) Flushes pending output on *out* and *err*.
• clojure.core/fn function: fn ([& sigs]) Defines an anonymous function.
• clojure.core/fn? function: fn? ([x]) Returns true if x is callable as a function (fn or prim).
• clojure.core/fnext function: fnext ([x]) Same as (first (next coll)).
• clojure.core/fnil function: fnil ([f x] [f x y] [f x y z]) Returns a function like f, but replaces nil arguments with the given defaults.
• clojure.core/for function: for ([bindings & body]) List comprehension.
• clojure.core/force function: force ([x]) Forces evaluation of a delay.
• clojure.core/format function: format ([fmt & args]) Returns a formatted string using a format specifier and arguments.
• clojure.core/format-time function: Formats epoch milliseconds as a string.
• clojure.core/frequencies function: frequencies ([coll]) Returns a map from distinct items in coll to the number of times they appear.
• clojure.core/funlock function: Releases a lock acquired by flock.
• clojure.core/future function: future ([& body]) 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: future-call ([f]) Spawn a worker thread to evaluate the given thunk; return a future.
• clojure.core/future-cancel function: future-cancel ([f]) Cancel a pending future.
• clojure.core/future-cancelled? function: future-cancelled? ([f]) 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: future-done? ([f]) Return true if the future has reached a terminal state (resolved/failed/cancelled).
• clojure.core/future? function: future? ([x]) 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: gen-class ([& options])
• clojure.core/gensym function: gensym ([] [prefix-string]) Returns a new symbol with a unique name.
• clojure.core/get function: get ([map key] [map key not-found]) Returns the value mapped to key in a collection, or not-found.
• clojure.core/get-in function: get-in ([m ks] [m ks not-found]) Returns the value in a nested associative structure at the given key path.
• clojure.core/get-method function: get-method ([multifn dispatch-val]) Returns the method for dispatch-val, or nil.
• clojure.core/get-thread-bindings function: get-thread-bindings ([]) Returns a map of symbol->value for the active dynamic bindings, or nil if no binding frames are active.
• clojure.core/get-validator function: get-validator ([iref]) 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/glob function: Walks directories matching a glob pattern and answers a sorted (byte order) vector of path strings rendered as-given: a relative pattern with no root (or root ".") answers relative paths.
• clojure.core/group-by function: group-by ([f coll]) Returns a map of the items in coll grouped by the result of f.
• clojure.core/gzip-compress function: Compresses a bytes value into one RFC 1952 gzip member and returns the bytes.
• clojure.core/gzip-decompress function: Decodes a single-member gzip container from a bytes value and returns the decompressed bytes.
• clojure.core/halt-when function: halt-when ([pred] [pred retf]) Returns a transducer that halts reduction when pred is satisfied.
• clojure.core/hash function: hash ([x]) Returns the hash code of the value.
• clojure.core/hash-combine function: hash-combine ([x y]) Boost-style hash combiner: mixes seed and hash into a single 32-bit hash.
• clojure.core/hash-map function: hash-map ([] [& keyvals]) Returns a new hash map with the given key-value pairs.
• clojure.core/hash-ordered-coll function: hash-ordered-coll ([coll]) Computes a sequence-position-aware hash for an ordered collection.
• clojure.core/hash-set function: hash-set ([] [& keys]) Returns a new hash set containing the arguments.
• clojure.core/hash-unordered-coll function: hash-unordered-coll ([coll]) Computes a position-independent hash for an unordered collection.
• clojure.core/hex-decode function: Decodes hex from a string or bytes value; hex digits are case-insensitive and odd-length or non-hex input throws.
• clojure.core/hex-encode function: Encodes a string or bytes value as lowercase hex, two digits per byte.
• clojure.core/hmac-sha256 function: Computes the HMAC-SHA256 tag (RFC 2104) of data under key, each a string or bytes value, and returns the full 32-byte tag as a bytes value. Capability: :digest
• clojure.core/hmac-sha512 function: Computes the HMAC-SHA512 tag (RFC 2104) of data under key, each a string or bytes value, and returns the full 64-byte tag as a bytes value. Capability: :digest
• 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/html-parse function: Parses HTML text into a hickory-shaped node tree (ADR 28): elements are {:type :element :tag keyword :attrs {keyword string} :content [node|string]} with comments and the first DOCTYPE preserved and text as bare strings.
• clojure.core/http-encode-chunk function: Encodes one HTTP chunked frame from a string or bytes value: hex size, CRLF, the payload, CRLF.
• clojure.core/http-encode-request function: Serializes an HTTP request to bytes from a plain map: :method :target :host are required strings; :headers is a vector of [name value] pairs or a map (string or keyword names); :body is bytes or a string (emits Content-Length); :chunked? true emits Transfer-Encoding: chunked with no body (drive the frames with http-encode-chunk); :http10? true selects the HTTP/1.0 request line.
• clojure.core/http-encode-response function: Serializes an HTTP response map to bytes: :status is a required integer in 100..599 (reason phrase from a table of common codes, unknown codes carry none); :headers is a vector of [name value] pairs or a map (Content-Length, Transfer-Encoding, Connection, and Date are computed by the server and rejected in :headers); :body is bytes or a string and always emits Content-Length, absent means bodiless (204/304/HEAD handlers must omit it); :http10? selects the HTTP/1.0 status line; :close? emits Connection: close and :keep-alive? emits Connection: keep-alive (mutually exclusive); :date is a preformatted string emitted as the Date header.
• clojure.core/http-parse-request function: Parses a prefix of an HTTP request from a string or bytes value and returns {:status :need-more | :done | :error}.
• clojure.core/http-parse-request-chunks function: Parses an HTTP request from a vector of string or bytes buffers fed through one parser in order, and returns the same shape as http-parse-request.
• clojure.core/http-parse-response function: Parses a prefix of an HTTP response from a string or bytes value and returns {:status :need-more | :done | :error}.
• clojure.core/http-parse-response-chunks function: Parses an HTTP response from a vector of string or bytes buffers fed through one parser in order, and returns the same shape as http-parse-response.
• clojure.core/http-request function: Runs one HTTP request end to end from a normalized parts map and returns {:status :headers :body-bytes :http-version :from-pool? :request-time-ms :request :trace-redirects} (plus :content-encoding when a compressed body came back undecoded).
• clojure.core/human-diff function: Renders the difference b - a between two epoch-ms as the largest unit phrase: under a second "just now" / "in a moment", then seconds under 60, minutes under 60, hours under 24, calendar months under 12, then years, with full singular and plural words ("3 days ago", "in 5 minutes").
• clojure.core/ident? function: ident? ([x]) Returns true if x is a symbol or keyword.
• clojure.core/identical? function: identical? ([x y]) Returns true if the arguments are the same object.
• clojure.core/identity function: identity ([x]) Returns its argument.
• clojure.core/if-let function: if-let ([bindings then & else]) Binds the result of expr, evaluates then if truthy, else otherwise.
• clojure.core/if-not function: if-not ([test then & else]) Evaluates then when test is falsy, else otherwise.
• clojure.core/if-some function: if-some ([bindings then & else]) Binds the result of expr, evaluates then if non-nil, else otherwise.
• clojure.core/ifn? function: ifn? ([x]) Returns true if x can be called as a function.
• clojure.core/import function: import ([& import-symbols-or-lists])
• clojure.core/in-ns function: in-ns ([name]) 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: inc ([x]) Returns x plus 1.
• clojure.core/inc' function: inc' ([x]) Returns x plus 1.
• clojure.core/indexed? function: indexed? ([coll]) Returns true if x supports nth in constant time (vectors).
• clojure.core/infinite? function: infinite? ([num]) Returns true if x is positive or negative infinity.
• clojure.core/inst-ms function: inst-ms ([inst]) 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: inst-ms* ([inst])
• clojure.core/inst? function: inst? ([x])
• clojure.core/instance? function: instance? ([c x]) Returns true if x is an instance of t.
• clojure.core/int function: int ([x]) Coerces x to an int (32-bit integer).
• clojure.core/int-array function: int-array ([size-or-seq] [size init-val-or-seq]) Creates a host-style int array.
• clojure.core/int? function: int? ([x]) Returns true if x is an integer.
• clojure.core/integer? function: integer? ([n]) Returns true if x is an integer (long or bigint).
• clojure.core/interleave function: interleave ([] [c1] [c1 c2] [c1 c2 & colls]) Returns a lazy sequence of the first item in each collection, then the second, and so on.
• clojure.core/intern function: intern ([ns name] [ns name val]) Intern a value into a namespace by name.
• clojure.core/internal-reduce function:
• clojure.core/internal-reduce-kv function:
• clojure.core/interpose function: interpose ([sep] [sep coll]) Returns a lazy sequence of the items in coll separated by sep.
• clojure.core/into function: into ([] [to] [to from] [to xform from]) Adds all items from from into to.
• clojure.core/into-array function: into-array ([aseq] [type aseq]) Converts a collection to an Object array.
• clojure.core/io! function: io! ([& body]) 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: isa? ([child parent] [h child parent]) Returns true if child is equal to or derives from parent.
• clojure.core/iterate function: iterate ([f x]) Returns a lazy sequence of x, (f x), (f (f x)), and so on.
• clojure.core/iteration function: iteration ([step & {:keys [somef vf kf initk], :or {vf identity, kf identity, somef some?}}]) 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/json-parse function: Parses one JSON value from a string.
• clojure.core/juxt function: juxt ([f] [f g] [f g h] [f g h & fs]) Returns a function that returns a vector of applying each f to its args.
• clojure.core/keep function: keep ([f] [f coll]) Returns a lazy sequence of non-nil results of (f item).
• clojure.core/keep-indexed function: keep-indexed ([f] [f coll]) Returns a lazy sequence of non-nil results of (f index item). When called with no collection, returns a transducer.
• clojure.core/key function: key ([e]) Returns the key of a map entry.
• clojure.core/keys function: keys ([map]) Returns a sequence of the keys in a map.
• clojure.core/keyword function: keyword ([name] [ns name]) Returns a keyword with the given name.
• clojure.core/keyword? function: keyword? ([x]) Returns true if x is a keyword.
• clojure.core/kv-reduce function: kv-reduce ([coll f init])
• clojure.core/last function: last ([coll]) 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: lazy-cat ([& colls]) 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: lazy-seq ([& body]) 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/leap-year? function: True when the year is a Gregorian leap year (divisible by 4, except centuries not divisible by 400). Capability: :time
• clojure.core/let function: let ([bindings & body]) 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: let-bits ([bindings & body]) 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: letfn ([fnspecs & body]) Binds local functions.
• clojure.core/line-seq function: line-seq ([rdr]) 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: list ([& items]) Returns a list of the supplied arguments; () with no args.
• clojure.core/list* function: list* ([args] [a args] [a b args] [a b c args] [a b c d & more]) 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: list? ([x]) Returns true if x is a list (cons chain or the empty-list singleton).
• clojure.core/load-file function: load-file ([name]) 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: :image
• clojure.core/load-string function: load-string ([s]) Reads and evaluates all forms in the given source string.
• clojure.core/loaded-libs function: loaded-libs ([]) Return a vector of names that have been required.
• clojure.core/locking function: locking ([x & body]) Executes body while holding a monitor of x.
• clojure.core/long function: long ([x]) Coerces x to a long (64-bit integer).
• clojure.core/long-array function: long-array ([size-or-seq] [size init-val-or-seq]) Creates a host-style long array.
• clojure.core/loop function: loop ([bindings & body]) 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: macroexpand ([form]) Repeatedly expands a macro form until it is no longer a macro call.
• clojure.core/macroexpand-1 function: macroexpand-1 ([form]) Expands a macro form once.
• clojure.core/make-hierarchy function: make-hierarchy ([]) Returns an empty hierarchy.
• clojure.core/map function: map ([f] [f & colls]) 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: map-entry? ([x]) Returns true if x is a map entry (mino represents entries as 2-vectors).
• clojure.core/map-indexed function: map-indexed ([f] [f coll]) 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: map? ([x]) Returns true if x is a map (including sorted-map).
• clojure.core/mapcat function: mapcat ([f] [f coll] [f c1 c2] [f c1 c2 & colls]) Returns the result of applying concat to the result of mapping f over coll.
• clojure.core/mapv function: mapv ([f coll] [f c1 c2] [f c1 c2 c3] [f c1 c2 c3 & colls]) 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: max ([x] [x y] [x y & more]) Returns the greatest of the given values.
• clojure.core/max-key function: max-key ([k x] [k x y] [k x y & more]) Returns the x for which (k x) is greatest.
• clojure.core/md5 function: Computes the MD5 digest of a string or bytes value and returns the 16-byte digest as a bytes value.
• clojure.core/memoize function: memoize ([f]) Returns a memoized version of f that caches return values by arguments.
• clojure.core/merge function: merge ([& maps]) Returns a map that is the merge of the maps.
• clojure.core/merge-with function: merge-with ([f & maps]) Returns the merge of the given maps, calling f to combine values at shared keys.
• clojure.core/meta function: meta ([obj]) Returns the metadata map of the given value, or nil.
• clojure.core/methods function: methods ([multifn]) Returns the method table of multimethod mm.
• clojure.core/min function: min ([x] [x y] [x y & more]) Returns the least of the given values.
• clojure.core/min-key function: min-key ([k x] [k x y] [k x y & more]) 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: mix-collection-hash ([hash-basis count]) 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/mkdtemp function: Creates a uniquely-named private (0700) directory under the system temp dir and returns its path.
• clojure.core/mkstemp function: Creates a uniquely-named private (0600) empty file under the system temp dir and returns its path.
• clojure.core/mod function: mod ([num div]) Returns the modulus of dividing num by div.
• clojure.core/monitor-exit function: monitor-exit ([x owner]) Release one level of x for owner; drops the entry at depth zero.
• clojure.core/monitor-registry function:
• clojure.core/monitor-try-enter function: monitor-try-enter ([x owner]) Claim x for owner, or reenter if owner already holds it.
• clojure.core/months-between function: Whole calendar months from a to b: the largest n with (add-months a n) <= b, so a January 31 to February 28 gap counts as one month.
• clojure.core/name function: name ([x]) Returns the name string of a symbol, keyword, or string.
• clojure.core/namespace function: namespace ([x]) 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: nat-int? ([x]) Returns true if x is a non-negative integer (long tier).
• clojure.core/nav function: nav ([coll k v])
• clojure.core/neg-int? function: neg-int? ([x]) Returns true if x is a negative integer (long tier).
• clojure.core/neg? function: neg? ([num]) Returns true if x is less than zero.
• clojure.core/net-accept function: Waits for one inbound connection on a listener and returns it as a socket handle (the type net-connect returns; net-read / net-write / net-close work on it).
• clojure.core/net-close function: Closes a socket or listener.
• clojure.core/net-connect function: Connects to host:port over TCP.
• clojure.core/net-listen function: Binds a TCP listener and returns a listener handle.
• clojure.core/net-listener-port function: Returns the port a listener is bound to; how a caller learns the kernel-chosen port after net-listen with port 0.
• clojure.core/net-read function: Reads up to n bytes from a socket as soon as any arrive.
• clojure.core/net-read-all function: Reads from a socket until EOF.
• clojure.core/net-write function: Writes a string (UTF-8 bytes) or bytes to a socket.
• clojure.core/newline function: newline ([]) Writes a line separator to *out*.
• clojure.core/next function: next ([coll]) Returns a seq of the items after the first.
• clojure.core/nfirst function: nfirst ([x]) Same as (next (first coll)).
• clojure.core/nil? function: nil? ([x]) Returns true if x is nil.
• clojure.core/nnext function: nnext ([x]) Same as (next (next coll)).
• clojure.core/not function: not ([x]) Returns true if x is logical false, false otherwise.
• clojure.core/not-any? function: not-any? ([pred coll]) Returns true if (pred x) is falsy for every x in coll.
• clojure.core/not-empty function: not-empty ([coll]) Returns coll if it has items, nil otherwise.
• clojure.core/not-every? function: not-every? ([pred coll]) Returns true if (pred x) is falsy for at least one x in coll.
• clojure.core/not= function: not= ([x] [x y] [x y & more]) Returns true if the arguments are not equal.
• clojure.core/now function: Returns the wall clock as epoch milliseconds since 1970-01-01T00:00:00Z (an integer).
• clojure.core/now-s function: Returns the wall clock as epoch seconds since 1970-01-01T00:00:00Z (an integer).
• clojure.core/ns function: ns ([name docstring? attr-map? references*]) 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: ns-aliases ([ns]) Return the alias map of a namespace.
• clojure.core/ns-imports function: ns-imports ([ns]) Returns the import map of the namespace (always empty: no host classes).
• clojure.core/ns-interns function: ns-interns ([ns]) Return the interned bindings of a namespace as a map.
• clojure.core/ns-map function: ns-map ([ns]) Return all bindings visible in a namespace as a map.
• clojure.core/ns-name function: ns-name ([ns]) Return the symbol name of a namespace.
• clojure.core/ns-publics function: ns-publics ([ns]) Return the public bindings of a namespace as a map.
• clojure.core/ns-refers function: ns-refers ([ns]) Return the refer'd bindings of a namespace as a map.
• clojure.core/ns-resolve function: ns-resolve ([ns sym] [ns env sym]) Resolve a symbol to a var in the given namespace.
• clojure.core/ns-unalias function: ns-unalias ([ns sym]) Remove an alias from a namespace.
• clojure.core/ns-unmap function: ns-unmap ([ns sym]) Remove a binding from a namespace.
• clojure.core/nth function: nth ([coll index] [coll index not-found]) Returns the item at index n in a collection.
• clojure.core/nthnext function: nthnext ([coll n]) Returns the result of calling next n times on coll.
• clojure.core/nthrest function: nthrest ([coll n]) Returns the result of calling rest n times on coll.
• clojure.core/num function: num ([x]) 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: number? ([x]) Returns true if x is a number (int or float).
• clojure.core/numerator function: numerator ([r]) Returns the numerator of a rational number. Capability: :bignum
• clojure.core/object-array function: object-array ([size-or-seq]) Creates a host-style Object array.
• clojure.core/odd? function: odd? ([n]) Returns true if x is an odd integer.
• clojure.core/on-signal function: Traps signal sig (one of :int :term :hup :usr1 :usr2) with handler, a zero-argument function that runs at the interpreter safepoint after the signal is delivered, never in signal context.
• clojure.core/or function: or ([& xs]) Returns the first truthy value, or the last value if none are truthy.
• clojure.core/out-buffer function: Returns a fresh growable output sink for *out*; prints into it append in amortized constant time.
• clojure.core/out-buffer-line-start? function: Returns true when an out-buffer is empty or ends with a newline.
• clojure.core/out-buffer-str function: Returns the accumulated contents of an out-buffer as a string.
• clojure.core/out-buffer? function: Returns true if x is an out-buffer sink.
• clojure.core/parents function: parents ([tag] [h tag]) Returns the immediate parents of tag in the hierarchy.
• clojure.core/parse-boolean function: parse-boolean ([s]) Parses 'true' or 'false' (case-sensitive) and returns the boolean. Returns nil for strings that don't match.
• clojure.core/parse-double function: parse-double ([s]) Parses a string into a double, or returns nil on failure.
• clojure.core/parse-long function: parse-long ([s]) Parses a string into a long integer, or returns nil on failure.
• clojure.core/parse-time function: Parses a date or datetime string into {:epoch-ms :offset-min :format :date-only?}.
• clojure.core/parse-url function: Parses a hierarchical http or https URL into a plain map with :scheme :host :port :path :query :fragment :userinfo and :explicit-port?.
• clojure.core/parse-uuid function: parse-uuid ([s]) Parses s as a UUID; returns a UUID value or nil if s is not a valid canonical UUID string.
• clojure.core/partial function: partial ([f] [f arg1] [f arg1 arg2] [f arg1 arg2 arg3] [f arg1 arg2 arg3 & more]) Returns a function that applies f with the given arguments prepended.
• clojure.core/partition function: partition ([n coll] [n step coll] [n step pad coll]) Returns a lazy sequence of lists of n items each, at offsets step apart.
• clojure.core/partition-all function: partition-all ([n] [n coll] [n step coll]) 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: partition-by ([f] [f coll]) Splits coll into lazy sequences of consecutive items with the same (f item) value.
• clojure.core/partitionv function: partitionv ([n coll] [n step coll] [n step pad coll]) Like partition but returns a lazy seq of vectors instead of lists.
• clojure.core/partitionv-all function: partitionv-all ([n coll] [n step coll]) Like partition-all but returns a lazy seq of vectors instead of lists.
• clojure.core/path-absolute? function: True when the path starts with / after backslash folding.
• clojure.core/path-basename function: The last path segment, raw (no ..
• clojure.core/path-dirname function: The directory part: the cleaned path cut at the last separator.
• clojure.core/path-expand-home function: Expands a lone ~ or ~/ prefix through HOME (POSIX) or USERPROFILE then HOMEDRIVE+HOMEPATH (Windows).
• clojure.core/path-extension function: The extension with its dot and the last dot only: "a.tar.gz" answers ".gz"; dotfiles and plain names answer "".
• clojure.core/path-glob-match function: Pure glob matcher: does one path match one pattern? Syntax * ? [class] (ranges, ! negation) {a,b} (nested, comma-split) backslash-escape, ** as a whole segment matching zero or more directories (a trailing ** matches everything left).
• clojure.core/path-join function: Joins path parts with / and normalizes the result.
• clojure.core/path-normalize function: Lexical clean: backslashes fold to /, duplicate separators collapse, .
• clojure.core/path-split function: Splits a path into raw segments: empty segments drop, a leading / answers a "/" element, and .
• clojure.core/path-split-ext function: Splits a path into [stem extension] over the whole path (os.path shape); the extension is nil when absent (dotfiles included).
• clojure.core/path-stem function: The basename minus its last extension (the pathlib stem as a plain function): "/a/b/c.tar.gz" answers "c.tar"; ".bashrc" answers ".bashrc". Capability: :path
• clojure.core/pcalls function: pcalls ([& fns]) Executes the no-arg fns in parallel, returning a lazy sequence of their values.
• clojure.core/peek function: peek ([coll]) Returns the first item of a list or last item of a vector.
• clojure.core/percent-decode function: Decodes %XX escapes in a string or bytes value, returning the same kind.
• clojure.core/percent-encode function: Percent-encodes a string or bytes value per RFC 3986: unreserved characters (letters, digits, - .
• clojure.core/persistent! function: persistent! ([coll]) Seals a transient and returns its persistent collection.
• clojure.core/pmap function: pmap ([f coll]) Like map, except f is applied in parallel via futures.
• clojure.core/pool-checkout function: Returns a live idle keep-alive socket or TLS handle for the endpoint map {:scheme :host :port :insecure?}, or nil when nothing is pooled (the caller connects on nil; the pool never connects).
• clojure.core/pool-close-all function: Closes every pooled socket in every endpoint and empties the pools.
• clojure.core/pool-return function: Gives an idle socket or TLS handle back to its endpoint pool for reuse, stamped with the endpoint map's verification mode (:insecure?).
• clojure.core/pop function: pop ([coll]) Returns a collection without the peek item.
• clojure.core/pop! function: pop! ([coll]) Removes the last element from a transient vector.
• clojure.core/pop-thread-bindings function: pop-thread-bindings ([]) 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: pos-int? ([x]) Returns true if x is a positive integer (long tier).
• clojure.core/pos? function: pos? ([num]) Returns true if x is greater than zero.
• clojure.core/postwalk function: postwalk ([f form]) Walks form depth-first, applying f to each sub-form after its children.
• clojure.core/postwalk-replace function: postwalk-replace ([smap form]) Replaces items in form that appear as keys in smap, walking bottom-up.
• clojure.core/pr function: pr ([] [x] [x & more]) 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: pr-str ([& xs]) Returns a readable string representation of the arguments.
• clojure.core/prefer-method function: prefer-method ([multifn dispatch-val-x dispatch-val-y]) Prefers dispatch-val x over y in multimethod mm.
• clojure.core/prefers function: prefers ([multifn]) Returns the prefer-table of multimethod mm.
• clojure.core/prewalk function: prewalk ([f form]) Walks form depth-first, applying f to each sub-form before its children.
• clojure.core/prewalk-replace function: prewalk-replace ([smap form]) Replaces items in form that appear as keys in smap, walking top-down.
• clojure.core/print function: print ([& more]) Prints the arguments space-separated to *out*, without a trailing newline.
• clojure.core/print-method function:
• clojure.core/print-simple function: print-simple ([o w]) Writes the plain text form of o (its str form, bypassing the print-method dispatch) to w, an output sink such as the buffer *out* is bound to inside with-out-str or a string-collecting atom.
• clojure.core/print-str function: print-str ([& xs]) Returns the print-string of args, space-separated, no trailing newline.
• clojure.core/printf function: printf ([fmt & args]) Formats and prints to *out*: equivalent to (print (apply format fmt args)).
• clojure.core/println function: println ([& more]) Prints the arguments to *out*, followed by a newline.
• clojure.core/println-str function: println-str ([& xs]) Returns the print-string of args followed by a newline.
• clojure.core/prn function: prn ([& more]) Prints the arguments readably to *out*, followed by a newline.
• clojure.core/prn-str function: prn-str ([& xs]) Returns the readable-string of args followed by a newline.
• clojure.core/promise function: promise ([]) Return a fresh promise that can be deliver'd a value once.
• clojure.core/protocol-dispatch function: protocol-dispatch ([dispatch-atom mname & args])
• clojure.core/proxy function: proxy ([& _])
• clojure.core/push-thread-bindings function: push-thread-bindings ([bindings]) 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: pvalues ([& exprs]) Returns a lazy sequence of the values of the exprs, which are evaluated in parallel via pcalls.
• clojure.core/qualified-ident? function: qualified-ident? ([x]) Returns true if x is a namespace-qualified symbol or keyword.
• clojure.core/qualified-keyword? function: qualified-keyword? ([x]) Returns true if x is a namespace-qualified keyword.
• clojure.core/qualified-symbol? function: qualified-symbol? ([x]) Returns true if x is a namespace-qualified symbol.
• clojure.core/queue? function: Returns true if x is a PersistentQueue.
• clojure.core/quot function: quot ([num div]) Returns the quotient of dividing num by div, truncated toward zero.
• clojure.core/rand function: rand ([] [n]) Returns a random float between 0 inclusive and 1 exclusive, or between 0 and n.
• clojure.core/rand-hex function: Returns n random bytes from the OS source encoded as a lowercase hex string of length 2n.
• clojure.core/rand-int function: rand-int ([n]) Returns a random integer between 0 (inclusive) and n (exclusive).
• clojure.core/rand-nth function: rand-nth ([coll]) Returns a random element from coll.
• clojure.core/rand-token function: Returns n random bytes from the OS source encoded as an unpadded base64url token (alphabet A-Za-z0-9-_).
• clojure.core/random-sample function: random-sample ([prob] [prob coll]) 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: random-uuid ([]) Returns a random UUID v4 string.
• clojure.core/range function: range ([] [end] [start end] [start end step]) 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: ratio? ([n]) Returns true if x is a ratio. Capability: :bignum
• clojure.core/rational? function: rational? ([n]) Returns true if x is a rational number (int, bigint, or ratio). Capability: :bignum
• clojure.core/rationalize function: rationalize ([num]) Returns the rational value nearest to the argument. Capability: :bignum
• clojure.core/re-find function: re-find ([m] [re s]) Find the first match.
• clojure.core/re-find-from function: Internal: finds the first match at or after a byte index; returns [match start end] or nil. Capability: :regex
• clojure.core/re-groups function: re-groups ([m]) 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: re-matcher ([re s]) Returns a matcher value for repeated find/match operations on text using pattern.
• clojure.core/re-matches function: re-matches ([re s]) Like re-find but anchored to the whole string.
• clojure.core/re-pattern function: re-pattern ([s]) Returns a regex from a string pattern (no-op on an existing regex). Capability: :regex
• clojure.core/re-seq function: re-seq ([re s]) Returns a lazy sequence of all matches of pattern in string s.
• clojure.core/read function: read ([] [s] [opts s])
• clojure.core/read* function: Reads one form from *in*.
• clojure.core/read+string function: read+string ([s]) 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: read-line ([]) Reads one line from *in*.
• clojure.core/read-password function: Reads one line from stdin with terminal echo turned off, so a typed secret is not shown, and returns it without the trailing newline.
• clojure.core/read-string function: read-string ([s] [opts s]) Reads one form from the string.
• clojure.core/read-symlink function: Returns the target path a symlink points at. Capability: :fs
• clojure.core/reader-conditional function: reader-conditional ([form splicing?]) Builds a reader-conditional record with form and splicing? fields. Predicate reader-conditional? returns true on the result.
• clojure.core/reader-conditional? function: reader-conditional? ([value]) Returns true if x is a reader-conditional record produced by reader-conditional.
• clojure.core/realized? function: realized? ([x]) Returns true if the lazy value 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: record? ([x]) Returns true if x is a record value.
• clojure.core/redirect-next function: Decides one redirect hop from a request map, a response map, and opts.
• clojure.core/reduce function: reduce ([f coll] [f val coll]) Reduces coll using f.
• clojure.core/reduce-kv function: reduce-kv ([f init coll]) Reduces a map (or any associative source) with f taking accumulator, key, and value.
• clojure.core/reduced function: reduced ([x]) Wraps a value to signal early termination of reduce.
• clojure.core/reduced? function: reduced? ([x]) Returns true if x is a reduced value.
• clojure.core/reductions function: reductions ([f coll] [f init coll]) Returns a lazy sequence of the intermediate values of a reduction. A reduced value from f (or as init) short-circuits: its dereferenced value becomes the final element.
• clojure.core/ref function: ref ([x] [x & options]) Creates an STM ref holding the given initial value.
• clojure.core/ref-history-count function: ref-history-count ([ref]) Returns the ref's current history-count.
• clojure.core/ref-max-history function: ref-max-history ([ref] [ref n]) Returns the ref's max-history.
• clojure.core/ref-min-history function: ref-min-history ([ref] [ref n]) Returns the ref's min-history.
• clojure.core/ref-set function: ref-set ([ref val]) Sets the value of ref.
• clojure.core/ref? function: Returns true if x is an STM ref. Capability: :stm
• clojure.core/refer function: refer ([ns-sym & filters]) Bring all publics of a namespace into the current namespace.
• clojure.core/refer-clojure function: refer-clojure ([& filters]) 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: reify ([& opts+specs]) Returns an instance of a fresh anonymous record type that satisfies the named protocols.
• clojure.core/release-pending-sends function: release-pending-sends ([]) Returns the count of sends queued by the current transaction and clears them so they will NOT fire on commit.
• clojure.core/rem function: rem ([num div]) Returns the remainder of dividing num by div.
• clojure.core/remove function: remove ([pred] [pred coll]) Returns a lazy sequence of items in coll for which pred returns falsy.
• clojure.core/remove-all-methods function: remove-all-methods ([multifn]) Removes all methods from multimethod mm.
• clojure.core/remove-method function: remove-method ([multifn dispatch-val]) Removes the method for dispatch-val from multimethod mm.
• clojure.core/remove-ns function: remove-ns ([sym]) Remove a namespace from the runtime.
• clojure.core/remove-tap function: remove-tap ([f]) Unregisters f from the tap registry.
• clojure.core/remove-watch function: remove-watch ([reference key]) Removes a watch function from an atom by key.
• clojure.core/repeat function: repeat ([x] [n x]) Returns a lazy sequence of xs.
• clojure.core/repeatedly function: repeatedly ([f] [n f]) Returns a lazy sequence of calls to f.
• clojure.core/replace function: replace ([smap] [smap coll]) Replace all matches of `match` in `s` with `replacement`.
• clojure.core/replicate function: replicate ([n x]) Returns a lazy seq of n copies of x.
• clojure.core/require function: require ([& args]) Loads and evaluates a mino source file.
• clojure.core/requiring-resolve function: requiring-resolve ([sym]) Require the namespace if needed, then resolve a qualified symbol.
• clojure.core/reset! function: reset! ([atom newval]) Sets the value of an atom to newval and returns newval.
• clojure.core/reset-meta! function: reset-meta! ([iref metadata-map]) Atomically resets the metadata for a reference type to meta-map. Returns meta-map.
• clojure.core/reset-vals! function: reset-vals! ([atom newval]) Sets the value of an atom and returns [old new].
• clojure.core/resolve function: resolve ([sym]) Returns the var to which a symbol resolves, or nil.
• clojure.core/rest function: rest ([coll]) Returns all but the first item in a collection.
• clojure.core/restart-agent function: restart-agent ([a new-state & options]) Clears the agent's error and resets its state to the given value.
• clojure.core/reverse function: reverse ([coll]) Returns s with its characters reversed.
• clojure.core/reversible? function: reversible? ([coll]) 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: rseq ([rev]) Returns a reverse sequence of a vector, or nil if empty.
• clojure.core/rsubseq function: rsubseq ([sc test key] [sc start-test start-key end-test end-key]) 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: run! ([proc coll]) Applies f to each item in coll for side effects.
• clojure.core/satisfies? function: satisfies? ([protocol x]) 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: :image
• clojure.core/second function: second ([x]) Returns the second item in coll.
• clojure.core/secure-rand-bytes function: Returns n bytes drawn from the OS cryptographic random source as a bytes value.
• clojure.core/select-keys function: select-keys ([map keyseq]) Returns a map containing only the entries whose keys are in ks.
• clojure.core/send function: send ([a f & args]) Dispatches an action onto the agent's POOLED run-queue and returns the agent immediately.
• clojure.core/send-off function: send-off ([a f & args]) Dispatches an action onto the agent's SOLO run-queue.
• clojure.core/send-via function: send-via ([executor a f & args]) JVM-canon dispatches the action through a host-supplied Executor.
• clojure.core/seq function: seq ([coll]) Returns a seq on the collection, or nil if empty.
• clojure.core/seq-to-map-for-destructuring function: seq-to-map-for-destructuring ([s]) Builds a map from a sequence of keyword/value pairs, possibly with a trailing override map.
• clojure.core/seq? function: seq? ([x]) Returns true if x is a cons cell or lazy-seq.
• clojure.core/seqable? function: seqable? ([x]) Returns true if (seq x) is supported.
• clojure.core/seque function: seque ([s] [n-or-q s]) 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: sequence ([coll] [xform coll] [xform coll & colls]) Coerces coll to a (possibly empty) sequence, if it is not already one.
• clojure.core/sequential? function: sequential? ([coll]) Returns true if x is a sequential collection (list, vector, lazy-seq, or queue).
• clojure.core/set function: set ([coll]) Returns a set of the items in coll.
• clojure.core/set! function: set! ([target value]) 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: set-error-handler! ([a handler-fn]) Sets the agent's error-handler fn (called with [agent ex] when an action throws). Capability: :agent
• clojure.core/set-error-mode! function: set-error-mode! ([a mode-keyword]) 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: set-validator! ([iref validator-fn]) Sets a validator function on an atom.
• clojure.core/set? function: set? ([x]) 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/sha1 function: Computes the SHA-1 digest of a string or bytes value and returns the 20-byte digest as a bytes value.
• clojure.core/sha256 function: Computes the SHA-256 digest of a string or bytes value (a string contributes its UTF-8 bytes) and returns the 32-byte digest as a bytes value.
• clojure.core/sha512 function: Computes the SHA-512 digest of a string or bytes value (a string contributes its UTF-8 bytes) and returns the 64-byte digest as a bytes value.
• clojure.core/short function: short ([x]) Coerces x to a short (16-bit integer).
• clojure.core/short-array function: short-array ([size-or-seq] [size init-val-or-seq]) Creates a host-style short array.
• clojure.core/shuffle function: shuffle ([coll]) Returns a randomly shuffled vector of the items in coll.
• clojure.core/shutdown-agents function: shutdown-agents ([]) 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: simple-ident? ([x]) Returns true if x is a non-namespace-qualified symbol or keyword.
• clojure.core/simple-keyword? function: simple-keyword? ([x]) Returns true if x is a keyword with no namespace.
• clojure.core/simple-symbol? function: simple-symbol? ([x]) Returns true if x is a symbol with no namespace.
• clojure.core/slurp function: slurp ([f]) Reads the entire contents of a file as a string. Capability: :io
• clojure.core/some function: some ([pred coll]) Returns the first truthy value of (pred x) for any x in coll, else nil.
• clojure.core/some-> function: some-> ([expr & forms]) Thread-first through forms, short-circuiting on nil.
• clojure.core/some->> function: some->> ([expr & forms]) Thread-last through forms, short-circuiting on nil.
• clojure.core/some-fn function: some-fn ([p] [p1 p2] [p1 p2 p3] [p1 p2 p3 & ps]) Returns a function that returns the first truthy value from any pred applied to any argument.
• clojure.core/some? function: some? ([x]) Returns true if x is not nil.
• clojure.core/sort function: sort ([coll] [comp coll]) Returns a sorted sequence of the items in coll.
• clojure.core/sort-by function: sort-by ([keyfn coll] [keyfn comp coll]) Returns a sorted sequence of the items in coll, ordered by (keyfn item).
• clojure.core/sorted-map function: sorted-map ([& keyvals]) Returns a new sorted map with the given key-value pairs.
• clojure.core/sorted-map-by function: sorted-map-by ([comparator & keyvals]) Returns a sorted map using the given comparator function.
• clojure.core/sorted-set function: sorted-set ([& keys]) Returns a new sorted set containing the arguments.
• clojure.core/sorted-set-by function: sorted-set-by ([comparator & keys]) Returns a sorted set using the given comparator function.
• clojure.core/sorted? function: sorted? ([coll]) Returns true if x is a sorted collection.
• clojure.core/special-symbol? function: special-symbol? ([s]) Returns true if x is a symbol that names a special form.
• clojure.core/spit function: spit ([f content & options]) Writes the string content to a file. Capability: :io
• clojure.core/split-at function: split-at ([n coll]) Returns a vector of [(take n coll) (drop n coll)].
• clojure.core/split-with function: split-with ([pred coll]) Returns a vector of [(take-while pred coll) (drop-while pred coll)].
• clojure.core/splitv-at function: splitv-at ([n coll]) Returns a vector [(vec (take n coll)) (drop n coll)]: the head is a vector, the tail stays a lazy seq.
• clojure.core/stat function: Returns a {:type :size :mode :mtime :symlink?} map, or nil when the path is missing.
• 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: str ([] [x] [x & ys]) Returns the string representation of the arguments concatenated.
• clojure.core/string? function: string? ([x]) 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: subs ([s start] [s start end]) Returns a substring from start (inclusive) to end (exclusive).
• clojure.core/subseq function: subseq ([sc test key] [sc start-test start-key end-test end-key]) Returns the entries of a sorted collection whose keys fall in the given range, ascending.
• clojure.core/subvec function: subvec ([v start] [v start end]) Returns a subvector from start (inclusive) to end (exclusive).
• clojure.core/swap! function: swap! ([atom f] [atom f x] [atom f x y] [atom f x y & args]) Atomically applies f to the current value of the atom and any additional args.
• clojure.core/swap-vals! function: swap-vals! ([atom f] [atom f x] [atom f x y] [atom f x y & args]) Atomically applies f to the atom and returns [old new].
• clojure.core/symbol function: symbol ([name] [ns name]) Returns a symbol with the given name.
• clojure.core/symbol? function: symbol? ([x]) Returns true if x is a symbol.
• clojure.core/symlink function: Creates a symlink at the link path pointing at the target.
• clojure.core/sync function: sync ([flags-ignored-for-now & body]) Like dosync: runs the exprs (which may be nil) in an STM transaction.
• clojure.core/tagged-literal function: tagged-literal ([tag form]) Builds a tagged-literal record with tag and form fields.
• clojure.core/tagged-literal? function: tagged-literal? ([value]) Returns true if x is a tagged-literal record produced by tagged-literal.
• clojure.core/take function: take ([n] [n coll]) Returns a lazy sequence of the first n items in coll.
• clojure.core/take-last function: take-last ([n coll]) Returns a seq of the last n items in coll.
• clojure.core/take-nth function: take-nth ([n] [n coll]) Returns a lazy sequence of every nth item in coll.
• clojure.core/take-while function: take-while ([pred] [pred coll]) Returns a lazy sequence of items from coll while pred returns truthy.
• clojure.core/tap> function: tap> ([x]) Sends x to every registered tap.
• clojure.core/tar-create function: Builds a tar archive (ustar, with a GNU long-name header for a name past 100 bytes) from a vector of entry maps and returns the bytes.
• clojure.core/tar-entries function: Lists a tar archive's members as a vector of maps with the keys {:name :size :mode :mtime :type :linkname}, in archive order.
• clojure.core/tar-extract function: Materializes a tar archive under the destination directory and returns the vector of extracted member names in archive order.
• clojure.core/tar-read function: Returns one tar member's bytes: the FIRST member whose name equals name.
• clojure.core/terminal-height function: Returns the terminal height in rows: TIOCGWINSZ when a standard stream is a terminal (stdout first), else the ROWS environment variable when set to a plain numeric value, else 24. Capability: :term
• clojure.core/terminal-width function: Returns the terminal width in columns: TIOCGWINSZ when a standard stream is a terminal (stdout first), else the COLUMNS environment variable when set to a plain numeric value, else 80.
• clojure.core/test function: test ([v]) 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: the-ns ([x]) Return the namespace symbol or throw if not found.
• clojure.core/thread function: thread ([& body]) Executes the body in another thread, returning a future-like value that can be deref'd.
• clojure.core/thread-bound? function: thread-bound? ([& vars]) 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: time ([& body]) Evaluates body, prints elapsed time, and returns the result.
• clojure.core/time-map->epoch function: Converts a time map back to epoch milliseconds.
• clojure.core/time-ms function: Returns the current time in milliseconds. Capability: :io
• clojure.core/tls-close function: Closes a TLS socket, sending close_notify first.
• clojure.core/tls-connect function: Starts a TLS client session over a connected net socket ((tls-connect sock host opts?)) or a fresh TCP connection ((tls-connect host port opts?)).
• clojure.core/tls-read function: Reads up to n decrypted bytes from a TLS socket as soon as any arrive.
• clojure.core/tls-read-all function: Reads decrypted bytes from a TLS socket until the peer closes cleanly.
• clojure.core/tls-write function: Writes a string (UTF-8 bytes) or bytes to a TLS socket.
• clojure.core/to-array function: to-array ([coll]) Converts a collection to an Object array (host-style).
• clojure.core/toml-parse function: Parses TOML text into plain nested maps with keyword keys.
• clojure.core/trampoline function: trampoline ([f & args]) Calls f with args, then repeatedly calls the result if it is a function.
• clojure.core/transduce function: transduce ([xform f coll] [xform f init coll]) Reduces coll using the transducer xf applied to the reducing function f.
• clojure.core/transient function: transient ([coll]) 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: tree-seq ([branch? children root]) Returns a lazy depth-first sequence of nodes in a tree.
• clojure.core/true? function: true? ([x]) Returns true if x is the value true.
• clojure.core/tty? function: Returns true when the given standard stream (:stdout, :stderr, or :stdin) is attached to a terminal, false for files, pipes, and other redirects.
• clojure.core/type function: type ([x]) Returns a keyword indicating the type of the value.
• clojure.core/udp-close function: Closes a udp socket.
• clojure.core/udp-recv function: Receives one datagram on a udp socket.
• clojure.core/udp-send function: Sends a datagram to host:port from a udp socket.
• clojure.core/udp-socket function: Binds a UDP datagram socket and returns a socket handle.
• clojure.core/udp-socket-port function: Returns the port a udp socket is bound to; how a caller learns the kernel-chosen port after an ephemeral bind.
• clojure.core/uname function: Returns a map of host identity: :sysname, :nodename, :release, :version, :machine. Capability: :io
• clojure.core/unchecked-add function: unchecked-add ([x y]) Returns x + y as a long with two's-complement wraparound.
• clojure.core/unchecked-add-int function: unchecked-add-int ([x y]) Returns x + y with 32-bit two's-complement wraparound.
• clojure.core/unchecked-byte function: unchecked-byte ([x]) Coerce x to an 8-bit signed byte (stored in a long with sign extension).
• clojure.core/unchecked-char function: unchecked-char ([x]) Coerce x to a Unicode char by truncating to 16 bits (matching JVM char).
• clojure.core/unchecked-dec function: unchecked-dec ([x]) Returns x - 1 as a long with two's-complement wraparound.
• clojure.core/unchecked-dec-int function: unchecked-dec-int ([x]) Returns x - 1 with 32-bit two's-complement wraparound.
• clojure.core/unchecked-divide-int function: unchecked-divide-int ([x y]) Returns the truncating integer division of x by y.
• clojure.core/unchecked-double function: unchecked-double ([x]) Coerce x to a 64-bit double.
• clojure.core/unchecked-float function: unchecked-float ([x]) Coerce x to a 32-bit float.
• clojure.core/unchecked-inc function: unchecked-inc ([x]) Returns x + 1 as a long with two's-complement wraparound.
• clojure.core/unchecked-inc-int function: unchecked-inc-int ([x]) Returns x + 1 with 32-bit two's-complement wraparound.
• clojure.core/unchecked-int function: unchecked-int ([x]) Coerce x to a 32-bit signed int (stored in a long with sign extension).
• clojure.core/unchecked-long function: unchecked-long ([x]) Coerce x to a 64-bit long by truncating toward zero.
• clojure.core/unchecked-multiply function: unchecked-multiply ([x y]) Returns x * y as a long with two's-complement wraparound.
• clojure.core/unchecked-multiply-int function: unchecked-multiply-int ([x y]) Returns x * y with 32-bit two's-complement wraparound.
• clojure.core/unchecked-negate function: unchecked-negate ([x]) Returns -x as a long with two's-complement wraparound.
• clojure.core/unchecked-negate-int function: unchecked-negate-int ([x]) Returns -x with 32-bit two's-complement wraparound.
• clojure.core/unchecked-remainder-int function: unchecked-remainder-int ([x y]) Returns the 32-bit signed remainder of x divided by y.
• clojure.core/unchecked-short function: unchecked-short ([x]) Coerce x to a 16-bit signed short (stored in a long with sign extension).
• clojure.core/unchecked-subtract function: unchecked-subtract ([x y]) Returns x - y as a long with two's-complement wraparound.
• clojure.core/unchecked-subtract-int function: unchecked-subtract-int ([x y]) Returns x - y with 32-bit two's-complement wraparound.
• clojure.core/underive function: underive ([tag parent] [h tag parent]) Removes a parent/child relationship between child and parent.
• clojure.core/unquote function: unquote ([& _]) Placeholder for the ~ reader form.
• clojure.core/unquote-splicing function: unquote-splicing ([& _]) Placeholder for the ~@ reader form.
• clojure.core/unreduced function: unreduced ([x]) Unwraps a reduced value.
• clojure.core/unsigned-bit-shift-right function: unsigned-bit-shift-right ([x n]) Returns n logically shifted right by count bits.
• clojure.core/update function: update ([m k f & args]) Updates the value at key k in map m by applying f to the old value and any args.
• clojure.core/update-in function: update-in ([m ks f & args]) Updates a value in a nested associative structure by applying f at the given key path.
• clojure.core/update-keys function: update-keys ([m f]) Returns a map with f applied to each key.
• clojure.core/update-vals function: update-vals ([m f]) Returns a map with f applied to each value.
• clojure.core/uri? function: uri? ([x])
• clojure.core/use function: use ([& args]) Loads a module and refers all of its public names by default.
• clojure.core/user-name function: Returns the current effective user's login name. Capability: :io
• clojure.core/uuid? function: uuid? ([x]) Returns true if x is a UUID value.
• clojure.core/val function: val ([e]) Returns the value of a map entry.
• clojure.core/vals function: vals ([map]) Returns a sequence of the values in a map.
• clojure.core/var-get function: var-get ([x]) Return the current value of a var: the thread-local binding if one is active, otherwise the root value.
• clojure.core/var-set function: var-set ([x val]) Set the root value of a var.
• clojure.core/var? function: var? ([v]) Returns true if x is a var.
• clojure.core/vary-meta function: vary-meta ([obj f & args]) Returns a copy of the value with (apply f meta args) as its metadata.
• clojure.core/vec function: vec ([coll]) Converts coll into a vector.
• clojure.core/vector function: vector ([] [a] [a b] [a b c] [a b c d] [a b c d e] [a b c d e f] [a b c d e f & args]) Returns a new vector containing the arguments.
• clojure.core/vector? function: vector? ([x]) Returns true if x is a vector.
• clojure.core/volatile! function: volatile! ([val]) Creates a volatile cell with the given initial value.
• clojure.core/volatile? function: volatile? ([x]) Returns true if x is a volatile.
• clojure.core/vreset! function: vreset! ([vol newval]) Sets the value of a volatile to newval and returns newval.
• clojure.core/vswap! function: vswap! ([vol f & args]) Non-atomically swaps the value of the volatile to be: (apply f current-value-of-vol args).
• clojure.core/walk function: walk ([inner outer form]) Traverses form, applying inner to each element and outer to the result.
• clojure.core/weekday function: Returns the day of the week as an integer 0..6, 0 = Sunday.
• clojure.core/when function: when ([test & body]) Evaluates body when test is truthy.
• clojure.core/when-first function: when-first ([[x coll] & body]) Binds the first element of a collection, evaluates body if the collection is non-empty.
• clojure.core/when-let function: when-let ([bindings & body]) Binds the result of expr, evaluates body if truthy.
• clojure.core/when-not function: when-not ([test & body]) Evaluates body when test is falsy.
• clojure.core/when-some function: when-some ([bindings & body]) 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: while ([test & body]) Repeatedly evaluates body while test is truthy.
• clojure.core/with-bindings function: with-bindings ([binding-map & body]) Takes a map of var->value pairs.
• clojure.core/with-bindings* function: with-bindings* ([binding-map f]) (with-bindings* bindings-map fn) — pushes the bindings as a dynamic frame and invokes fn with no args.
• clojure.core/with-file-lock function: with-file-lock ([bindings & body]) Acquires an advisory lock on the lockfile, binds name to the lock handle, evaluates body, and releases the lock on every exit, including a throwing one.
• clojure.core/with-in-str function: with-in-str ([s & body]) Evaluates body with *in* bound to a string-cursor atom holding s.
• clojure.core/with-local-vars function: with-local-vars ([name-vals-vec & body]) 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: with-meta ([obj m]) Returns a copy of the value with the given metadata map.
• clojure.core/with-open function: with-open ([bindings & body]) Binds resources, evaluates body, then closes each resource.
• clojure.core/with-out-str function: with-out-str ([& body]) Evaluates body with *out* bound to a fresh growable output buffer, and returns the accumulated string.
• clojure.core/with-precision function: with-precision ([precision & exprs]) Sets *math-context* to {:precision precision :rounding-mode mode} around body.
• clojure.core/with-redefs function: with-redefs ([bindings & body]) Temporarily rebinds the root bindings of vars while body executes, restoring them in a finally clause.
• clojure.core/with-redefs-fn function: with-redefs-fn ([binding-map func]) Temporarily rebinds the root values of vars to new-values while thunk runs, restoring originals afterward.
• clojure.core/with-temp-dir function: with-temp-dir ([bindings & body]) Binds name to a fresh private temp directory, evaluates body, and removes the directory (and its contents) on every exit, including a throwing one.
• clojure.core/with-temp-file function: with-temp-file ([bindings & body]) Binds name to a fresh private temp file, evaluates body, and removes the file on every exit, including a throwing one.
• clojure.core/ws-accept-key function: Computes the Sec-WebSocket-Accept value from a Sec-WebSocket-Key string: the SHA-1 of the key concatenated with the RFC 6455 GUID, base64-encoded.
• clojure.core/ws-decode-frames function: Decodes complete websocket messages from an accumulated buffer and returns {:frames [..] :rest bytes}, where :rest is the suffix from the first incomplete frame or still-open fragment run, so feeding the rest plus more bytes resumes exactly where the last call stopped.
• clojure.core/ws-encode-frame function: Encodes one RFC 6455 websocket frame from a plain map and returns the wire bytes.
• clojure.core/xml-parse function: Parses a well-formed XML 1.0 document into the JVM clojure.xml element shape (ADR 28, strict mode): elements are {:tag keyword :attrs {keyword string} :content [string|node]} with case-sensitive names (a QName prefix keywordizes at its first colon), :attrs {} and :content [] always present, the root element only (comments, processing instructions, and the DOCTYPE drop; character data merges across them into one string per position).
• clojure.core/xml-seq function: xml-seq ([root]) A tree seq on the xml elements as per xml/parse: nodes are maps with :tag and :content keys, leaves are strings.
• clojure.core/yaml-parse function: Parses YAML subset text into a vector of documents (ADR 26).
• clojure.core/zero? function: zero? ([num]) Returns true if x is zero.
• clojure.core/zip-entries function: Lists a zip archive's entries as a vector of maps with the keys {:name :size :compressed-size :crc32 :method :mtime :directory? :comment}, in archive order, from the central directory.
• clojure.core/zip-read function: Returns one zip entry's bytes: the FIRST central-directory entry whose decoded name equals name (the same decoding zip-entries listed).
• clojure.core/zip-write function: Builds a zip archive in memory from a vector of entry maps and returns the bytes.
• clojure.core/zipmap function: zipmap ([keys vals]) Returns a map with keys mapped to corresponding vals.
• clojure.core/zlib-compress function: Compresses a bytes value into one RFC 1950 zlib stream (CMF/FLG header plus big-endian Adler-32 trailer) and returns the bytes.
• clojure.core/zlib-decompress function: Decodes one RFC 1950 zlib stream from a bytes value and returns the decompressed bytes.
• clojure.core/zone-offset-mins function: Returns a zone's UTC offset in minutes at an epoch-ms instant.
• clojure.lang.PersistentQueue/EMPTY function:
• clojure.repl/apropos function: apropos ([str-or-pattern]) 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: dir ([ns-sym]) Prints a sorted list of public names in the given namespace symbol.
• clojure.repl/dir-fn function: dir-fn ([ns-sym]) Returns a sorted seq of symbols for public names in the namespace named by `ns-sym`.
• clojure.repl/doc function: doc ([name]) Prints documentation for the named var.
• clojure.repl/doc-string function: Returns the documentation string for the named var: name, arglists, and docstring lines when the var's meta carries :arglists, else the bare docstring.
• clojure.repl/find-doc function: find-doc ([re-string-or-pattern]) 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: pst ([] [e]) Prints the most recent exception (`*e`) as a formatted summary.
• clojure.repl/source function: source ([name]) 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/blank? function: blank? ([s])
• clojure.string/capitalize function: capitalize ([s])
• clojure.string/ends-with? function: ends-with? ([s substr])
• clojure.string/escape function: escape ([s cmap])
• clojure.string/includes? function: includes? ([s substr])
• clojure.string/index-of function: index-of ([s value] [s value from-index]) Return index of value (string or char) in s, optionally searching forward from from-index.
• clojure.string/join function: join ([coll] [separator coll]) Returns a string of the items in coll joined by separator.
• clojure.string/last-index-of function: last-index-of ([s value] [s value from-index]) Return last index of value (string or char) in s, optionally searching backward from from-index.
• clojure.string/lower-case function: lower-case ([s])
• clojure.string/re-quote-replacement function: re-quote-replacement ([replacement]) Escapes $ and \ in replacement so s can be used literally in replacement strings without triggering backreference syntax.
• clojure.string/replace function: replace ([s match replacement]) Replace all matches of `match` in `s` with `replacement`.
• clojure.string/replace-first function: replace-first ([s match replacement]) Replaces only the first occurrence of match in s with replacement. match may be a string, char, or regex; for regex match, replacement may be a $N template string or a function, exactly as in replace.
• clojure.string/reverse function: reverse ([s]) Returns s with its characters reversed.
• clojure.string/split function: split ([s re] [s re limit]) Splits a string on a regex pattern.
• clojure.string/split-lines function: split-lines ([s])
• clojure.string/starts-with? function: starts-with? ([s substr])
• clojure.string/trim function: trim ([s])
• clojure.string/trim-newline function: trim-newline ([s])
• clojure.string/triml function: triml ([s])
• clojure.string/trimr function: trimr ([s])
• clojure.string/upper-case function: upper-case ([s])
• 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.
• 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.
• ^:private function:
• ^:private function:
• ^:private function:
• ^{:arglists function:
• 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:
• ^:private function:
• 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:
• ^: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 growable output buffer, 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.
• with-temp-dir macro: Binds name to a fresh private temp directory, evaluates body, and removes the directory (and its contents) on every exit, including a throwing one.
• with-temp-file macro: Binds name to a fresh private temp file, evaluates body, and removes the file on every exit, including a throwing one.
• with-file-lock macro: Acquires an advisory lock on the lockfile, binds name to the lock handle, evaluates body, and releases the lock on every exit, including a throwing one.
• ^: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: