Language Reference

+

Returns the sum of the arguments. Throws on long overflow; use +' to auto-promote to bigint.

(+ 1 2)

(+ 1 2.5)

(+ (dec' max-int) 1)

-

Returns the difference of the arguments. With one arg, returns the negation. Throws on long overflow; use -' to auto-promote.

(- 10 3 2)

(- 7)

(- tag-min 1)

*

Returns the product of the arguments. Throws on long overflow; use *' to auto-promote.

(* 2 3 4)

(* max-int 1)

(* 2 (quot (- tag-max 1) 2))

/

Returns the quotient of the arguments.

(/ 10 4)

(double (/ 10 4))

(/ 4 2)

mod

Returns the modulus of dividing num by div. Truncates toward negative infinity.

(mod 10 3)

(mod -10 3)

(mod 5.5 2.0)

rem

Returns the remainder of dividing num by div.

(rem 10 3)

(rem -10 3)

(rem 4 2)

quot

Returns the quotient of dividing num by div, truncated toward zero.

(quot 10 3)

(quot -10 3)

(* 2 (quot (- tag-max 1) 2))

inc

Returns x plus 1. Throws on long overflow; use inc' to auto-promote.

(inc 5)

(inc tag-max)

(type (inc tag-max))

dec

Returns x minus 1. Throws on long overflow; use dec' to auto-promote.

(dec 5)

(dec tag-min)

(type (dec tag-min))

+'

Returns the sum of the arguments. Auto-promotes to bigint on long overflow; use + to throw on overflow.

(+' max-int 1)

(+' 1 max-int)

(+' min-int -1)

-'

Returns the difference of the arguments. With one arg, returns the negation. Auto-promotes to bigint on long overflow.

(-' min-int 1)

(-' max-int -1)

(-' min-int)

*'

Returns the product of the arguments. Auto-promotes to bigint on long overflow.

(*' max-int 2)

(*' -1 min-int)

(*' min-int -1)

inc'

Returns x plus 1. Auto-promotes to bigint on long overflow.

(inc' max-int)

(inc' 9223372036854775807)

dec'

Returns x minus 1. Auto-promotes to bigint on long overflow.

(dec' min-int)

(+ (dec' max-int) 1)

(dec' -9223372036854775808)

=

Returns true if all arguments are equal.

(take 4 (iterate #(if (= % :foo) 42 :foo) :foo))

(loop [n 100 acc 0]
(if (= n 0)
  acc
  (recur (- n 1) (+ acc n))))

<

Returns true if nums are in monotonically increasing order.

(loop [a 1]
(if (< a 3)
  (recur (inc a))
  a))

(cond (< 3 2) (+ 1 2) true :result true (throw (ex-info "boom" {})))

(loop* [i 0] (if (< i 5) (recur (inc i)) i))

<=

Returns true if nums are in monotonically non-decreasing order.

(letfn [(factorial [n]
         (if (<= n 1) 1 (* n (factorial (dec n)))))]
(factorial 5))

(loop [n 5 acc 1]
(if (<= n 1) acc (recur (- n 1) (* acc n))))

(loop [n 5 acc 1]
(if (<= n 1) acc (recur (- n 1) (* acc n))))

>

Returns true if nums are in monotonically decreasing order.

(cond (> 3 2) (+ 1 2) true :result true (throw (ex-info "boom" {})))

((every-pred even? number? #(> % 0)))

((every-pred even? number? #(> % 0)) 2 4 6 8 10)

>=

Returns true if nums are in monotonically non-increasing order.

(reduce (fn [a x] (if (>= x 10) (reduced a) (+ a x)))
0 v)

not=

Returns true if the arguments are not equal.

compare

Returns a negative, zero, or positive integer comparing x and y.

(compare 1 2)

(compare 5 5)

(compare 10 3)

math-floor

Returns the largest integer not greater than n.

(math-floor 3.7)

(math-floor 3.0)

(math-floor -3.2)

math-ceil

Returns the smallest integer not less than n.

(math-ceil 3.2)

(math-ceil 3.0)

(math-ceil -3.2)

math-round

Returns the closest integer to n.

(math-round 3.5)

(math-round 3.4)

(math-round -3.5)

math-sqrt

Returns the square root of n.

(math-sqrt 16)

(math-sqrt 0)

(math-sqrt 1)

math-pow

Returns base raised to the power of exp.

(math-pow 2 10)

(math-pow 5 0)

(math-pow 2 3)

math-log

Returns the natural logarithm of n.

(math-log 1)

math-exp

Returns e raised to the power of n.

(math-exp 0)

math-sin

Returns the sine of n (in radians).

(math-sin 0)

math-cos

Returns the cosine of n (in radians).

(math-cos 0)

math-tan

Returns the tangent of n (in radians).

(math-tan 0)

math-atan2

Returns the angle in radians between the positive x-axis and the point (x, y).

(math-atan2 0 1)

bit-and

Returns the bitwise AND of the arguments.

(bit-and 12 10)

bit-or

Returns the bitwise OR of the arguments.

(bit-or 12 10)

bit-xor

Returns the bitwise XOR of the arguments.

(bit-xor 12 10)

bit-not

Returns the bitwise complement of n.

(bit-not 0)

bit-shift-left

Returns n shifted left by count bits.

(bit-shift-left 1 4)

(bit-shift-left 1 0)

(bit-shift-left 1 63)

bit-shift-right

Returns n arithmetically shifted right by count bits.

(bit-shift-right 16 2)

(bit-shift-right 1 0)

(bit-shift-right 1 63)

car

Returns the first element of a cons cell.

(car '(1 2 3))

(car (source-form '__sq))

cdr

Returns the rest of a cons cell.

(cdr '(1 2 3))

cons

Returns a new list with x prepended to coll.

(apply (fn [a b & rest] (vec (cons a (cons b rest)))) [1 2 3 4 5])

(cons 1 '(2 3))

(get m (cons 0 (cons 1 (cons 2 nil))))

list

Returns a list of the supplied arguments; () with no args.

(vec (list 0 1 2 3))

(list 1 2 'a)

(list true false)

count

Returns the number of items in a collection.

(count bs)

(count bs)

(count bs)

nth

Returns the item at index n in a collection.

(nth (byte-array [9 8 7]) 1)

(nth (byte-array [9 8 7]) 99 :missing)

(meta (nth y 1))

first

Returns the first item in a collection, or nil if empty.

(first (byte-array [9 8 7]))

(loop [a []
     b [1 2 3]]
(if (seq b)
  (recur (conj a (* 2 (first b)))
         (next b))
  a))

(loop [a ()
     b [1 2 3]]
(if (seq b)
  (recur (conj a (* 2 (first b)))
         (next b))
  a))

rest

Returns all but the first item in a collection.

(vec (rest (byte-array [9 8 7])))

(rest [10 20 30])

(rest nil)

vector

Returns a new vector containing the arguments.

(vector 1 2 3)

(#(vector %1 (vec %&)) 1 2 3)

(into {} (map #(vector % (* % %))) [1 2 3])

hash-map

Returns a new hash map with the given key-value pairs.

(hash-map :a 1 :b 2)

assoc

Returns a new map with the given key-value pairs added.

(meta (reduce #(assoc %1 %2 (inc %2)) x (range 1000)))

(meta (assoc x 1 "one"))

(keys (assoc {:z 1 :a 2 :m 3} :a 99))

dissoc

Returns a map with the given keys removed.

(meta (-> x (dissoc :foo) (dissoc :bar)))

(dissoc {:a 1 :b 2 :c 3} :b)

(dissoc {:a 1 :b 2 :c 3} :a :c)

get

Returns the value mapped to key in a collection, or not-found.

(get result :mino/message)

(get data :n)

(get data :tag)

conj

Returns a new collection with items added.

(loop [a []
     b [1 2 3]]
(if (seq b)
  (recur (conj a (* 2 (first b)))
         (next b))
  a))

(loop [a ()
     b [1 2 3]]
(if (seq b)
  (recur (conj a (* 2 (first b)))
         (next b))
  a))

(meta (reduce #(conj %1 %2) x (range 1000)))

update

Updates the value at key k in map m by applying f to the old value and any args.

(update {:a [1]} :a conj 2)

(update [0] 0 inc)

(update {:a 1} :b identity)

keys

Returns a sequence of the keys in a map.

(keys {:z 1 :a 2 :m 3 :b 4})

(keys (assoc {:z 1 :a 2 :m 3} :a 99))

(keys (assoc {:z 1 :a 2} :b 3 :c 4))

vals

Returns a sequence of the values in a map.

(vals {:a 1 :b 2})

(set (vals entries))

(vals [[:a 1] [:b 2]])

hash

Returns the hash code of the value.

(hash (byte-array [1 2 3]))

(hash large2)

(hash (dissoc m :z))

hash-set

Returns a new hash set containing the arguments.

(hash-set 1 2 3)

set?

Returns true if x is a set (including sorted-set).

contains?

Returns true if the collection contains the key.

disj

Returns a set with the given keys removed.

(meta (-> x (disj 1) (disj 2) (disj 3)))

(disj #{1 2 3} 2)

(disj #{1 2 3 4} 2 4)

atom

Creates an atom with the given initial value.

(deref (atom 42))

@(atom 42)

(type (atom 1))

deref

Returns the current value of a reference (atom, delay, etc.).

(deref p 50 :timeout)

(deref p 500 :timeout)

(deref p 0 :timeout)

reset!

Sets the value of an atom to newval and returns newval.

(try (throw "x")
(catch e "caught")
(finally (reset! a 1)))

(try
(try (throw "x") (finally (reset! a 1)))
(catch e "got-it"))

(reset! a 42)

swap!

Atomically applies f to the current value of the atom and any additional args.

(let [a (atom 0)]
(dotimes [n 3] (swap! a inc))
@a)

(let [a (atom [])]
(dotimes [n 3] (swap! a conj n))
@a)

(let [a (atom [])]
(dotimes [n 0] (swap! a conj n))
@a)

atom?

Returns true if x is an atom.

(atom? 42)

(atom? [1 2 3])

(atom? nil)

map

Returns a lazy sequence of applying f to each item in coll. When called with multiple collections, maps f across them in parallel. When called with no collection, returns a transducer.

(map inc (byte-array [1 2 3]))

(map (fn [s] (s 0)) '(inc dec zero?))

(sequence (map inc) (range 10))

filter

Returns a lazy sequence of items in coll for which pred returns truthy. When called with no collection, returns a transducer.

(filter even? (byte-array [1 2 3 4 5]))

(eduction (map inc) (filter even?) (map str) (range 5))

(some->> [1 2 3] (map inc) (filter even?))

reduce

Reduces coll using f. With 2 args, uses the first element as init. With 3 args, uses init explicitly. Consults CollReduce: a user type or :default override on coll-reduce takes precedence over the built-in seq-driven reduction.

(reduce + (byte-array [1 2 3 4]))

(reduce * 1 (byte-array [1 2 3 4]))

(reduce + (byte-array 0))

take

Returns a lazy sequence of the first n items in coll. When called with no collection, returns a transducer.

(take 4 (iterate #(if (= % :foo) 42 :foo) :foo))

(take 10 (iterate #(quot % 2) 256))

(into [] (take 3) (next (iterate inc 0)))

drop

Returns a lazy sequence of all but the first n items in coll. When called with no collection, returns a transducer.

(pr-str (drop 0 [1 2 3 4]))

(pr-str (drop -1 [1 2 3 4]))

(pr-str (drop 2 [1 2 3 4]))

range

Returns a lazy sequence of nums from start (inclusive) to end (exclusive), by step. With no args, returns an infinite sequence from 0.

(mapv (fn [f] (f)) (mapv outer (range 10)))

(vec (range 4))

(meta (reduce #(assoc %1 %2 (inc %2)) x (range 1000)))

repeat

Returns a lazy sequence of xs. With two args, returns n repetitions of x. Per Clojure, n is truncated toward zero before counting (so 3.14 and 3.99 both yield three repetitions). Booleans coerce as if via `(if n 1 0)` to mirror the JVM behavior on non-:clj dialects.

(drop 1 (repeat 2 :a))

(drop 2 (repeat 2 :a))

(drop 3 (repeat 2 :a))

concat

Returns a lazy sequence of the concatenation of the given collections.

(into [] (concat [1 2] "ab"))

(concat [1 2] [3 4])

(concat [1] [2] [3])

into

Adds all items from from into to. With a transducer, transforms items first.

(into [] (byte-array [10 20 30]))

(into #{} (byte-array [1 2 3 1 2]))

(meta (into x y))

apply

Applies f to the arguments, with the last argument spread as a sequence.

(apply (fn [x y] [x y]) [1 2])

(apply (fn [a b & rest] (vec (cons a (cons b rest)))) [1 2 3 4 5])

(apply mapv vector [[:a :b :c] [:d :e :f] [:g :h :i]])

reverse

Returns a sequence of the items in coll in reverse order.

(reverse (list 1 2 3))

(reverse [1 2 3])

(reverse nil)

sort

Returns a sorted sequence of the items in coll.

(cond->> [4 3 2 1] true (sort <))

(sort [3 1 4 1 5])

(sort ["c" "a" "b"])

cons?

Returns true if x is a list (cons cell).

nil?

Returns true if x is nil.

(try (throw nil) (catch e (nil? (ex-data e))))

string?

Returns true if x is a string.

number?

Returns true if x is a number (int or float).

(postwalk (fn [x] (if (number? x) (inc x) x)) '(1 (2 3)))

keyword?

Returns true if x is a keyword.

symbol?

Returns true if x is a symbol.

vector?

Returns true if x is a vector.

map?

Returns true if x is a map (including sorted-map).

set?

Returns true if x is a set (including sorted-set).

fn?

Returns true if x is callable as a function (fn or prim).

empty?

Returns true if coll has no items.

seq?

Returns true if x is a cons cell or lazy-seq.

not

Returns true if x is logical false, false otherwise.

(not true)

(not false)

(not nil)

not=

Returns true if the arguments are not equal.

identity

Returns its argument.

(identity 42)

some

Returns the first truthy value of (pred x) for any x in coll, else nil.

(some pos? [1])

(some pos? [1 2])

(some pos? [-1])

every?

Returns true if (pred x) is truthy for every x in coll.

(every? pos? [1])

(every? pos? [1 2])

(every? pos? [1 2 3 4 5])

rand

Returns a random float between 0 inclusive and 1 exclusive, or between 0 and n.

eval

Evaluates the given form.

(with-in-str "(+ 10 20)" (eval (read)))

(eval '(+ 1 2))

(eval (read-string "(* 3 4)"))

type

Returns a keyword indicating the type of the value.

(type (+' max-int 1))

(type (*' max-int 2))

(type (+ 1 2))

name

Returns the name string of a symbol, keyword, or string.

(name :/)

(name      'abc/def)

(name      'abc)

symbol

Returns a symbol with the given name.

(str (symbol "Foo."))

(symbol "abc" "def")

(symbol "abc.def" "ghi")

keyword

Returns a keyword with the given name.

(keyword "abc" "def")

(keyword 'abc/def)

(keyword "abc.def" "ghi")

str

Returns the string representation of the arguments concatenated.

(str \A)

(str \a \b \c)

(str \space)

pr-str

Returns a readable string representation of the arguments.

(pr-str (byte-array [65 66 67]))

(pr-str (byte-array 0))

(pr-str (byte-array [255]))

format

Returns a formatted string using a format specifier and arguments.

(format "%d" 42)

(format "%s" "hello")

(format "%%")

subs

Returns a substring from start (inclusive) to end (exclusive).

(subs (str (random-uuid)) 14 15)

(subs "hello" 1 3)

(subs "hello" 2)

char-at

Returns the character at the given index as a string.

(char-at "hello" 0)

(char-at "hello" 4)

read-string

Reads one form from the string.

(read-string "\\A")

(read-string "\\space")

(read-string "\\newline")

re-find

Find the first match. (re-find pattern text) returns a string (no groups) or [whole g1 g2 ...] (groups). (re-find m) advances a matcher. Capability: :regex

(re-find #"[0-9]+" "abc123def")

(re-find #"hel+" "hello")

(re-find (re-pattern "abc") "xabcy")

re-matches

Like re-find but anchored to the whole string. Returns a string (no groups) or [whole g1 g2 ...] (groups), or nil. Capability: :regex

(re-matches "(.+)/(.+)" "a/b")

(re-matches "\\d+" "12345")

(re-matches "\\d+" "123abc")

int

Coerces x to an int (32-bit integer). Throws on out-of-range values, NaN, or infinity. Returns the value as a MINO_INT (mino has only one integer tier); only the contract narrows.

(int 3.7)

(int 5)

(int \space)

float

Coerces x to a 32-bit float (returns a MINO_FLOAT32). Throws on out-of-float32-range, +/-Infinity. NaN passes through. Underflow rounds toward zero.

(float 5.0)

(double (float 5))

throw

Throws an exception with the given value.

(when false (throw (ex-info "boom" {})))

(when-not true (throw (ex-info "boom" {})))

(if-let [a false] (throw (ex-info "boom" {})))

last-error

Returns the last error as a diagnostic map, or nil.

error?

Returns true if the value is a diagnostic map.

require

Loads and evaluates a mino source file.

(eval (read-string
"(do (require '[clojure [set :refer [union]]]) (union #{1 2 3} #{2 3 4}))"))

(eval (read-string "(do (ns foo) (def x 1) (ns bar) (def x 2) (in-ns 'baz) (def x 3) (require 'foo 'bar) [foo/x bar/x x])"))

(eval (read-string "(do (ns foo) (def x 1) (ns bar) (def x 2) (in-ns 'baz) (def x 3) (require (symbol \"foo\") (symbol \"bar\")) [foo/x bar/x x])"))

macroexpand

Repeatedly expands a macro form until it is no longer a macro call.

(macroexpand '(do-template [x y] (+ y x) 2 4 3 5))

(eval (read-string "(do (eval (macroexpand '(ns foo (:require [clojure.string :as str])))) `str/x)"))

macroexpand-1

Expands a macro form once.

gensym

Returns a new symbol with a unique name.

*1

*2

*3

*agent*

*assert*

Controls assertion compilation. When false, `assert` is a no-op. Defaults to true.

*command-line-args*

*compile-files*

*compile-path*

*data-readers*

*default-data-reader-fn*

*e

*err*

*file*

*flush-on-newline*

When true (the default), the I/O sink behind `*out*` is flushed automatically after any write that contains a newline. When false, the sink stays buffered so consecutive writes coalesce.

*in*

*math-context*

Precision/rounding-mode for bigdec division. nil means exact-or- throw (mirrors java.math.BigDecimal.divide without MathContext). When set, the value is a map of {:precision N :rounding-mode K} where N is a positive integer and K is one of: :half-up (default), :down, :up, :floor, :ceiling, :half-down, :half-even, :unnecessary. :unnecessary throws when rounding would change the value (mirrors JVM's ArithmeticException). Resolved by mino_bigdec_div on each call.

*out*

*print-dup*

When true, the printer emits forms a reader can reconstruct exactly. mino's built-in record / collection / scalar prints are already reader-roundtrip-compatible, so the flag is currently an information channel for user-installed print-method implementations that branch on dup vs. non-dup output. Default false.

*print-length*

Maximum number of items printed in a single collection (vector, list, map, set, chunk, chunked-cons). nil means no limit (the default). The remainder is replaced with `...`. Resolved once per top-level pr / prn / print / println / pr-str call; nested collections share the same limit.

*print-level*

Maximum nesting depth printed. A collection found at depth >= this limit is replaced with `#`. nil means no limit (the default). Resolved once per top-level pr / print call.

*print-meta*

When true, every value carrying non-nil metadata is printed with its meta map prefixed as `^{...} `. When false (the default), meta is silent. Resolved once per top-level pr / print call.

*print-namespace-maps*

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}`. Default false.

*print-readably*

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. When false, strings and characters print their underlying bytes — pr/prn behave like print/println. Resolved once per top-level pr / print call.

*source-path*

*unchecked-math*

*warn-on-reflection*

-empty-queue

Internal: return an empty PersistentQueue. Public surface is clojure.lang.PersistentQueue/EMPTY (a bound var) plus conj.

-lock-first

-lock-next

-thread-bound?

(-thread-bound? var) — true iff the var has a thread-local binding on the current dyn-stack. Clojure-level thread-bound? wraps this and is variadic.

-var-root-bound?

Return true if the var has a root binding. Internal helper backing the variadic Clojure-level bound?.

==

Returns true if nums are numerically equal, treating ints and floats uniformly.

Boolean/FALSE

Boolean/TRUE

Boolean/parseBoolean

Parses "true" (case-insensitive) to true; everything else to false.

Byte/MAX_VALUE

Byte/MIN_VALUE

Character/toString

JVM Character.toString; routes to mino's str.

(Character/toString \a)

CollReduce

CollReduce--coll-reduce

Datafiable

Datafiable--datafy

Double/MAX_VALUE

Double/MIN_VALUE

Double/NEGATIVE_INFINITY

Double/NaN

Double/POSITIVE_INFINITY

Double/isInfinite

True when the argument is +inf or -inf.

Double/isNaN

True when the argument is NaN.

Double/parseDouble

Parses a floating-point string. JVM Double static.

(Double/parseDouble "3.14")

Float/MAX_VALUE

Float/MIN_VALUE

Float/NEGATIVE_INFINITY

Float/NaN

Float/POSITIVE_INFINITY

Float/parseFloat

Alias for Double/parseDouble; mino has one float tier.

IKVReduce

IKVReduce--kv-reduce

Integer/MAX_VALUE

Integer/MIN_VALUE

Integer/parseInt

Alias for Long/parseLong; mino has one integer tier.

(Integer/parseInt "7")

Long/MAX_VALUE

Long/MIN_VALUE

Long/parseLong

Parses an integer string. JVM Long static.

(Long/parseLong "42")

(Long/parseLong "FF" 16)

Math/E

Math/PI

Math/abs

Absolute value (preserves int/double type).

(Math/abs -1.0)

(Math/abs -5)

Math/atan

Arctangent.

Math/atan2

Two-argument arctangent.

Math/ceil

Ceiling (rounds toward positive infinity).

(Math/ceil  2.3)

Math/cos

Cosine (radians).

Math/exp

e^x.

Math/floor

Floor (rounds toward negative infinity).

(Math/floor 2.7)

Math/log

Natural log.

Math/log10

Base-10 log.

Math/max

Numeric maximum of two values.

(Math/max 1 2)

Math/min

Numeric minimum of two values.

(Math/min 1 2)

Math/pow

Exponentiation.

(Math/pow 2 3)

Math/round

Round to nearest long.

(Math/round 2.7)

Math/sin

Sine (radians).

(Math/sin 0)

Math/sqrt

Square root.

(Math/sqrt 16)

Math/tan

Tangent (radians).

NaN?

Returns true if x is NaN.

Navigable

Navigable--nav

Short/MAX_VALUE

Short/MIN_VALUE

String/valueOf

JVM String.valueOf; routes to mino's str.

(String/valueOf 42)

(String/valueOf "abc")

System/currentTimeMillis

Epoch millis from the host clock.

System/exit

Exits the host process with the given status code.

System/getProperty

JVM system-properties lookup. mino has no JVM properties table; throws :mino/unsupported.

System/getenv

Reads an environment variable from the host process.

System/nanoTime

Monotonic nanosecond counter from the host clock.

Thread/sleep

Suspends the current thread for the given number of milliseconds.

(Thread/sleep 1)

abs

Returns the absolute value of x. Matches JVM Math/abs 2's-complement semantics: (abs Long/MIN_VALUE) returns Long/MIN_VALUE rather than overflowing, since the true absolute value is unrepresentable in a signed 64-bit int.

(abs -5)

(abs -1)

(abs 1)

add-load-path!

Appends a directory to the runtime's extra-load-paths list (consulted by `require` after project paths). Returns nil; idempotent.

add-tap

Registers f as a tap target. Each call to tap> invokes every registered tap with the tapped value. Returns nil.

add-watch

Adds a watch function to an atom, called on state changes.

(add-watch a :w (fn [k r o n] nil))

agent

Creates an asynchronous agent holding the given initial state. Mutate via send / send-off; read via @agent. The action runs on a per-state worker thread; await blocks until queued actions complete. Capability: :agent

agent-error

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

agent?

Returns true if x is an agent. Capability: :agent

aget

Reads slot `index` from a host array or a bytes value. On a bytes value, returns the byte at that index as an unsigned int (0..255).

(aget bs 0)

(aget bs 1)

(aget bs 0)

alength

Returns the slot count of a host array or the byte length of a bytes value.

(alength b)

alias

Add an alias to a namespace.

(eval (read-string "(do (alias (symbol \"c\") (symbol \"clojure.core\")) (c/and true 1))"))

(eval (read-string "(do (alias 'set1 'clojure.set) (alias 'set2 'clojure.set) (set2/difference (set1/union #{1 2 3} #{4 5 6}) #{4 5 6}))"))

all-ns

Return a vector of all known namespace symbols.

all-some?

alloc-profile-dump!

Dump the top-N allocation call sites to stderr. Defaults to 30; pass 0 for all.

alloc-profile-enabled?

Returns true if this binary was built with -DMINO_ALLOC_PROFILE=1.

alloc-profile-reset!

Zero the per-callsite allocation counters. No-op in non-profile builds.

alter

Sets ref to (apply f current-value args). Must be in dosync. Returns the new value. Capability: :stm

alter-meta!

Atomically applies f to the metadata of a reference.

alter-var-root

Apply a function to a var's root and store the result.

ancestors

Returns all ancestors of tag in the hierarchy.

(ancestors h :square)

(ancestors h :square)

(ancestors h :d)

any?

Returns true for any argument.

aset

Mutates the host array at index, storing val. Returns val. The host-array tier is the only path that exposes in-place mutation outside MINO_ATOM / MINO_VOLATILE. Throws :mino/state on a MINO_BYTES value -- the immutable bytes tier rejects in-place writes.

assoc!

Associates key with val in a transient map or vector.

assoc-in

Associates a value in a nested associative structure at the given key path.

(assoc-in {} [:a :b] 42)

(assoc-in {:a {:b 1}} [:a :b] 2)

associative?

Returns true if x supports assoc (maps and vectors).

async-sched-enqueue*

Enqueue a callback on the async scheduler run queue. Capability: :async

async-schedule-timer*

Schedule a callback to fire after ms milliseconds. Capability: :async

await

Blocks the calling thread until every named agent's queued actions have finished. Throws MST002 if called from inside an agent action body (would self-deadlock). Capability: :agent

await-for

Like await with a millisecond timeout. Returns true if every named agent reached zero in-flight actions before the deadline, false on timeout. Capability: :agent

bigdec

Coerces a value to an arbitrary-precision decimal. Capability: :bignum

bigint

Coerces a value to an arbitrary-precision integer. Accepts int, bigint, float (truncated toward zero), or a base-10 string. Capability: :bignum

(bigint 1.7)

(bigint -1.7)

(bigint 1)

bigint?

Returns true if x is an arbitrary-precision integer. Capability: :bignum

biginteger

Alias of bigint. Coerces a value to an arbitrary-precision integer. Capability: :bignum

(biginteger 7)

bit-and-not

Returns the bitwise AND of x and the complement of y.

(bit-and-not 7 1)

bit-clear

Returns x with bit n cleared.

(bit-clear 15 1)

(bit-clear 13 1)

(bit-clear 8 3)

bit-flip

Returns x with bit n flipped.

(bit-flip 15 1)

(bit-flip 13 1)

(bit-flip 8 3)

bit-set

Returns x with bit n set.

(bit-set 15 1)

(bit-set 13 1)

(bit-set 0 3)

bit-test

Returns true if bit n of x is set.

bits

Pack a sequence of [value & options] segments into an immutable MINO_BYTES value. Options: :size (bits), :type (:int/:uint/:float/:bytes), :endian (:big/:little), :signed? (true/false). Bit-aligned totals leave a 1..7 bit_tail; the result satisfies bitstring? but not necessarily bytes?.

bits-get

Read a bit field out of a bytes value. Required: :offset and :size. Optional: :type (:int/:uint/:float/:bytes), :endian, :signed?. For :type :bytes returns a MINO_BYTES slice; for :float returns a double; otherwise returns an integer.

(bits-get bs :offset 0 :size 16)

(bits-get bs :offset 0 :size 16 :endian :little)

(bits-get bs :offset 0 :size 8)

bits-let-seg-size

Compute the static bit count of one segment from its option map. Returns :rest when the segment has :type :bytes without :size, otherwise an integer. Throws on a malformed segment.

bitstring?

Returns true if x is any mino bytes value -- byte-aligned or bit-aligned. bytes? is the byte-aligned subset.

boolean

Coerces x to a boolean value.

(boolean 1)

(boolean nil)

(boolean (:splicing? v2))

boolean-array

Creates a host-style boolean array. Fills with false on size; copies elements from a collection.

boolean?

Returns true if x is true or false.

bound-fn*

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.

bound?

Returns true if all of the vars provided as arguments have any bindings — either a root binding or a thread-local binding.

bounded-count

Returns the count of coll, but stops counting at n.

(bounded-count 10 [1 2 3 4 5])

(bounded-count 10 (range))

(bounded-count 10 (take 3 (range)))

butlast

Returns a seq of all but the last item in coll.

(butlast [1 2 3])

(butlast [1])

byte

Coerces x to a byte (8-bit integer). Throws on out-of-range values, NaN, or infinity. Returns the value as a long since mino has only one integer tier.

byte-array

Creates a host-style byte array. Zero-fills on size argument; copies elements from a collection.

(byte-array [1 2 3])

(hash (byte-array [1 2 3]))

(seq (byte-array [65 66 67]))

bytes?

Returns true if x is a byte-aligned mino bytes value (the immutable binary-data type returned by byte-array).

cat

A transducer that concatenates the contents of each input.

chan-buf-add

Direct buffer push: (chan-buf-add ch val). Used by xform rf. Capability: :async

chan-buf-count

Number of buffered values. Capability: :async

chan-buf-full?

True if buffer is full (or unbuffered/promise-set). Capability: :async

chan-close

Close channel: (chan-close ch). Capability: :async

chan-closed?

True if channel is closed. Capability: :async

chan-flush-buf-to-takers

Wake every parked taker with a buffered value handoff. Capability: :async

chan-get-ex-handler

Read installed ex-handler, or nil if none. Capability: :async

chan-get-xform

Read installed transducer rf, or nil if none. Capability: :async

chan-has-pending-putter?

True if any non-committed putter is parked. Capability: :async

chan-has-pending-taker?

True if any non-committed taker is parked. Capability: :async

chan-instance?

True if x is a channel (MINO_CHAN tag). Public chan? lives in clojure.core.async to avoid shadowing on :refer :all. Capability: :async

chan-new

Construct a channel: (chan-new buf-kind buf-cap xform ex-handler). Capability: :async

chan-offer

Non-blocking put: (chan-offer ch val). Returns true/false. Capability: :async

chan-poll

Non-blocking take: (chan-poll ch). Returns value or nil. Capability: :async

chan-put

Async put: (chan-put ch val cb-or-nil). Capability: :async

chan-put-alts

alts-flavoured put: (chan-put-alts ch val cb flag). Capability: :async

chan-set-xform

Install transducer rf: (chan-set-xform ch rf ex-handler). Capability: :async

chan-take

Async take: (chan-take ch cb-or-nil). Capability: :async

chan-take-alts

alts-flavoured take: (chan-take-alts ch cb flag). Capability: :async

char

Coerces x to a character: integer codepoint (0..0x10FFFF) becomes the Unicode scalar value, character is identity. Throws on out-of-range values, non-integer types.

(char 65)

(char 97)

(char 48)

char-array

Creates a host-style char array. Nul-fills on size argument; copies elements from a collection.

char?

Returns true if x is a one-character string.

chunk

Seals chunk-buffer buf so no further appends are accepted, and returns the chunk.

chunk-append

Appends elem to chunk-buffer buf and returns buf. Throws if buf is full or already sealed.

chunk-buffer

Returns a fresh chunk-buffer of the given capacity. Append values with chunk-append, then seal with chunk.

chunk-cons

Returns a chunked seq prepending the given chunk to the seq more.

chunk-first

Returns the chunk at the head of a chunked seq.

chunk-next

Returns the rest of a chunked seq as a seq, or nil if empty.

chunk-rest

Returns the rest of a chunked seq after the head chunk, or () if none.

chunked-seq?

Returns true if x is a chunked seq.

clojure-version

coll-reduce

coll?

Returns true if x is a collection.

commute

Sets ref to (apply f current-value args). Like alter but does not participate in read-set validation -- two transactions commuting on the same ref do not conflict. The fn is replayed against the latest committed value at commit time. Must be in dosync. Capability: :stm

comp

Returns a function that is the composition of the given functions.

(transduce (comp (take 1) (take 1)) conj [:a])

(transduce (comp (take 1) (take 1) (take 1)) conj [:a])

(transduce (comp (take 1) (take 1) (take 1) (take 1)) conj [:a])

comparator

Returns a comparator function from a two-arg predicate.

((comparator <) 1 2)

((comparator <) 2 1)

((comparator <) 1 1)

compare-and-set!

Atomically sets the atom to new-val if its current value equals expected. Returns true on swap, false otherwise.

complement

Returns a function that returns the logical opposite of f.

((complement nil?) 42)

((complement nil?) nil)

completing

Returns a reducing function with a completion step.

conj!

Conjoins val onto a transient vector, map, or set.

constantly

Returns a function that always returns x.

((constantly 42) :a :b)

counted?

Returns true if (count x) is a constant-time operation. Per Clojure this is the Counted protocol -- vectors, maps, sets, and sorted variants. Strings are not Counted on the JVM (their count walks java.lang.CharSequence).

create-multimethod

create-ns

Ensure the namespace exists and return its symbol.

cycle

Returns a lazy infinite sequence of repetitions of the items in coll.

(take 5 (cycle [1 2]))

datafy

(datafy 42)

(datafy "hello")

(datafy [1 2 3])

decimal?

Returns true if x is an arbitrary-precision decimal. Capability: :bignum

dedupe

Returns a lazy sequence removing consecutive duplicates. When called with no collection, returns a transducer.

(into [] (dedupe [1 1 2 3 3 3 4 4 1]))

(transduce (dedupe) conj [] [1 1 2 2 3 1])

defrecord*

Runtime constructor for record types. Takes ns name fields-vector and returns the MINO_TYPE value, idempotent across calls.

defrecord-bind-fields-in-method

Wraps a protocol method body so the record's field names are visible as locals bound to (get this :field). Matches Clojure defrecord's contract: in (defrecord R [a b] IFoo (bar [this] a)), `a` resolves to (:a this) inside the method body. Returns the method form unchanged if it doesn't look like a method spec (`(symbol [vec] body...)`), so protocol-name separators inside specs pass through. Bypasses wrapping when there are no fields. Skips binding for fields whose name shadows the method's first param (i.e. the dispatching `this` slot). Order of bindings inside the let preserves the field declaration order so later fields can reference earlier ones if a user shadows intentionally.

delay?

Returns true if x is a delay.

deliver

Deliver a value to a promise. Returns the promise on success, nil if already realized.

denominator

Returns the denominator of a rational number. Capability: :bignum

(denominator 1/2)

(denominator -3/4)

(denominator 1/3)

deref-delay

Forces evaluation of a delay and returns its value.

derive

Establishes a parent/child relationship between child and parent in a hierarchy.

descendants

Returns all descendants of tag in the hierarchy.

(descendants h :shape)

(descendants h :shape)

(descendants h :rect)

destructure

Takes a binding-pairs vector [lhs1 rhs1 lhs2 rhs2 ...] and returns a flat vector of [name init ...] suitable as a let binding form.

directory?

Returns true if the path is a directory. Capability: :fs

disj!

Removes key from a transient set.

dissoc!

Removes key from a transient map.

distinct

Returns a lazy sequence of the distinct items in coll. When called with no collection, returns a transducer.

(sequence (distinct) [])

(sequence (distinct) (range 10))

(sequence (distinct) (repeat 10 0))

distinct?

Returns true if no two of the arguments are equal.

doall

Forces realization of a lazy sequence. Returns coll.

(count (doall (map inc [1 2 3])))

dorun

Forces realization of a lazy sequence. Returns nil.

dosync*

Runs a zero-arg thunk inside an STM transaction. The `dosync` macro expands to (dosync* (fn [] body...)). Capability: :stm

double

Coerces x to a 64-bit double (returns a MINO_FLOAT). Identity on existing doubles.

(double (/ 10 4))

(double (float 5))

(letfn [(double [x] (* 2 x))]
(double 5))

double-array

Creates a host-style double array. Zero-fills (0.0) on size; copies elements from a collection.

double?

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)`. Matches JVM Clojure where `double?` is `(instance? Double x)`.

drain!

Drain the async run queue once. Capability: :async

drain-loop!

Drain until done-thunk returns truthy or no progress. Capability: :async

drop-last

Returns a lazy sequence of all but the last n items in coll.

(into [] (drop-last [1 2 3 4]))

(into [] (drop-last 2 [1 2 3 4]))

drop-seq

Internal fast path for eager drop.

drop-while

Returns a lazy sequence of items from coll after pred returns falsy. When called with no collection, returns a transducer.

(drop-while (fn [x] (< x 3)) [1 2 3 4])

(transduce (drop-while #(< % 3)) conj [] [1 2 3 4 5])

eduction

Returns a lazy sequence of applying the given transducers to coll.

(eduction (map inc) (range 5))

(eduction (map inc) (filter even?) (map str) (range 5))

(eduction cat [[1 2 3 nil] [4 5 6 nil]])

empty

Returns an empty collection of the same type.

(empty nil)

(empty [])

(empty [1 2])

ensure

Reads ref and prevents any other transaction from changing it before this transaction commits. Must be in dosync. Returns the current in-tx value. Capability: :stm

ensure-reduced

Wraps x in reduced if it is not already reduced.

@(ensure-reduced 42)

error-handler

Returns the agent's current error-handler fn or nil. Capability: :agent

error-mode

Returns the agent's current error mode. Capability: :agent

even?

Returns true if x is an even integer.

(sequence (keep-indexed (fn [i v] (when (even? i) v)))
[:a :b :c :d :e])

(into [] (keep (fn [x] (when (even? x) (* x 10)))
[1 2 3 4 5]))

(into [] (keep-indexed
(fn [i x] (when (even? i) x))
[:a :b :c :d :e]))

every-pred

Returns a function that returns true when all preds are satisfied by all its arguments.

((every-pred even?))

((every-pred even?) 2)

((every-pred even?) 2 4)

ex-cause

Returns the cause attached to the given exception, or nil.

(ex-cause (ex-info "boom" {:cause :down}))

(ex-cause e)

(ex-message (ex-cause e))

ex-data

Extract the data map from an exception. Handles diagnostic maps (from catch), ex-info maps, and plain thrown values.

(try (throw "oops") (catch e (ex-data e)))

(try (throw {:type :err}) (catch e (:type (ex-data e))))

(try (try (throw "inner")
     (catch e (throw e)))
(catch e (ex-data e)))

ex-info

Create an exception map with a message and data map. The 3-arity form additionally attaches a cause; ex-cause walks the chain via metadata so the visible map structure stays the same as the 2-arity form.

(when false (throw (ex-info "boom" {})))

(when-not true (throw (ex-info "boom" {})))

(if-let [a false] (throw (ex-info "boom" {})))

ex-message

Extract the message from an exception. Handles both diagnostic maps and ex-info maps.

(ex-message (ex-info "oops" {}))

(ex-message e)

(ex-message (ex-cause e))

false?

Returns true if x is the value false.

ffirst

Returns the first item of the first item in coll.

(ffirst '((1 2) (3 4)))

file-exists?

Returns true if the path exists (file or directory). Capability: :fs

file-mtime

Returns the file modification time in milliseconds, or nil. Capability: :fs

filterv

Returns a vector of items in coll for which pred returns logical true.

(filterv even? [1 2 3 4 5])

find

Returns the map entry for the key, or nil.

(find {:a 1 :b 2} :a)

(find {:a 1} :z)

(find p :x)

find-best-method

find-keyword

Returns the keyword for the given string. In mino keywords are always interned, so this is equivalent to keyword for string input and nil for other input.

(find-keyword "a")

(find-keyword "ns" "a")

find-ns

Return the namespace symbol if it exists, else nil.

(ns-name (find-ns 'clojure.set))

(:doc (eval (read-string "(do (ns foo \"foobar\") (meta (find-ns 'foo)))")))

find-var

Return the var named by a qualified symbol, or nil.

(find-var (symbol (str (ns-name *ns*)) "fv-x"))

(var-get (find-var (symbol (str (ns-name *ns*)) "interned-x")))

flatten

Returns a lazy sequence of the non-sequential items from a nested structure.

(into [] (flatten [[1 2] [3 [4 5]] 6]))

(into [] (flatten [1 2 3]))

float-array

Creates a host-style float array. Zero-fills (0.0) on size; copies elements from a collection.

float?

Returns true if x is a float.

flush

Flushes pending output on *out* and *err*. No-op for string-atom bindings.

(flush)

fn-arity-with-prepost

fnext

Same as (first (next coll)).

(fnext [1 3 5])

fnil

Returns a function like f, but replaces nil arguments with the given defaults.

((fnil + 0) nil 5)

((fnil + 0) 3 4)

force

Forces evaluation of a delay. If x is not a delay, returns x.

frequencies

Returns a map from distinct items in coll to the number of times they appear.

(frequencies [1 2 1 3 2 1])

future-call

Spawn a worker thread to evaluate the given thunk; return a future.

future-cancel

Cancel a pending future. Returns true if the future was newly cancelled.

future-cancelled?

Return true if the future was cancelled.

future-deref

Block until the future is realized; return result, rethrow exception, or throw :mino/cancelled.

future-done?

Return true if the future has reached a terminal state (resolved/failed/cancelled).

future?

Return true if x is a future or promise.

get-method

Returns the method for dispatch-val, or nil.

get-thread-bindings

Returns a map of symbol->value for the active dynamic bindings, or nil if no binding frames are active.

get-validator

Returns the validator function of an atom, or nil.

(get-validator a)

(get-validator r)

(get-validator r)

global-hierarchy

group-by

Returns a map of the items in coll grouped by the result of f.

(group-by even? [1 2 3 4])

halt-when

Returns a transducer that halts reduction when pred is satisfied.

(transduce (halt-when even?) conj [1 3 5 4 7])

(transduce (halt-when even?
  (fn [r input] {:stopped input :so-far r}))
conj [1 3 5 4 7])

(transduce (halt-when even?) conj [1 3 5])

hash-combine

Boost-style hash combiner: mixes seed and hash into a single 32-bit hash. Matches clojure.core/hash-combine bit-for-bit so user code that manually composes hashes via this helper sees the same result on mino as on JVM Clojure. seed ^= hash + 0x9e3779b9 + (seed << 6) + (seed >> 2) The operation is performed in unchecked 32-bit arithmetic; the result is truncated to the low 32 bits.

(hash-combine 0 (hash :a))

(hash-combine 0 0)

(hash-combine 0 (hash :a))

hash-ordered-coll

Computes a sequence-position-aware hash for an ordered collection.

hash-unordered-coll

Computes a position-independent hash for an unordered collection.

(hash-unordered-coll #{3 2 1})

hierarchy-version

host/call

Calls a method on a host handle. Capability: :host

(host/call c :get)

(host/call c :get)

(host/call c :get)

host/get

Returns the value of a field on a host handle. Capability: :host

(host/get c :value)

(try (host/get c :nope) (catch e e))

host/new

Creates a new instance of a host-registered type. Capability: :host

(try (host/new :Nope) (catch e e))

host/static-call

Calls a static method on a host-registered type. Capability: :host

(host/static-call :Math :add 3 4)

(try (host/static-call :Math :nope) (catch e e))

ident?

Returns true if x is a symbol or keyword.

identical?

Returns true if the arguments are the same object.

ifn?

Returns true if x can be called as a function.

in-ns

Set the current namespace, creating it if necessary.

(eval (read-string "(do (in-ns 'cs-strict-foo) (ns-name *ns*))"))

(eval (read-string "(do (in-ns 'cs-strict-all-dst) (pubA))"))

(eval (read-string "(do (in-ns 'cs-strict-all-dst) (pubB))"))

in-transaction?

Returns true when called from inside a `dosync` body. Capability: :stm

indexed?

Returns true if x supports nth in constant time (vectors).

infinite?

Returns true if x is positive or negative infinity.

inst-ms

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. Throws on a non-inst argument.

(inst-ms #inst "1970-01-01T00:00:00Z")

(inst-ms #inst "2000-01-01T00:00:00Z")

(inst-ms #inst "2026-05-21T00:00:00Z")

inst-ms-count-leaps

inst-ms-days-from-1970

inst-ms-leap?

inst?

instance?

Returns true if x is an instance of t. For record types defined with defrecord, t is the type value and the test is type-pointer identity. For built-in types or ad-hoc :type-tagged values, t may be the keyword (type x) returns and the test is keyword equality.

int-array

Creates a host-style int array. Zero-fills on size argument; copies elements from a collection.

int?

Returns true if x is an integer.

integer?

Returns true if x is an integer (long or bigint).

intern

Intern a value into a namespace by name.

(do (require '[remote :refer [cake]])
(ns-unmap *ns* 'cake)
(def resolved (resolve 'cake))
(intern *ns* 'cake "bar")
[resolved cake])

interpose

Returns a lazy sequence of the items in coll separated by sep. When called with no collection, returns a transducer.

(sequence (interpose :s) (range 0))

(sequence (interpose :s) (range 1))

(sequence (interpose :s) (range 2))

into-array

Converts a collection to an Object array.

io!-check

Internal: throws when called inside a transaction. The io! macro expands to (do (io!-check) body...) so the check runs before the body evaluates. Capability: :stm

isa?

Returns true if child is equal to or derives from parent.

iterate

Returns a lazy sequence of x, (f x), (f (f x)), and so on.

(take 4 (iterate #(if (= % :foo) 42 :foo) :foo))

(take 10 (iterate #(quot % 2) 256))

(first (next (next (iterate inc 0))))

iteration

Creates a seqable via repeated calls to step, a function of some continuation token 'k'. The first call to step is passed initk, returning 'ret'. If (somef ret) is true, (vf ret) is included in the iteration; else iteration terminates and vf/kf are not called. If (kf ret) is non-nil it is passed to the next step call; else iteration terminates. Used to consume APIs that return paginated or batched data. step - (possibly impure) fn of 'k' -> 'ret' :somef - fn of 'ret' -> truthy/falsy, default some? :vf - fn of 'ret' -> 'v', default identity :kf - fn of 'ret' -> 'next-k' or nil, default identity :initk - first value passed to step, default nil Step with non-initk is presumed unreproducible. The first step call is deferred until the result is realized.

java.util.List/of

JVM List.of static; routes to mino's list constructor.

(java.util.List/of 1 2 3)

java.util.Map/of

JVM Map.of static; routes to mino's hash-map constructor.

(java.util.Map/of :a 1 :b 2)

java.util.Set/of

JVM Set.of static; routes to mino's hash-set constructor.

(java.util.Set/of 1 2 3)

java.util.UUID/fromString

Parses a UUID from its canonical string form.

(java.util.UUID/fromString (str u))

java.util.UUID/randomUUID

Generates a random UUID v4.

juxt

Returns a function that returns a vector of applying each f to its args.

((juxt :a :b) {:a 1 :b 2})

((juxt fnext first) a0)

((juxt a1 b1) 3)

keep

Returns a lazy sequence of non-nil results of (f item). When called with no collection, returns a transducer.

(into [] (keep (fn [x] (when (even? x) (* x 10)))
[1 2 3 4 5]))

(transduce (keep #(when (even? %) (* % %))) conj [] [1 2 3 4 5])

keep-indexed

Returns a lazy sequence of non-nil results of (f index item). When called with no collection, returns a transducer.

(sequence (keep-indexed (fn [i v] (when (odd? i) v))) [])

(into [] (keep-indexed (fn [i v] (when (odd? i) v)))
[2 5 3 4 6 7 9 8])

(sequence (keep-indexed (fn [i v] (when (even? i) v)))
[:a :b :c :d :e])

key

Returns the key of a map entry. Throws on values that are not map entries (a literal 2-vector, for instance).

(key (first {:a 1}))

(key (first {nil 1}))

(key (first {:a nil}))

kv-reduce

last

Returns the last item in coll.

(last (byte-array [9 8 7]))

(last [1 2 3])

(last [1])

lazy-filter

Internal fast path for lazy filter.

lazy-map-1

Internal fast path for single-collection lazy map.

lazy-take

Internal fast path for lazy take.

list*

Creates a new list containing the items prepended to the rest, the last of which will be treated as a sequence.

(r/fold + + (list* (range 1000)))

list?

Returns true if x is a list (cons chain or the empty-list singleton). Excludes lazy-seq and chunked-cons; for the broader 'is a sequence' predicate, use seq?.

load-file

Reads and evaluates all forms in the file at the given path. Returns the value of the last form.

load-string

Reads and evaluates all forms in the given source string. Returns the value of the last form.

(load-string "(+ 1 1)")

(load-string "(def __ls_x 42) (* __ls_x 2)")

(load-string "(defn __ls_sq [x] (* x x)) (__ls_sq 5)")

loaded-libs

Return a vector of names that have been required.

long

Coerces x to a long (64-bit integer). Throws on out-of-range values, NaN, or infinity, including bigint and bigdec out of long range.

long-array

Creates a host-style long array. Zero-fills on size argument; copies elements from a collection.

make-hierarchy

Returns an empty hierarchy.

map-entry

Constructs a (k, v) map entry. Distinct from a 2-vector: key/val accept only map entries, not plain vectors. Equality with [k v] still compares element-wise.

map-entry?

Returns true if x is a map entry (mino represents entries as 2-vectors).

map-indexed

Returns a lazy sequence of (f index item) for each item in coll. When called with no collection, returns a transducer.

(sequence (map-indexed vector) [])

(sequence (map-indexed vector) (range 1 5))

(into [] (map-indexed vector [:a :b :c]))

map-n

map1

mapcat

Returns the result of applying concat to the result of mapping f over coll. When called with no collection, returns a transducer.

(mapcat (fn [x] [x (* x 10)]) [1 2 3])

(transduce (mapcat #(list % %)) conj [] [1 2 3])

mapv

Returns a vector of applying f to each item in one or more collections.

(mapv (fn [f] (f)) (mapv outer (range 10)))

(mapv (fn [f] (f)) @cls)

(mapv (fn [f] (f)) fs)

match-whole

matcher?

math-acos

Returns the arc-cosine of n; n in [-1, 1]; result in [0, PI].

math-asin

Returns the arc-sine of n; n in [-1, 1]; result in [-PI/2, PI/2].

math-atan

Returns the arc-tangent of n; result in [-PI/2, PI/2].

math-cbrt

Returns the cube root of n.

math-copy-sign

Returns a value with the magnitude of mag and the sign of sgn.

math-cosh

Returns the hyperbolic cosine of n.

math-expm1

Returns exp(n) - 1, accurate for small n.

math-hypot

Returns sqrt(a^2 + b^2) avoiding intermediate overflow.

math-ieee-remainder

Returns IEEE 754 remainder of a by b.

math-log10

Returns the base-10 logarithm of n.

math-log1p

Returns the natural logarithm of (1 + n), accurate for small n.

math-next-down

Returns the next representable double less than n (toward -Inf).

math-next-up

Returns the next representable double greater than n (toward +Inf).

math-pi

math-signum

Returns -1.0, 0.0, or 1.0 depending on the sign of n (preserves -0.0).

math-sinh

Returns the hyperbolic sine of n.

math-tanh

Returns the hyperbolic tangent of n.

math-to-degrees

Converts the angle n (in radians) to degrees.

math-to-radians

Converts the angle n (in degrees) to radians.

max

Returns the greatest of the given values.

(max 3 7)

(max 1 5 3)

(max -10 -5 -1)

max-key

Returns the x for which (k x) is greatest.

(max-key count "ab" "a" "abc")

(max-key :x {:x 3} {:x 1} {:x 2})

(max-key identity 42)

memoize

Returns a memoized version of f that caches return values by arguments.

merge

Returns a map that is the merge of the maps. If a key occurs in more than one map, the mapping from the latter (left-to-right) will be the mapping in the result. Per Clojure, position-2+ args use `conj` semantics, so MapEntries / 2-element vectors are accepted.

(meta (merge x y))

(meta (merge y x))

(merge {:a 1} {:b 2} {:a 3})

merge-with

Returns the merge of the given maps, calling f to combine values at shared keys.

(meta (merge-with + x y))

(meta (merge-with + y x))

(merge-with + {:a 1 :b 2} {:a 3 :c 4})

meta

Returns the metadata map of the given value, or nil.

(meta (:guh y))

(meta (reduce #(assoc %1 %2 (inc %2)) x (range 1000)))

(meta (-> x (dissoc :foo) (dissoc :bar)))

methods

Returns the method table of multimethod mm.

(count (methods area-mm))

(count (methods mm-test))

(count (methods mm-test))

min

Returns the least of the given values.

(min 3 7)

(min 1 5 3)

(min -10 -5 -1)

min-key

Returns the x for which (k x) is least.

(min-key count "ab" "a" "abc")

(min-key :x {:x 3} {:x 1} {:x 2})

(min-key identity 42)

mino-capability

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.

(mino-capability 'slurp)

(mino-capability 'spit)

(mino-capability 'exit)

mino-installed?

Returns true if a named capability has been installed on this runtime. Argument is a keyword, symbol, or string; supported names include :floor :regex :bignum :multimethods :protocols :transducers :io :fs :proc :stm :agent :host :async. Used by core.clj sections to gate optional surface on the host's install picks.

mino-no-grant-msg

Build the :mino/unsupported message used when host threads are not granted in the current state.

mino-thread-count

Return the live host-thread count for this state.

mino-thread-limit

Return the host-granted thread limit for this state. 1 means single-threaded; >1 means the host has granted that many concurrent worker threads.

mix-collection-hash

Combines a hash-basis with the collection's count.

mkdir-p

Creates a directory and any missing parent directories. Capability: :fs

namespace

Returns the namespace string of a symbol or keyword, or nil.

(namespace 'abc/def)

(namespace 'abc)

(namespace :abc/def)

nat-int?

Returns true if x is a non-negative integer (long tier).

nav

(nav [1 2 3] 0 99)

(nav {:a 1} :a :x)

neg-int?

Returns true if x is a negative integer (long tier).

neg?

Returns true if x is less than zero.

next

Returns a seq of the items after the first. Returns nil if no more items.

(loop [a []
     b [1 2 3]]
(if (seq b)
  (recur (conj a (* 2 (first b)))
         (next b))
  a))

(loop [a ()
     b [1 2 3]]
(if (seq b)
  (recur (conj a (* 2 (first b)))
         (next b))
  a))

(first (next (next (iterate inc 0))))

nfirst

Same as (next (first coll)).

(nfirst [[1 2] [3 4]])

nnext

Same as (next (next coll)).

(nnext [1 2 3])

(nnext [1 2])

not-any?

Returns true if (pred x) is falsy for every x in coll.

(not-any? pos? [1])

(not-any? pos? [1 2])

(not-any? pos? [1 2 3 4 5])

not-empty

Returns coll if it has items, nil otherwise.

(not-empty [1])

(not-empty [])

not-every?

Returns true if (pred x) is falsy for at least one x in coll.

(not-every? pos? [1])

(not-every? pos? [1 2])

(not-every? pos? [1 2 3 4 5])

ns-aliases

Return the alias map of a namespace.

(ns-name (get (ns-aliases *ns*) 'e1))

(ns-name (get (ns-aliases *ns*) 'c))

(ns-name (get (ns-aliases *ns*) 'c2))

ns-interns

Return the interned bindings of a namespace as a map.

ns-map

Return all bindings visible in a namespace as a map.

(eval (read-string "(do (defn inc [x] :foo) ((get (ns-map *ns*) 'inc) 1))"))

ns-name

Return the symbol name of a namespace.

(eval (read-string "(do (in-ns 'cs-strict-foo) (ns-name *ns*))"))

(ns-name *ns*)

(ns-name *ns*)

ns-publics

Return the public bindings of a namespace as a map.

ns-refers

Return the refer'd bindings of a namespace as a map.

ns-resolve

Resolve a symbol to a var in the given namespace.

ns-unalias

Remove an alias from a namespace.

ns-unmap

Remove a binding from a namespace.

(eval (read-string "(do (ns-unmap *ns* 'Object) (def o1 (resolve 'Object)) (import '[java.lang Object]) (def o2 (resolve 'Object)) [(some? o1) (some? o2)])"))

(do (require '[remote :refer [cake]])
(ns-unmap *ns* 'cake)
(def resolved (resolve 'cake))
(intern *ns* 'cake "bar")
[resolved cake])

(eval (read-string "(do (ns-unmap *ns* 'String) `String)"))

nthnext

Returns the result of calling next n times on coll.

(nthnext [1 2 3 4 5] 2)

(nthnext [1 2] 3)

nthrest

Returns the result of calling rest n times on coll.

(into [] (nthrest [1 2 3 4 5] 2))

(into [] (nthrest [1 2] 0))

num

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.

numerator

Returns the numerator of a rational number. Capability: :bignum

(numerator 1/2)

(numerator -3/4)

(numerator 1/3)

object-array

Creates a host-style Object array. With a non-negative integer, returns an array of that length filled with nil. With a collection, returns an array of its elements. Distinct from vector: vector? / coll? / counted? / sequential? / associative? all return false on the result, matching JVM Java arrays.

odd?

Returns true if x is an odd integer.

(sequence (keep-indexed (fn [i v] (when (odd? i) v))) [])

(into [] (keep-indexed (fn [i v] (when (odd? i) v)))
[2 5 3 4 6 7 9 8])

(into [] (for [x [1 2 3] :when (odd? x) y [2 4]] [x y]))

parents

Returns the immediate parents of tag in the hierarchy.

(parents h :square)

(parents h :square)

(parents h :d)

parse-boolean

Parses 'true' or 'false' (case-sensitive) and returns the boolean. Returns nil for strings that don't match. Per Clojure's contract raises an error on non-string input (analogous to JVM's ClassCastException / NullPointerException).

parse-double

Parses a string into a double, or returns nil on failure.

parse-long

Parses a string into a long integer, or returns nil on failure.

parse-uuid

Parses s as a UUID; returns a UUID value or nil if s is not a valid canonical UUID string.

(parse-uuid "550e8400-e29b-41d4-a716-446655440000")

partial

Returns a function that applies f with the given arguments prepended.

((partial + 10) 5)

partition-all

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.

(into [] (partition-all 3 [1 2 3 4 5 6 7 8]))

(partition-all 2 [1 2 3])

(transduce (partition-all 2) conj [] [1 2 3 4 5])

partition-by

Splits coll into lazy sequences of consecutive items with the same (f item) value. When called with no collection, returns a transducer.

(transduce (comp (partition-by keyword?) (take 1)) conj [] [:a])

(sequence (comp (partition-by keyword?) (take 1)) [:a])

(transduce (partition-by odd?) conj [] [1 3 2 4 5])

partition-protocol-specs

partitionv

Like partition but returns a lazy seq of vectors instead of lists.

(vec (partitionv 2 [1 2 3 4]))

(vec (partitionv 2 1 [1 2 3 4]))

(vec (partitionv 2 2 [:p :p] [1 2 3 4 5]))

partitionv-all

Like partition-all but returns a lazy seq of vectors instead of lists.

(vec (partitionv-all 2 [1 2 3 4 5]))

pcalls

Executes the no-arg fns in parallel, returning a lazy sequence of their values. Mirrors clojure.core/pcalls. When host threads aren't granted (mino-thread-limit <= 1), falls back to sequential map so the surface is portable across embedded and CLI runs.

(pcalls (fn [] 1) (fn [] 2) (fn [] 3))

(pcalls)

peek

Returns the first item of a list or last item of a vector.

(peek q)

(peek q)

(peek (pop q))

persistent!

Seals a transient and returns its persistent collection.

(persistent! t)

(persistent! @a)

(persistent! t)

pmap

Like map, except f is applied in parallel via futures. Semi-lazy in that the parallel computation stays no more than thread-limit-1 items ahead of the consumer. f's invocations across the collection are independent; do not pmap with a side-effectful f if order of effects matters. Single-arity collection only: (pmap f coll). When host threads are not granted (mino-thread-limit <= 1), falls back to (map f coll) so callers don't need a conditional.

pop

Returns a collection without the peek item.

(meta (pop (pop (pop x))))

(pop sv)

(seq (pop q))

pop!

Removes the last element from a transient vector.

pop-thread-bindings

Pop the topmost dynamic-binding frame. Throws when no frame is active. Pair with push-thread-bindings.

pop-thread-bindings*

(pop-thread-bindings*) — pop and free the top dynamic-binding frame. Throws when no frame is active.

pos-int?

Returns true if x is a positive integer (long tier).

pos?

Returns true if x is greater than zero.

postwalk

Walks form depth-first, applying f to each sub-form after its children.

(postwalk (fn [x] (if (number? x) (inc x) x)) '(1 (2 3)))

postwalk-replace

Replaces items in form that appear as keys in smap, walking bottom-up.

(postwalk-replace {:a 1 :b 2} [:a [:b :c]])

pr-builtin

Prints a value readably via the built-in C formatter, bypassing print-method.

(with-out-str (pr-builtin {:a 1}))

prefer-method

Prefers dispatch-val x over y in multimethod mm.

prefers

Returns the prefer-table of multimethod mm.

(prefers pf-mm)

prefers?

prewalk

Walks form depth-first, applying f to each sub-form before its children.

prewalk-replace

Replaces items in form that appear as keys in smap, walking top-down.

(prewalk-replace {:a 1 :b 2} [:a [:b :c]])

prim-into

prim-re-find

prim-re-matches

print-method

print-str

Returns the print-string of args, space-separated, no trailing newline.

(print-str 1 2 3)

printf

Formats and prints to *out*: equivalent to (print (apply format fmt args)).

(with-out-str (printf "x=%d y=%s" 42 "ok"))

println-str

Returns the print-string of args followed by a newline.

(println-str "a" "b")

prn-str

Returns the readable-string of args followed by a newline.

(prn-str [1 2 3])

(prn-str "hi")

promise

Return a fresh promise that can be deliver'd a value once.

protocol-dispatch

push-thread-bindings

Push a fresh dynamic-binding frame whose entries come from the map. Symbols-or-strings are accepted as keys. Must be paired with pop-thread-bindings in a try/finally.

push-thread-bindings*

(push-thread-bindings* bindings-map) — push a fresh dynamic-binding frame. Must be paired with pop-thread-bindings* in a try/finally.

qualified-ident?

Returns true if x is a namespace-qualified symbol or keyword.

qualified-keyword?

Returns true if x is a namespace-qualified keyword.

qualified-symbol?

Returns true if x is a namespace-qualified symbol.

queue?

Returns true if x is a PersistentQueue.

rand-int

Returns a random integer between 0 (inclusive) and n (exclusive).

rand-nth

Returns a random element from coll.

random-sample

Returns items from coll with probability prob. When called with no collection, returns a transducer.

(random-sample 0 [1 2 3 4 5])

(random-sample 1 [1 2 3 4 5])

(into [] (random-sample 0) [1 2 3 4 5])

random-seed!

Seeds the per-state PRNG to a known integer value so subsequent rand calls produce a reproducible stream. Returns the seed.

random-uuid

Returns a random UUID v4 string.

(subs (str (random-uuid)) 14 15)

rangev

Returns a vector of integers from start (inclusive) to end (exclusive).

ratio?

Returns true if x is a ratio. Capability: :bignum

rational?

Returns true if x is a rational number (int, bigint, or ratio). Capability: :bignum

rationalize

Returns the rational value nearest to the argument. Capability: :bignum

(rationalize -0.5)

(rationalize 0.5)

(rationalize 0.25)

re-find-on-matcher

re-groups

Returns the most recent match groups for matcher m: a vector [whole g1 g2 ...] when the pattern has groups, the whole-match string otherwise. Throws when the matcher has no recorded match yet.

(re-groups m)

(re-groups m)

re-matcher

Returns a matcher value for repeated find/match operations on text using pattern. The resulting value is consumed by re-find, re-groups and so on.

re-pattern

Returns a regex from a string pattern (no-op on an existing regex). Capability: :regex

(type (re-pattern "\\d+"))

(re-find (re-pattern "abc") "xabcy")

(re-pattern r)

re-seq

Returns a lazy sequence of all matches of pattern in string s. Each match is a string when the pattern has no groups, or a vector [whole g1 g2 ...] when it does.

(into [] (re-seq "\\d+" "abc123def456ghi"))

(into [] (re-seq "[a-z]" "a1b2c3"))

(count (re-seq #"\d+" "1 2 33 444"))

read

(read "(+ 1 2)")

(read "42")

(read "#?(:mino 3 :clj 1 :cljs 2)")

read*

Reads one form from *in*. Atom-bound *in* consumes from the head; stdin-backed *in* is unsupported. The user-facing `read` in core.clj dispatches on arity.

read-line

Reads one line from *in*. Returns the line without trailing newline, or nil at EOF.

(with-in-str "hello\nworld" (read-line))

(with-in-str "a\nb\nc"
[(read-line) (read-line) (read-line) (read-line)])

(with-in-str "no-newline" (read-line))

reader-conditional

Builds a reader-conditional record with form and splicing? fields. Predicate reader-conditional? returns true on the result.

reader-conditional?

Returns true if x is a reader-conditional record produced by reader-conditional.

realized?

Returns true if a delay, lazy sequence, future, or promise has been realized.

recompute-hierarchy

record*

Runtime constructor for record values. Takes a record type and a vector of declared field values. Used by the ->Type macro expansion.

record-fields

Returns the declared field-name vector for a record type.

record-from-map

Builds a record by reading declared fields from a map; non-field keys land in ext. Used by the map->Type macro expansion.

record-type?

Returns true if x is a record type (the value defrecord defines).

record?

Returns true if x is a record value.

reduce-kv

Reduces a map (or any associative source) with f taking accumulator, key, and value. Consults IKVReduce; falls back to walking the seq.

(reduce-kv (fn [acc k v] (assoc acc k (* v 2)))
{} {:a 1 :b 2})

(reduce-kv (fn [a k v] (assoc a k v)) {} {:a 1 :b 2})

reduced

Wraps a value to signal early termination of reduce.

(reduce (fn [acc x] (if (> x 3) (reduced acc) (+ acc x))) 0 (range 10))

(reduce (fn [acc x] (reduced acc)) 0 [1 2 3])

(reduce (fn [a x] (if (>= x 10) (reduced a) (+ a x)))
0 v)

reduced?

Returns true if x is a reduced value.

reductions

Returns a lazy sequence of the intermediate values of a reduction.

(into [] (reductions + [1 2 3 4 5]))

(into [] (reductions + 100 [1 2 3]))

ref

Creates an STM ref holding the given initial value. Mutate via ref-set / alter / commute inside dosync. Capability: :stm

(type (ref 1))

ref-history-count

Returns the ref's current history-count. mino uses single-version optimistic locking; this stub always returns 0. Capability: :stm

(ref-history-count r)

ref-max-history

Returns the ref's max-history. mino uses single-version optimistic locking; this stub always returns 10. Capability: :stm

(ref-max-history r)

ref-min-history

Returns the ref's min-history. mino uses single-version optimistic locking; this stub always returns 0. Capability: :stm

(ref-min-history r)

ref-set

Sets the value of ref. Must be in dosync. Returns the new value. Capability: :stm

ref?

Returns true if x is an STM ref. Capability: :stm

refer

Bring all publics of a namespace into the current namespace.

regex?

Returns true if x is a regex value.

register-method

release-pending-sends

Returns the count of sends queued by the current transaction and clears them so they will NOT fire on commit. Outside a transaction returns 0. Capability: :agent

remove

Returns a lazy sequence of items in coll for which pred returns falsy. When called with no collection, returns a transducer.

(into [] (remove even? [1 2 3 4 5]))

(transduce (remove even?) + 0 [1 2 3 4 5])

remove-all-methods

Removes all methods from multimethod mm.

remove-method

Removes the method for dispatch-val from multimethod mm.

remove-ns

Remove a namespace from the runtime.

remove-tap

Unregisters f from the tap registry. Returns nil.

remove-watch

Removes a watch function from an atom by key.

(remove-watch a :w)

(remove-watch a :nonexistent)

repeatedly

Returns a lazy sequence of calls to f. With two args, returns n calls.

(take 3 (repeatedly (fn [] 42)))

replace

Returns a collection with items in coll replaced by entries in smap.

(meta (replace {2 "two"} x))

(replace {2 "two"} x)

(into [] (replace {:a 1 :b 2} [:a :c :b]))

replicate

Returns a lazy seq of n copies of x. Deprecated alias for (take n (repeat x)).

(vec (replicate 3 :x))

(vec (replicate 0 :x))

requiring-resolve

Require the namespace if needed, then resolve a qualified symbol.

(deref (requiring-resolve 'foo.bar/x))

reset-meta!

Atomically resets the metadata for a reference type to meta-map. Returns meta-map.

reset-vals!

Sets the value of an atom and returns [old new].

(reset-vals! a 42)

(reset-vals! a 10)

resolve

Returns the var to which a symbol resolves, or nil.

(eval (read-string "(do (ns-unmap *ns* 'Object) (def o1 (resolve 'Object)) (import '[java.lang Object]) (def o2 (resolve 'Object)) [(some? o1) (some? o2)])"))

(do (require '[remote :refer [cake]])
(ns-unmap *ns* 'cake)
(def resolved (resolve 'cake))
(intern *ns* 'cake "bar")
[resolved cake])

restart-agent

Clears the agent's error and resets its state to the given value. Trailing :clear-actions true also drops every queued action targeting this agent. Capability: :agent

reversible?

Returns true if x supports rseq (vectors and sorted collections).

rm-rf

Recursively removes a file or directory. Capability: :fs

rseq

Returns a reverse sequence of a vector, or nil if empty.

rsubseq

Returns the entries of a sorted collection whose keys fall in the given range, descending.

(rsubseq m >= 3)

(rsubseq m >= 3 < 7)

(rsubseq s > 1 < 5)

run!

Applies f to each item in coll for side effects. Returns nil.

satisfies?

Returns true if x's type has implementations for all methods of proto.

second

Returns the second item in coll.

(second [1 2 3])

(second v)

(second e)

select-keys

Returns a map containing only the entries whose keys are in ks.

(meta (select-keys x [:bar]))

(select-keys {:a 1 :b 2 :c 3} [:a :c])

send

Dispatches an action onto the agent's POOLED run-queue and returns the agent immediately. The action runs on the POOLED worker under state_lock. Throws MTH001 if the host has not granted a thread budget for the worker. Capability: :agent

send-off

Dispatches an action onto the agent's SOLO run-queue. mino's per-state eval lock means actions across the two pools still serialize, but the queues are independent: a long-running send-off action does not stall pending sends, and vice versa. Throws MTH001 if the host has not granted a thread budget. Capability: :agent

send-via

JVM-canon dispatches the action through a host-supplied Executor. mino has no public Executor type yet; this prim throws MST008 rather than aliasing to send and dropping the executor argument. Use send / send-off. Capability: :agent

seq

Returns a seq on the collection, or nil if empty.

(seq (byte-array [65 66 67]))

(seq (byte-array [-1 0 -128]))

(loop [a []
     b [1 2 3]]
(if (seq b)
  (recur (conj a (* 2 (first b)))
         (next b))
  a))

seq-to-map-for-destructuring

Builds a map from a sequence of keyword/value pairs, possibly with a trailing override map. Used by JVM Clojure's 1.11+ map-destructure over a varargs seq. Public so portable code can call it directly.

(seq-to-map-for-destructuring [])

(seq-to-map-for-destructuring nil)

(seq-to-map-for-destructuring [:a 1 :b 2])

seqable?

Returns true if (seq x) is supported.

sequence

Coerces coll to a (possibly empty) sequence, if it is not already one. Will not force a lazy seq. (sequence nil) yields (). With a transducer xf, returns a lazy sequence of applying xf to coll, or to the pair-wise step of multiple collections. Parallel collections stop at the shortest.

(sequence (map inc) (range 10))

(sequence (map-indexed vector) [])

(sequence (map-indexed vector) (range 1 5))

sequential?

Returns true if x is a sequential collection (list, vector, or lazy-seq).

set

Returns a set of the items in coll.

(set (keys entries))

(set (vals entries))

(set [1 2 3])

set-dyn-binding!

(set-dyn-binding! 'name value) — mutate the topmost active dynamic binding for `name`. Returns the value. Throws when no binding frame is active for `name`. Backs (set! *var* expr).

set-error-handler!

Sets the agent's error-handler fn (called with [agent ex] when an action throws). Capability: :agent

set-error-mode!

Sets the agent's error mode (:fail or :continue). Capability: :agent

set-fail-alloc-at!

Make the n-th GC allocation fail (simulated OOM). Pass 0 to disable.

set-print-method!

Installs a fn to dispatch pr / prn output; nil removes the hook.

set-validator!

Sets a validator function on an atom.

sh

Runs an external command. Returns {:exit n :out "..."}. Capability: :proc

sh!

Runs an external command. Returns stdout; throws on non-zero exit. Capability: :proc

(sh! "echo" "hello")

short

Coerces x to a short (16-bit integer). Throws on out-of-range values, NaN, or infinity. Returns the value as a long since mino has only one integer tier.

short-array

Creates a host-style short array. Zero-fills on size argument; copies elements from a collection.

shuffle

Returns a randomly shuffled vector of the items in coll.

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. Idempotent. Throws MST002 if called from inside an action body (self-join). Capability: :agent

simple-ident?

Returns true if x is a non-namespace-qualified symbol or keyword.

simple-keyword?

Returns true if x is a keyword with no namespace.

simple-symbol?

Returns true if x is a symbol with no namespace.

some-fn

Returns a function that returns the first truthy value from any pred applied to any argument.

some?

Returns true if x is not nil.

(eval (read-string "(do (ns-unmap *ns* 'Object) (def o1 (resolve 'Object)) (import '[java.lang Object]) (def o2 (resolve 'Object)) [(some? o1) (some? o2)])"))

sort-by

Returns a sorted sequence of the items in coll, ordered by (keyfn item).

(sort-by count ["ccc" "a" "bb"])

(sort-by count > ["a" "bb" "ccc"])

sorted-map

Returns a new sorted map with the given key-value pairs.

(get m (sorted-map :a 1))

(hash (sorted-map))

(pr-str (sorted-map :a/x 1 :a/y 2))

sorted-map-by

Returns a sorted map using the given comparator function.

sorted-set

Returns a new sorted set containing the arguments.

(get m (sorted-set :a :b))

(hash (sorted-set))

(count (sorted-set 3 1 2))

sorted-set-by

Returns a sorted set using the given comparator function.

sorted?

Returns true if x is a sorted collection.

special-symbol?

Returns true if x is a symbol that names a special form.

special-symbols-set

split-at

Returns a vector of [(take n coll) (drop n coll)].

(split-at 2 [1 2 3 4 5])

split-with

Returns a vector of [(take-while pred coll) (drop-while pred coll)].

(split-with odd? [1 3 4 2 5])

splitv-at

Returns a vector [(vec (take n coll)) (vec (drop n coll))].

(splitv-at 2 [1 2 3 4])

(splitv-at 5 [1 2 3])

(splitv-at 0 [1 2 3])

subbits

Zero-copy-semantics slice of a bytes value over a half-open bit range [start..end). Result satisfies bitstring? and is byte-aligned when (- end start) is a multiple of 8.

subseq

Returns the entries of a sorted collection whose keys fall in the given range, ascending.

(subseq m >= 3)

(subseq m > 3)

(subseq m <= 2)

substring-index

subvec

Returns a subvector from start (inclusive) to end (exclusive).

(subvec [1 2 3 4] 1 3)

(subvec [1 2 3 4] 2)

(subvec [1 2 3] 1 1)

swap-vals!

Atomically applies f to the atom and returns [old new].

(swap-vals! a inc)

(swap-vals! a + 5)

(swap-vals! a inc)

tagged-literal

Builds a tagged-literal record with tag and form fields. Predicate tagged-literal? returns true on the result.

tagged-literal?

Returns true if x is a tagged-literal record produced by tagged-literal.

take-last

Returns a seq of the last n items in coll.

(take-last 2 [1 2 3 4 5])

(take-last 5 [1 2 3])

take-nth

Returns a lazy sequence of every nth item in coll. When called with no collection, returns a transducer.

take-while

Returns a lazy sequence of items from coll while pred returns truthy. When called with no collection, returns a transducer.

(take-while (fn [x] (< x 3)) [1 2 3 4])

(transduce (take-while #(< % 4)) conj [] [1 2 3 4 5])

tap-fns

tap>

Sends x to every registered tap. Tap fns that throw are silently skipped so a misbehaving subscriber does not poison the stream. Returns true.

tc-ancestors

the-ns

Return the namespace symbol or throw if not found.

(ns-name (the-ns (the-ns 'clojure.set)))

(eval (read-string "(do (ns ^{:a 1} foo {:b 1}) (meta *ns*) (ns bar) (meta (the-ns 'foo)))"))

thread-bound?

Returns true if all of the vars provided as arguments have thread-local bindings active on the current dyn-stack.

thread-sleep

Blocks the current thread for the given number of milliseconds. Returns nil. Capability: :proc

to-array

Converts a collection to an Object array (host-style).

trampoline

Calls f with args, then repeatedly calls the result if it is a function.

(trampoline my-bounce 1000)

transduce

Reduces coll using the transducer xf applied to the reducing function f.

(transduce (take 1) conj [:a])

(transduce (comp (take 1) (take 1)) conj [:a])

(transduce (comp (take 1) (take 1) (take 1)) conj [:a])

transient

Returns a transient view of coll for batch mutation.

transient?

Returns true if x is a transient.

tree-seq

Returns a lazy depth-first sequence of nodes in a tree.

(into [] (tree-seq vector? seq [1 [2 [3]]]))

true?

Returns true if x is the value true.

type-marker-key

Translates an extend-protocol type marker to the dispatch key extend-type understands. Keywords pass through (used for built-in types and ad-hoc tags via :type metadata). Symbols pass through too: at runtime they evaluate to a MINO_TYPE value so (extend-protocol P Point ...) places its impls under that type's pointer in the dispatch atom. Nil maps to :nil so a (extend-protocol P nil ...) clause registers against (type nil).

unchecked-add

Returns x + y as a long with two's-complement wraparound. Operands must be ints. Opt-in fast path for code that knows overflow can't occur or wants wraparound semantics.

(unchecked-add max-int 1)

(unchecked-add 9223372036854775807 1)

(unchecked-add 1 2)

unchecked-add-int

Returns x + y with 32-bit two's-complement wraparound.

(unchecked-add-int 1 1)

(unchecked-add-int 2147483647 1)

unchecked-byte

Coerce x to an 8-bit signed byte (stored in a long with sign extension).

(unchecked-byte 255)

(unchecked-byte 128)

(unchecked-byte 256)

unchecked-char

Coerce x to a Unicode char by truncating to 16 bits (matching JVM char).

(unchecked-char 65)

(unchecked-char 48)

unchecked-dec

Returns x - 1 as a long with two's-complement wraparound. Argument must be an int.

(unchecked-dec min-int)

(unchecked-dec -9223372036854775808)

(unchecked-dec 5)

unchecked-dec-int

Returns x - 1 with 32-bit two's-complement wraparound.

(unchecked-dec-int 0)

(unchecked-dec-int -2147483648)

unchecked-divide-int

Returns the truncating integer division of x by y. Both must be ints. Aliased to quot — the truncating semantic matches canon's unchecked-divide-int (no overflow check; on the JVM this is the primitive idiv instruction).

unchecked-double

Coerce x to a 64-bit double.

(unchecked-double 1)

(unchecked-double 1.0)

unchecked-float

Coerce x to a 32-bit float.

unchecked-inc

Returns x + 1 as a long with two's-complement wraparound. Argument must be an int.

(unchecked-inc max-int)

(unchecked-inc 9223372036854775807)

(unchecked-inc 5)

unchecked-inc-int

Returns x + 1 with 32-bit two's-complement wraparound.

(unchecked-inc-int 0)

(unchecked-inc-int 2147483647)

unchecked-int

Coerce x to a 32-bit signed int (stored in a long with sign extension). Truncates toward zero; 32-bit wraparound.

(unchecked-int 1)

(unchecked-int -1)

(unchecked-int 2147483648)

unchecked-long

Coerce x to a 64-bit long by truncating toward zero. No overflow check; out-of-range doubles clamp to long-long range.

(unchecked-long 1)

(unchecked-long -1)

(unchecked-long 1.1)

unchecked-multiply

Returns x * y as a long with two's-complement wraparound. Operands must be ints.

(unchecked-multiply 2 4611686018427387904)

(unchecked-multiply 2 4611686018427387904)

(unchecked-multiply 2 3)

unchecked-multiply-int

Returns x * y with 32-bit two's-complement wraparound.

(unchecked-multiply-int 2 3)

unchecked-negate

Returns -x as a long with two's-complement wraparound. Argument must be an int.

(unchecked-negate -9223372036854775808)

(unchecked-negate 5)

unchecked-negate-int

Returns -x with 32-bit two's-complement wraparound.

(unchecked-negate-int 5)

(unchecked-negate-int -2147483647)

unchecked-remainder-int

Returns the 32-bit signed remainder of x divided by y. Matches JVM int `%`; throws on division by zero; INT_MIN % -1 = 0.

(unchecked-remainder-int 10 3)

(unchecked-remainder-int -2147483648 -1)

unchecked-short

Coerce x to a 16-bit signed short (stored in a long with sign extension).

(unchecked-short 65535)

(unchecked-short 32768)

(unchecked-short 1)

unchecked-subtract

Returns x - y as a long with two's-complement wraparound. Operands must be ints.

(unchecked-subtract min-int 1)

(unchecked-subtract -9223372036854775808 1)

(unchecked-subtract 5 3)

unchecked-subtract-int

Returns x - y with 32-bit two's-complement wraparound.

(unchecked-subtract-int 1 1)

(unchecked-subtract-int -2147483648 1)

underive

Removes a parent/child relationship between child and parent.

(underive h :a :c)

unreduced

Unwraps a reduced value. If not reduced, returns x.

unsigned-bit-shift-right

Returns n logically shifted right by count bits.

(unsigned-bit-shift-right -1 1)

(unsigned-bit-shift-right -1 63)

update-in

Updates a value in a nested associative structure by applying f at the given key path.

(update-in {:a {:b 1}} [:a] update :b inc)

(update-in {:a {:b 1}} [:a :b] inc)

update-keys

Returns a map with f applied to each key.

(update-keys {:a 1 :b 2} name)

(update-keys {1 :a 2 :b} (fn [k] (* k 2)))

(update-keys {} inc)

update-vals

Returns a map with f applied to each value.

(update-vals {:a 1 :b 2 :c 3} (fn [v] (* v 2)))

(update-vals {:a 1 :b 2 :c 3} inc)

(update-vals {} inc)

uri?

use

Loads a module and refers all of its public names by default.

(eval (read-string "(do (ns ut-a2) (use 'clojure.set) (union #{1} #{2}))"))

(eval (read-string "(do (ns ut-a3) (use '[clojure.set :only [union]]) (union #{1} #{2}))"))

uuid-hex-pattern

uuid-string?

Validates RFC 4122 textual layout: 36 chars with dashes at the 8/13/18/23 positions and hex digits everywhere else. Avoids the {n} quantifier mino's regex engine does not support.

uuid?

Returns true if x is a UUID value.

val

Returns the value of a map entry. Throws on values that are not map entries (a literal 2-vector, for instance).

(val (first {:a 1}))

(val (first {nil 1}))

(val (first {:a nil}))

valid-hierarchy?

valid-tag?

var-get

Return the root value of a var.

(var-get #'vg-x)

(var-get (var vg-x))

(var-get (find-var (symbol (str (ns-name *ns*)) "interned-x")))

var-set

Set the root value of a var.

var?

Returns true if x is a var.

vary-meta

Returns a copy of the value with (apply f meta args) as its metadata.

(catches-throw?
#(vary-meta (var with-meta-var-target) assoc :doc "y"))

vec

Converts coll into a vector. Coll must be nil, a sequential collection, a string, a map, a set, or a host array. Booleans, numbers, keywords, characters, regexes, and transients throw (matching JVM Clojure's `vec` rejecting non-seqable scalars).

(apply (fn [a b & rest] (vec (cons a (cons b rest)))) [1 2 3 4 5])

((fn [[a & rest]] [a (vec rest)]) [1 2 3])

(vec results)

volatile!

Creates a volatile cell with the given initial value. A volatile is a single-slot mutable reference with no watches, validators, or atomic publish — intended for transducer state where the reducing fn already implies single-thread access.

volatile?

Returns true if x is a volatile.

vreset!

Sets the value of a volatile to newval and returns newval. No watches, no validators, no atomicity.

vswap!

Applies f to the current value of the volatile and any args, sets the result, and returns it. No retry loop — single-thread only.

walk

Traverses form, applying inner to each element and outer to the result.

with-bindings*

(with-bindings* bindings-map fn) — pushes the bindings as a dynamic frame and invokes fn with no args.

(with-bindings* snap (fn [] *bt-dyn-y*))

with-meta

Returns a copy of the value with the given metadata map.

(meta (empty (with-meta [1 2] {:a 1})))

(meta (empty (with-meta {:x 1} {:b 2})))

(meta (empty (with-meta #{1 2} {:c 3})))

with-redefs-fn

Temporarily rebinds the root values of vars to new-values while thunk runs, restoring originals afterward. bindings-map is a map of var -> new-value.

zero?

Returns true if x is zero.

(letfn [(my-even? [n] (if (zero? n) :even (my-odd?  (dec n))))
      (my-odd?  [n] (if (zero? n) :odd  (my-even? (dec n))))]
(my-even? 7))

(letfn [(my-even? [n] (if (zero? n) :even (my-odd?  (dec n))))
      (my-odd?  [n] (if (zero? n) :odd  (my-even? (dec n))))]
(my-even? 6))

zipmap

Returns a map with keys mapped to corresponding vals.

(zipmap [:a :b] [1 2])

(zipmap [:a] [1 2])

(zipmap [:a :b] [1])

quote

(str (quote Foo.))

quasiquote

unquote

unquote-splicing

def

(eval (read-string "(do (ns foo) (def x 1) (ns bar) (def x 2) (in-ns 'baz) (def x 3) (require 'foo 'bar) [foo/x bar/x x])"))

(eval (read-string "(do (ns foo) (def x 1) (ns bar) (def x 2) (in-ns 'baz) (def x 3) (require (symbol \"foo\") (symbol \"bar\")) [foo/x bar/x x])"))

(eval (read-string "(do (in-ns 'bar) (def just-one-ns :bar/foo) (in-ns 'bar) just-one-ns)"))

defmacro

if

(loop [a 1]
(if (< a 3)
  (recur (inc a))
  a))

(loop [a []
     b [1 2 3]]
(if (seq b)
  (recur (conj a (* 2 (first b)))
         (next b))
  a))

(loop [a ()
     b [1 2 3]]
(if (seq b)
  (recur (conj a (* 2 (first b)))
         (next b))
  a))

do

(do 1 2 3)

(eval (read-string
"(do (ns cs-strict-only.a (:refer-clojure :only [+ -])) (+ 1 2))"))

(eval (read-string "(do (in-ns 'cs-strict-foo) (ns-name *ns*))"))

let

(let [x 5] x)

(let [x 1 y 2] (+ x y))

(let [x 1 y (+ x 10)] y)

fn

((fn [n] (+ n 0)) tag-max)

((fn [n] (+ n 1)) tag-max)

((fn [n] (dec n)) tag-max)

loop

(loop [] 1)

(loop [a 1]
(if (< a 3)
  (recur (inc a))
  a))

(loop [a []
     b [1 2 3]]
(if (seq b)
  (recur (conj a (* 2 (first b)))
         (next b))
  a))

recur

(loop [a 1]
(if (< a 3)
  (recur (inc a))
  a))

(loop [a []
     b [1 2 3]]
(if (seq b)
  (recur (conj a (* 2 (first b)))
         (next b))
  a))

(loop [a ()
     b [1 2 3]]
(if (seq b)
  (recur (conj a (* 2 (first b)))
         (next b))
  a))

try

(try 42)

(try (+ 1 2))

(try (throw "oops") (catch e (ex-data e)))

whenmacro

Evaluates body when test is truthy. Returns nil otherwise.

(defmacro when
  "Evaluates body when test is truthy. Returns nil otherwise."
  [c & body]
  `(if ~c (do ~@body)))

(when true 1)

(when true)

(when false)

condmacro

Takes pairs of test/expr. Returns the expr for the first truthy test.

(defmacro cond
  "Takes pairs of test/expr. Returns the expr for the first truthy test."
  [& clauses]
  (if (< (count clauses) 2)
    nil
    `(if ~(first clauses)
         ~(first (rest clauses))
         (cond ~@(rest (rest clauses))))))

(cond)

(cond nil true)

(cond false true)

andmacro

Returns the first falsy value, or the last value if all are truthy.

(defmacro and
  "Returns the first falsy value, or the last value if all are truthy."
  [& xs]
  (if (= 0 (count xs))
    true
    (if (= 1 (count xs))
      (first xs)
      (let [g (gensym)]
        `(let [~g ~(first xs)]
           (if ~g (and ~@(rest xs)) ~g))))))

(and)

(and true)

(and nil)

ormacro

Returns the first truthy value, or the last value if none are truthy.

(defmacro or
  "Returns the first truthy value, or the last value if none are truthy."
  [& xs]
  (if (= 0 (count xs))
    nil
    (if (= 1 (count xs))
      (first xs)
      (let [g (gensym)]
        `(let [~g ~(first xs)]
           (if ~g ~g (or ~@(rest xs))))))))

(or)

(or true)

(or nil)

->macro

Thread-first. Inserts x as the second item in the first form, then inserts the result as the second item in the next form, and so on.

(defmacro ->
  "Thread-first. Inserts x as the second item in the first form, then
  inserts the result as the second item in the next form, and so on."
  [x & forms]
  (if (= 0 (count forms))
    x
    (let [step (first forms)]
      (if (cons? step)
        `(-> (~(first step) ~x ~@(rest step)) ~@(rest forms))
        `(-> (~step ~x) ~@(rest forms))))))

(meta (-> x (dissoc :foo) (dissoc :bar)))