Standard Library

nil? src

Exported functions: - Higher-order: map, filter, fold, reduce, keep - Combinators: identity, complement, constantly, compose, comp, partial, juxt - Predicates: all?, any?, some, none? - Search: find, find-index, index-of, last-index-of - Transformation: flatten, group-by, partition, take-while, drop-while - Struct operations: merge - Stream sinks: stream/for-each, stream/fold, stream/collect, stream/into-array - Stream transforms: stream/map, stream/filter, stream/take, stream/drop, stream/concat, stream/zip, stream/pipe - Stream ports: port/lines, port/chunks, port/writer - Subprocess convenience: subprocess/system

integer? src

float? src

boolean? src

keyword? src

native-fn? src

closure? src

fiber? src

box? src

parameter? src

number? src

string? src

bytes? src

array? src

struct? src

set? src

fn? src

mutable? src

immutable? src

pair? src

list? src

symbol? src

even? src

odd? src

abs src

floor src

ceil src

round src

zero? src

nonzero? src

nan? src

finite? src

inf? src

pos? src

neg? src

min src

max src

not= src

nonempty? src

compare src

range src

assert src

xor src

take src

drop src

+ src

- src

* src

/ src

The div-family wrappers dispatch the divisor on type-of: an INTEGER divisor is zero-guarded (the guard's fall-through proves it nonzero, which is what lets the silent %div/%rem lower); a FLOAT divisor divides directly under IEEE semantics (±inf/NaN) — the float arm's narrowing is the proof the intrinsic's float exemption accepts.

rem src

mod src

check-comparable src

lt-pair src

gt-pair src

le-pair src

ge-pair src

< src

> src

<= src

>= src

not src

pair src

push src

The (match (type-of coll) …) arms route to the MONOMORPHIC data ops: each arm narrows coll to a concrete container family (:array → Array, :@array → MutableArray, etc.), which is exactly the static proof the silent monomorphic op demands (the operand contract in hir/typeinfer/contract.rs — check_intrinsic_operand_proofs — rejects an arm whose container is unproven). Routing is the legality vehicle: the arms type-check as silent leaves. It is not, on its own, a reclamation win at a push/put caller — the closure call convention is the residue there. The :@string arm routes to the monomorphic %string-push-mut (a -mut pass-through, so its stranded owned-param container is compensated like the @array/@struct/@set -mut arms); the immutable :string and both :bytes arms keep the polymorphic %string-push/%bytes-push (no monomorphic @bytes byte-copy variant exists yet); the _ fallbacks keep the polymorphic %array-push/%put.

put src

add src

Set add is set-only, so — like push — the _ arm ERRORS rather than delegating to a polymorphic fallback native. The two container arms route to the silent monomorphic %add-set/%add-set-mut, which the region solver collapses when the container type is statically proven (else the runtime match dispatches). Freezing the element is the funnel body's job (prim_add).

del src

Remove is struct+set only (an array/string has no key-remove), so — like add — the _ arm ERRORS. The container arms route to the silent monomorphic %del-struct/%del-struct-mut/%del-set/%del-set-mut, which the region solver collapses when the container type is statically proven (else the runtime match dispatches on the funnel body, prim_del). The -mut arms return their container pass-through; the wrapper's container compensation reclaims the owned-param reference they strand (like add/put/push).

pop src

Pop is a moves_out REMOVE that mutates in place and returns the removed ELEMENT (not the container), so — unlike push/add/del — it is MUTABLE-only: an immutable array/string/bytes has nothing to remove-in-place, so the _ arm ERRORS (there is no polymorphic fallback). The three container arms route to the silent monomorphic funnels %pop/%pop-string/%pop-bytes, which the region solver reaches on a proven container. The @array arm's %pop moves out a pre-existing heap element (its tail retain is suppressed as redundant); the @string/@bytes arms return a FRESH grapheme / immediate byte and keep theirs.

map src

The first clause is the per-operator method, which overrides the operator. The second drives :iter, and rebuilds through :Collection :empty/:conj when the operator answers with a collection of the same kind. A builtin family reaches neither: trait/op and trait/iterable? (src/primitives/traits.rs) answer nil and false for one. docs/traits.md § Collection operators.

filter src

identity src

complement src

constantly src

compose src

partial src

juxt src

all? src

any? src

find src

find-index src

count src

nth src

zip src

flatten src

take-while src

drop-while src

distinct src

frequencies src

mapcat src

group-by src

map-indexed src

partition src

interpose src

min-key src

max-key src

memoize src

sort-by src

sort-by-builtin src

sort-with src

sort-with-builtin src

time/stopwatch src

time/elapsed src

call-count src

global? src

fiber/self src

fiber/new? src

fiber/alive? src

fiber/paused? src

fiber/dead? src

fiber/error? src

fiber/done? src

fiber-failed? src

fn/cfg src

fn/cfg-label src

fn/cfg-dot src

fn/cfg-mermaid src

merge src

stream/for-each src

stream/fold src

stream/collect src

stream/into-array src

stream/map src

stream/filter src

stream/take src

stream/drop src

stream/concat src

stream/zip src

stream/pipe src

port/lines src

port/chunks src

port/writer src

tcp/connect src

service-up? src

print src

println src

eprint src

eprintln src

ev/spawn src

make-async-scheduler src

ev/shutdown src

ev/report src

ev/step src

ev/with-scheduler src

ev/run src

emit-wait src

ev/futex-wait src

ev/futex-wake src

ev/join src

ev/join-protected src

ev/abort src

ev/as-completed src

ev/select src

ev/race src

ev/timeout src

ev/scope src

ev/map src

ev/map-limited src

chan/select src

sys/join src

inc src

dec src

subprocess/system src

ffi/pin src

from-pairs src

get-in src

put-in src

update-in src

update src

sum src

product src