docs: add generated-code-focused reference docs
ober
b91b87363af3d7a678e1e808d012d4699f0a7ca9
new file mode 100644 --- /dev/null +++ b/docs/anti-cookbook.md @@ -0,0 +1,375 @@ +# Jerboa Anti-Cookbook + +_Patterns that look right but aren't. Each entry shows **wrong** code a +reasonable LLM/Schemer would write, then the **correct** Jerboa form and +why it matters. Focused on multi-form pitfalls; single-identifier +hallucinations live in [`divergence.md`](divergence.md)._ + +--- + +## 1. `(hash-ref key ht)` — arg order reversed + +**Wrong** (Clojure/Racket order): +```scheme +(hash-ref "name" h) +``` +**Correct** (Jerboa/Gerbil order: container first): +```scheme +(hash-ref h "name") +(hash-ref h "name" "default") ; optional default +``` +**Why:** Jerboa follows Chez/Gerbil "container first" convention. Clojure is +the odd one out. + +--- + +## 2. `(sort lst <)` — arg order reversed + +**Wrong** (SRFI-95 / Clojure / Gerbil order): +```scheme +(sort '(3 1 2) <) +``` +**Correct** (Chez order: comparator first): +```scheme +(sort < '(3 1 2)) +``` +**Why:** `(std sort)` matches Chez, not SRFI-95. LLMs trained on Gerbil +reliably get this wrong — and the wrong form compiles silently then +crashes at runtime with a type error because `<` is being applied as +`(< '(3 1 2) <)`. + +--- + +## 3. `((list-of? number?) '(1 2 3))` — factory, not predicate + +**Wrong:** +```scheme +(list-of? number? '(1 2 3)) ; arity error +``` +**Correct:** +```scheme +((list-of? number?) '(1 2 3)) ; → #t +``` +**Why:** `list-of?` and `maybe` are predicate **factories**: they take one +argument and return a predicate. Same for `maybe`, `one-of?`. + +--- + +## 4. `(string-contains "abc" "b")` returns an index, not a boolean + +**Wrong:** +```scheme +(when (string-contains s "needle") + ...) +``` +**Correct** — `(string-contains s sub)` returns an index or `#f`, and +`0` is truthy in Scheme, so `(when (string-contains ...))` works: +```scheme +(when (string-contains s "needle") + ...) +``` +For an explicit predicate (and to avoid confusion with JS/Python where +`0` is falsy), import the predicate form: +```scheme +(import (std misc string-more)) ; NOT in the prelude +(string-contains? s "needle") ; → #t/#f +``` +**Why:** `string-contains` returns the match **index** (or `#f`). The +predicate form `string-contains?` lives in `(std misc string-more)`, not +the prelude. Prefer the explicit predicate when writing code others will +skim. + +--- + +## 5. `(string-split "a,b" ",")` — delimiter must be a **char** + +**Wrong:** +```scheme +(string-split "a,b,c" ",") ; passes a string +``` +**Correct:** +```scheme +(string-split "a,b,c" #\,) ; passes a char +``` +**Why:** Unlike Python / Racket / Clojure, Jerboa's `string-split` takes +a `char` delimiter, not a string. For multi-char delimiters, use +`(re-split "…" s)` from the prelude. + +--- + +## 6. `(raise "message")` — won't produce a readable error + +**Wrong:** +```scheme +(raise "something went wrong") ; raises a string condition +``` +**Correct:** +```scheme +(error 'my-func "something went wrong" irritant1 irritant2) +``` +**Why:** `raise` with a bare string propagates a string as the condition +object; downstream `(condition-message c)` returns `#f`. `error` +constructs a proper `&message`/`&irritants` condition with who/what/why +structure. + +--- + +## 7. `let` with multiple RHS forms referencing each other + +**Wrong** (expects Clojure's `let` or Racket's `let*`): +```scheme +(let ((x 1) + (y (+ x 1))) ; x not in scope here! + (* y 2)) +``` +**Correct**: +```scheme +(let* ((x 1) + (y (+ x 1))) + (* y 2)) +``` +**Why:** Scheme `let` binds all RHSs in parallel (no access to earlier +bindings). `let*` is sequential. `letrec` is mutually recursive. Pick +the right one. + +--- + +## 8. `(for ((x lst)) ...)` without an iterator + +**Wrong:** +```scheme +(for ((x '(1 2 3))) ; raw list, not an iterator + (displayln x)) +``` +**Correct:** +```scheme +(for ((x (in-list '(1 2 3)))) + (displayln x)) +``` +**Why:** `for` works with **iterator expressions**, not raw data. Use +`in-list`, `in-vector`, `in-string`, `in-range`, `in-hash-keys`, +`in-hash-values`, `in-hash-pairs`, `in-naturals`, `in-indexed`, +`in-port`, `in-lines`, `in-chars`, `in-bytes`. + +--- + +## 9. `(match val [list a b])` — missing inner parens + +**Wrong** (Clojure-ish, drops pattern constructor): +```scheme +(match val + ([a b c] "three") ; [a b c] is a bracket-list — this DOES match + (else "other")) ; but this form is fragile +``` +**Correct**: +```scheme +(match val + ((list a b c) (+ a b c)) + ((cons h t) h) + (_ 'other)) +``` +**Why:** Use explicit pattern constructors (`list`, `cons`, `vector`, +`?`, `and`, `or`). Bare bracket-lists work under stock Chez reader but +are a syntax error under the Jerboa reader (which rewrites `[...]` → +`(list ...)`). + +--- + +## 10. `(catch e ...)` — `try` needs a clause form + +**Wrong** (Java/JavaScript-ish): +```scheme +(try + (do-thing) + (catch e (handle e))) ; catch takes a BINDING LIST +``` +**Correct**: +```scheme +(try + (do-thing) + (catch (e) (handle e)) ; any exception, bound to e + (catch (error? e) (handle-error e)) ; predicate filter + (finally (cleanup))) +``` +**Why:** `catch` takes either `(var)` or `(pred var)` as the binding +form. The classic mistake is writing `(catch e ...)` which parses as a +predicate of one argument — often silently. + +--- + +## 11. `(make-rwlock 'my-lock)` — no name argument + +**Wrong** (Gerbil): +```scheme +(make-rwlock 'cache-lock) ; Gerbil accepts a name; Jerboa does not +``` +**Correct**: +```scheme +(make-rwlock) ; zero args +``` +**Why:** Jerboa's `make-rwlock` is a 0-argument procedure. For debug +identity, wrap with your own `(defstruct named-rwlock (lock name))`. + +--- + +## 12. `(path-expand relpath base)` — only 1 arg + +**Wrong** (Gerbil): +```scheme +(path-expand "foo.txt" "/home/user") +``` +**Correct**: +```scheme +(path-expand "foo.txt") ; absolute-ify against CWD +(path-join "/home/user" "foo.txt") ; the Jerboa way to combine +``` +**Why:** `path-expand` is unary; use `path-join` for concatenation. + +--- + +## 13. `(thread-sleep! 1.0)` — not a thing + +**Wrong** (Gambit): +```scheme +(thread-sleep! 2.5) +``` +**Correct**: +```scheme +(sleep (make-time 'time-duration 500000000 2)) ; 2.5 seconds +;; or +(import (std misc thread)) +(thread-sleep! 2.5) ; Gambit-compat export +``` +**Why:** Stock Jerboa prelude uses Chez's `sleep` which takes a `time` +object. The Gambit spelling works only when you explicitly import +`(std misc thread)`. + +--- + +## 14. `(with-resource port open-port close-port)` — arg order + +**Wrong** (looks like Lisp `with-slots`): +```scheme +(with-resource port (open-file "x.txt") (close-port port) + body) +``` +**Correct**: +```scheme +(with-resource (port (open-file "x.txt") close-port) + (read-all port)) +``` +**Why:** The first form is a 3-element **binding list**: `(var init +cleanup-proc)`. `cleanup-proc` is a procedure taking the resource, not +an expression. + +--- + +## 15. Hash-table iteration: iterator vs callback + +**Wrong** (mixes APIs): +```scheme +(for ((k v) (in-hash ht)) ; in-hash is not a Jerboa iterator name + ...) +``` +**Correct**: +```scheme +;; Callback style: +(hash-for-each (lambda (k v) ...) ht) + +;; Iterator style: +(for (((k v) (in-hash-pairs ht))) ; note the double parens + ...) +(for ((k (in-hash-keys ht))) ...) +(for ((v (in-hash-values ht))) ...) +``` +**Why:** Racket's `(in-hash h)` does not exist in Jerboa. Use one of the +three explicit iterators, or go callback-style with `hash-for-each`. + +--- + +## 16. `(displayln x y z)` — correct, but subtle + +**Wrong assumption:** "`displayln` takes one arg and newline." +Actually correct code: +```scheme +(displayln "answer: " 42 "!") +``` +Prints `answer: 42!` followed by newline. Jerboa's `displayln` is +variadic and concatenates display-formatted args — similar to `print` +in Racket. If you want `display` semantics + explicit newline, use: +```scheme +(display x) (newline) +``` + +--- + +## 17. `(ok 1 2)` / `(err)` — Result is unary + +**Wrong**: +```scheme +(ok 1 2 3) ; arity error +(err) ; arity error +``` +**Correct**: +```scheme +(ok (list 1 2 3)) ; pack multiple values +(err "reason") ; always one payload +``` +**Why:** `ok` / `err` wrap exactly one value. Multiple results must be +packed into a list, vector, or record. + +--- + +## 18. Quasi-regex: `re-match?` vs `re-search` + +**Wrong assumption:** "`re-match?` returns a match object." +```scheme +(let ((m (re-match? #/\d+/ "abc 42"))) + (match-group m 0)) ; m is #t, not a match obj +``` +**Correct**: +```scheme +(let ((m (re-search "\\d+" "abc 42"))) ; returns match-obj or #f + (when m (re-match-group m 0))) ; → "42" + +(re-match? "\\d+" "42") ; → #t (full-string match only) +(re-match? "\\d+" "abc 42") ; → #f (must match ENTIRE string) +``` +**Why:** `re-match?` is a boolean **full-string** match. `re-search` +finds a substring match and returns a match object. `re-find-all` +returns all matches as strings. + +--- + +## 19. `(format "~s" x)` — `~s` vs `~a` + +**Same as Common Lisp, but worth calling out:** +```scheme +(format "~a" "hi") ; → "hi" (display) +(format "~s" "hi") ; → "\"hi\"" (write — readable) +(format "~%") ; → "\n" +(format "~a, ~a" 1 2) ; → "1, 2" +``` +Do not use `{}` (Python), `%s` (C), or `${…}` (JS) — Jerboa's `format` +is CL/Racket style only. + +--- + +## 20. `(defstruct point (x y))` defines a constructor named `make-point` + +**Wrong assumption:** "the constructor is `point`." +```scheme +(defstruct point (x y)) +(point 1 2) ; undefined — `point` is the predicate maker +``` +**Correct**: +```scheme +(defstruct point (x y)) +(define p (make-point 1 2)) +(point? p) ; → #t +(point-x p) ; → 1 accessor +(point-x-set! p 99) ; → unspecified mutator +``` +**Why:** The macro generates names by convention: `make-NAME`, `NAME?`, +`NAME-FIELD`, `NAME-FIELD-set!`. Verify with `jerboa_class_info` if in +doubt. Do **not** assume Racket's `set-NAME-FIELD!` order. new file mode 100644 --- /dev/null +++ b/docs/api-index.md @@ -0,0 +1,13342 @@ +# Jerboa API Index + +_Auto-generated from `jerboa-mcp/api-signatures.json` (2026-04-22). 626 modules, 12393 unique symbols, 18925 total exports._ + +> **Authoritative.** If a symbol does not appear in the index below, it is not exported by any Jerboa library and any reference is a hallucination. This index is parsed directly from `.sls` source files on every regeneration. + +## Contents + +- [1. Prelude exports](#1-prelude-exports) +- [2. Where is X? (symbol → modules)](#2-where-is-x-symbol--modules) +- [3. Module catalog](#3-module-catalog) + +## 1. Prelude exports + +Importing `(jerboa prelude)` gives you 438 bindings. Everything listed here is available with no further import. + +<details><summary>Full list</summary> + +``` +*method-tables* *struct-types* -> +->> ->>? ->? +1+ 1- : +<...> <> ContractViolation +Error acons add-watch! +aget agetq agetv +aif alist alist->hash-table +alist->plist* alist? alists->csv +and-then any append-map +append1 arem arem! +aremq aremq! aremv +aremv! as-> aset +aset! asetq asetq! +asetv asetv! assert! +assoc-in assoc-in! atom +atom-deref atom-reset! atom-swap! +atom-update! atom? awhen +begin-ffi bind-method! butlast +c-declare c-lambda call-method +call-with-list-builder capture catch +chain chain-and comp +compare-and-set! complement compose +compose1 cond-> cond->> +conjoin constantly cpu-count +csv->alists csv-port->rows curry +curryn cut cute +date->string datetime->alist datetime->epoch +datetime->iso8601 datetime->julian datetime->string +datetime-add datetime-clamp datetime-day +datetime-diff datetime-floor-day datetime-floor-hour +datetime-floor-month datetime-hour datetime-max +datetime-min datetime-minute datetime-month +datetime-nanosecond datetime-now datetime-offset +datetime-second datetime-subtract datetime-truncate +datetime-utc-now datetime-year datetime<=? +datetime<? datetime=? datetime>=? +datetime>? datetime? day-of-week +day-of-year days-in-month def +def* defclass define-active-pattern +define-c-lambda define-enum define-match-type +define-rx define-sealed-hierarchy define-values +defmethod defn defrecord +defrule defrules defstruct +delete-duplicates/hash deref directory-exists? +disjoin displayln distinct +dotimes drop drop-last +drop-until drop-while duplicates +duration duration-nanoseconds duration-seconds +duration? epoch->datetime eprintf +eql? err err->list +err? error-irritants error-message +error-trace every every-consecutive? +every-pred filter-err filter-map +filter-ok finally first-and-only +flatten flatten-result flatten1 +flip fnil for +for-each! for/and for/collect +for/fold for/or force-output +format fprintf frequencies +get-in group-by group-consecutive +group-n-consecutive group-same hash->list +hash->plist hash-clear! hash-copy +hash-eq-literal hash-find hash-fold +hash-for-each hash-get hash-has-key? +hash-key? hash-keys hash-length +hash-literal hash-map hash-merge +hash-merge! hash-put! hash-ref +hash-remove! hash-set hash-table-set! +hash-table? hash-update! hash-values +identity if-let in-bytes +in-chars in-hash-keys in-hash-pairs +in-hash-values in-indexed in-lines +in-list in-naturals in-port +in-producer in-range in-string +in-vector interleave interpose +iota iterate-n json-object->string +julian->datetime juxt keep +keyword->string keyword? last-pair +leap-year? length<=? length<=n? +length<? length<n? length=? +length=n? length>=? length>=n? +length>? length>n? let-alist +let-hash list->hash-table list-of? +make-date make-datetime make-duration +make-hash-table make-hash-table-eq make-keyword +make-shared make-time map-err +map-ok map-results map/car +mapcat match match/strict +maybe memo-proc meta +meta-wrapped? negate nested-empty-like +nested-get ok ok->list +ok? or-else parse-date +parse-datetime parse-time partial +partition partition-all partition-by +path-absolute? path-directory path-expand +path-extension path-join path-normalize +path-strip-directory path-strip-extension pget +pgetq pgetv plist->alist* +plist->hash-table pop! pp +pp-to-string ppd ppd-to-string +pprint prem prem! +premq premq! premv +premv! printf processor-count +pset pset! psetq +psetq! psetv psetv! +push! random-integer rassoc +re re-find-all re-fold +re-groups re-match-end re-match-full +re-match-group re-match-groups re-match-named +re-match-start re-match? re-replace +re-replace-all re-search re-split +re? read-all-as-lines read-all-as-string +read-csv read-csv-file read-file-lines +read-file-string read-json read-line +reductions regex-match regex-replace +regex-replace-all regex-search register-struct-type! +remove-watch! reset! result->option +result->values result? results-partition +rows->csv-string rx sequence-results +shared-cas! shared-ref shared-set! +shared-swap! shared-update! shared? +slice snoc some +some-> some->> some-fn +sort sort! split +split-at split-with stable-sort +stable-sort! str string->json-object +string->keyword string-contains string-empty? +string-find string-find-all string-index +string-join string-map string-match? +string-prefix? string-split string-suffix? +string-trim strip-meta struct-field-ref +struct-field-set! struct-predicate struct-type-info +swap! take take-last +take-until take-while time->string +try try-result try-result* +unique until unwind-protect +unwrap unwrap-err unwrap-or +unwrap-or-else update-in update-in! +using vary-meta vderef +volatile! volatile? vreset! +vswap! when-let when/list +while with-catch with-id +with-input-from-string with-list-builder with-lock +with-meta with-output-to-string with-resource +write-csv write-csv-file write-file-string +write-json zip ~ +``` + +</details> + +## 2. Where is X? (symbol → modules) + +Every exported symbol, mapped to the modules that export it. If a symbol has multiple providers, any of them will give you that binding. + +| [1](#idx-1) | [a](#idx-a) | [b](#idx-b) | [c](#idx-c) | [d](#idx-d) | [e](#idx-e) | [f](#idx-f) | [g](#idx-g) | [h](#idx-h) | [i](#idx-i) | [j](#idx-j) | [k](#idx-k) | [l](#idx-l) | [m](#idx-m) | [n](#idx-n) | [o](#idx-o) | [p](#idx-p) | [q](#idx-q) | [r](#idx-r) | [s](#idx-s) | [sym](#idx-sym) | [t](#idx-t) | [u](#idx-u) | [v](#idx-v) | [w](#idx-w) | [x](#idx-x) | [y](#idx-y) | [z](#idx-z) | +| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | + +### <a name="idx-1"></a>1 + +| Symbol | Modules | +| --- | --- | +| `1+` | `(jerboa clojure)`, `(jerboa core)`, `(jerboa prelude safe)`, `(jerboa prelude)`, ... (+3) | +| `1-` | `(jerboa clojure)`, `(jerboa core)`, `(jerboa prelude safe)`, `(jerboa prelude)`, ... (+3) | + +### <a name="idx-a"></a>a + +| Symbol | Modules | +| --- | --- | +| `AF_SP` | `(std ffi nanomsg)`, `(thunderchez nanomsg)` | +| `AF_SP_RAW` | `(std ffi nanomsg)`, `(thunderchez nanomsg)` | +| `ALL` | `(std specter)` | +| `Applicative` | `(std typed hkt)` | +| `Async` | `(std async)` | +| `Async::descriptor` | `(std async)` | +| `abi-name` | `(jerboa cross)` | +| `abort` | `(std control delimited)` | +| `abort-to-prompt` | `(std misc delimited)` | +| `absento` | `(jerboa clojure)`, `(std logic)` | +| `acons` | `(jerboa clojure)`, `(jerboa prelude)`, `(std misc alist)` | +| `acquire` | `(std effect resource)` | +| `acquire-port` | `(std effect resource)` | +| `activate-cloj-reader!` | `(jerboa cloj)`, `(jerboa clojure)` | +| `active-pattern-proc` | `(std match2)` | +| `active-pattern?` | `(std match2)` | +| `actor-alive?` | `(std actor core)`, `(std actor)` | +| `actor-dead?` | `(std error conditions)` | +| `actor-error-actor-id` | `(std error conditions)` | +| `actor-error?` | `(std error conditions)` | +| `actor-id` | `(std actor core)`, `(std actor)` | +| `actor-kill!` | `(std actor core)`, `(std actor)` | +| `actor-ref-id` | `(std actor core)`, `(std actor)` | +| `actor-ref-links` | `(std actor core)`, `(std actor)` | +| `actor-ref-links-set!` | `(std actor core)`, `(std actor)` | +| `actor-ref-mailbox` | `(std actor core)` | +| `actor-ref-monitors` | `(std actor core)`, `(std actor)` | +| `actor-ref-monitors-set!` | `(std actor core)`, `(std actor)` | +| `actor-ref-name` | `(std actor core)`, `(std actor)` | +| `actor-ref-node` | `(std actor core)`, `(std actor)` | +| `actor-ref?` | `(std actor core)`, `(std actor)` | +| `actor-timeout-seconds` | `(std error conditions)` | +| `actor-timeout?` | `(std error conditions)` | +| `actor-wait!` | `(std actor core)`, `(std actor)` | +| `add-command!` | `(std cli multicall)` | +| `add-duration` | `(std srfi srfi-19)` | +| `add-method!` | `(std clos)` | +| `add-rule!` | `(std lint)` | +| `add-signal-handler!` | `(std os signal)` | +| `add-sink!` | `(std log)` | +| `add-watch!` | `(jerboa clojure)`, `(jerboa prelude)`, `(std clojure)`, `(std misc atom)` | +| `address->string` | `(std net address)` | +| `address-host` | `(std net address)` | +| `address-port` | `(std net address)` | +| `address?` | `(std net address)` | +| `admix` | `(std csp clj)` | +| `admix!` | `(std csp mix)`, `(std csp ops)` | +| `advise-after` | `(std misc advice)` | +| `advise-around` | `(std misc advice)` | +| `advise-before` | `(std misc advice)` | +| `advise-error` | `(std error-advice)` | +| `advised?` | `(std misc advice)` | +| `aead-decrypt` | `(std crypto aead)` | +| `aead-encrypt` | `(std crypto aead)` | +| `aead-key-generate` | `(std crypto aead)` | +| `affine-consumed?` | `(std typed affine)` | +| `affine-drop!` | `(std typed affine)` | +| `affine-peek` | `(std typed affine)` | +| `affine-use` | `(std typed affine)` | +| `affine?` | `(std typed affine)` | +| `after` | `(std select)` | +| `agent` | `(std agent)` | +| `agent-error` | `(std agent)` | +| `agent-value` | `(std agent)` | +| `agent?` | `(std agent)` | +| `aget` | `(jerboa clojure)`, `(jerboa prelude clean)`, `(jerboa prelude safe)`, `(jerboa prelude)`, ... (+2) | +| `agetq` | `(jerboa clojure)`, `(jerboa prelude clean)`, `(jerboa prelude safe)`, `(jerboa prelude)`, ... (+2) | +| `agetv` | `(jerboa clojure)`, `(jerboa prelude clean)`, `(jerboa prelude safe)`, `(jerboa prelude)`, ... (+2) | +| `agg-collect` | `(std table)` | +| `agg-count` | `(std table)` | +| `agg-max` | `(std table)` | +| `agg-mean` | `(std table)` | +| `agg-min` | `(std table)` | +| `agg-sum` | `(std table)` | +| `aif` | `(jerboa clojure)`, `(jerboa prelude)`, `(std gambit-compat)`, `(std prelude)`, ... (+1) | +| `alias` | `(std srfi srfi-212)` | +| `alist` | `(jerboa clojure)`, `(jerboa prelude)`, `(std prelude)`, `(std sugar)` | +| `alist->btree` | `(std mmap-btree)` | +| `alist->hamt` | `(std misc persistent)` | +| `alist->hash` | `(std misc alist-more)` | +| `alist->hash-table` | `(jerboa clojure)`, `(jerboa prelude clean)`, `(jerboa prelude safe)`, `(jerboa prelude)`, ... (+3) | +| `alist->headers` | `(std net request)` | +| `alist->mapping` | `(std srfi srfi-146)` | +| `alist->plist` | `(std misc plist)` | +| `alist->plist*` | `(jerboa clojure)`, `(jerboa prelude)`, `(std misc alist)` | +| `alist->pmap` | `(std data pmap)` | +| `alist->protobuf` | `(std protobuf)` | +| `alist->query-string` | `(std net uri)` | +| `alist->record` | `(std debug record-inspect)` | +| `alist->sorted-map` | `(std ds sorted-map)` | +| `alist-copy` | `(std srfi srfi-1)` | +| `alist-delete` | `(std srfi srfi-1)` | +| `alist-delete!` | `(std srfi srfi-1)` | +| `alist-filter` | `(std misc alist-more)` | +| `alist-keys` | `(std misc alist-more)` | +| `alist-list->relation` | `(std misc relation)` | +| `alist-map` | `(std misc alist-more)` | +| `alist-merge` | `(std misc alist-more)` | +| `alist-ref/default` | `(std misc alist-more)` | +| `alist-update` | `(std misc alist-more)` | +| `alist-values` | `(std misc alist-more)` | +| `alist?` | `(jerboa clojure)`, `(jerboa prelude)`, `(std misc alist)` | +| `alists->csv` | `(jerboa clojure)`, `(jerboa prelude)`, `(std csv)`, `(std prelude)` | +| `all-sealed-methods` | `(std dev devirt)` | +| `all-solutions` | `(std effect multishot)` | +| `alloc-profile-start!` | `(std dev profile)` | +| `alloc-profile-stop!` | `(std dev profile)` | +| `alloc-results` | `(std dev profile)` | +| `allocate-instance` | `(std clos)` | +| `allocation-count` | `(std profile)` | +| `alt!` | `(std csp clj)`, `(std csp select)` | +| `alt!!` | `(std csp clj)`, `(std csp select)` | +| `alter` | `(std stm)` | +| `alts!` | `(std csp clj)`, `(std csp select)` | +| `alts!!` | `(std csp clj)`, `(std csp select)` | +| `always-event` | `(std misc event)` | +| `always-evt` | `(std event)` | +| `amb` | `(std amb)`, `(std effect multishot)`, `(std misc amb)` | +| `amb-all` | `(std effect multishot)` | +| `amb-assert` | `(std amb)`, `(std misc amb)` | +| `amb-collect` | `(std amb)`, `(std misc amb)` | +| `amb-fail` | `(std amb)`, `(std misc amb)` | +| `amb-find` | `(std amb)` | +| `analyze-document` | `(std lsp)` | +| `and-then` | `(jerboa clojure)`, `(jerboa prelude)`, `(std prelude)`, `(std result)` | +| `annotate-code` | `(std quasiquote-types)` | +| `annotated-datum` | `(jerboa reader)` | +| `annotated-datum-source` | `(jerboa reader)` | +| `annotated-datum-value` | `(jerboa reader)` | +| `annotated-datum?` | `(jerboa reader)` | +| `antidebug-breakpoint?` | `(std os antidebug)` | +| `antidebug-check-all` | `(std os antidebug)` | +| `antidebug-error-reason` | `(std os antidebug)` | +| `antidebug-error?` | `(std os antidebug)` | +| `antidebug-ld-preload?` | `(std os antidebug)` | +| `antidebug-ptrace!` | `(std os antidebug)` | +| `antidebug-timing-anomaly?` | `(std os antidebug)` | +| `antidebug-traced?` | `(std os antidebug)` | +| `any` | `(jerboa clojure)`, `(jerboa core)`, `(jerboa prelude clean)`, `(jerboa prelude safe)`, ... (+5) | +| `any-bit-set?` | `(std srfi srfi-151)` | +| `any?-ec` | `(std srfi srfi-42)` | +| `api-key-register!` | `(std security auth)` | +| `api-key-revoke!` | `(std security auth)` | +| `api-key-store?` | `(std security auth)` | +| `api-key-validate` | `(std security auth)` | +| `app-arguments` | `(std app)` | +| `app-init-proc` | `(std app)` | +| `app-main-proc` | `(std app)` | +| `app-name` | `(std app)` | +| `app-run!` | `(std app)` | +| `app?` | `(std app)` | +| `append-map` | `(jerboa clojure)`, `(jerboa prelude)`, `(std misc list)`, `(std srfi srfi-1)` | +| `append-map!` | `(std srfi srfi-1)` | +| `append-reverse` | `(std srfi srfi-1)` | +| `append-reverse!` | `(std srfi srfi-1)` | +| `append1` | `(jerboa clojure)`, `(jerboa prelude)`, `(std misc list)` | +| `appendo` | `(jerboa clojure)`, `(std logic)` | +| `apply-dynamic-bindings` | `(jerboa clojure)`, `(std clojure)` | +| `apply-generic` | `(std clos)` | +| `apply-input-transformers` | `(std repl middleware)` | +| `apply-method` | `(std clos)` | +| `apply-methods` | `(std clos)` | +| `apply-optimization-passes` | `(std compiler passes)` | +| `apply-security-headers` | `(std net security-headers)` | +| `apply-xf` | `(std transducer)` | +| `arbitrary-boolean` | `(std test framework)` | +| `arbitrary-integer` | `(std test framework)` | +| `arbitrary-list` | `(std test framework)` | +| `arbitrary-string` | `(std test framework)` | +| `arem` | `(jerboa clojure)`, `(jerboa prelude)`, `(std misc alist)` | +| `arem!` | `(jerboa clojure)`, `(jerboa prelude)`, `(std misc alist)` | +| `aremq` | `(jerboa clojure)`, `(jerboa prelude)`, `(std misc alist)` | +| `aremq!` | `(jerboa clojure)`, `(jerboa prelude)`, `(std misc alist)` | +| `aremv` | `(jerboa clojure)`, `(jerboa prelude)`, `(std misc alist)` | +| `aremv!` | `(jerboa clojure)`, `(jerboa prelude)`, `(std misc alist)` | +| `arena-alloc` | `(std arena)` | +| `arena-alloc-bytes` | `(std arena)` | +| `arena-alloc-string` | `(std arena)` | +| `arena-capacity` | `(std arena)` | +| `arena-checkpoint` | `(std arena)` | +| `arena-destroy!` | `(std arena)` | +| `arena-intern!` | `(std arena)` | +| `arena-intern-lookup` | `(std arena)` | +| `arena-remaining` | `(std arena)` | +| `arena-reset!` | `(std arena)` | +| `arena-rollback!` | `(std arena)` | +| `arena-stats` | `(std arena)` | +| `arena-used` | `(std arena)` | +| `arena?` | `(std arena)` | +| `argon2id-available?` | `(std crypto password)` | +| `argument` | `(std cli getopt)` | +| `arithmetic-seq` | `(std compiler partial-eval)` | +| `arithmetic-shift` | `(jerboa core)`, `(std gambit-compat)`, `(std srfi srfi-151)` | +| `arity-error` | `(std errors)` | +| `arity-error-definition` | `(std errors)` | +| `arity-error-expected` | `(std errors)` | +| `arity-error-got` | `(std errors)` | +| `arity-error-who` | `(std errors)` | +| `arity-error?` | `(std errors)` | +| `artifact-store-get` | `(std build reproducible)` | +| `artifact-store-has?` | `(std build reproducible)` | +| `artifact-store-path` | `(std build reproducible)` | +| `artifact-store-put!` | `(std build reproducible)` | +| `artifact-store?` | `(std build reproducible)` | +| `as->` | `(jerboa clojure)`, `(jerboa prelude)`, `(std prelude)`, `(std sugar)` | +| `aset` | `(jerboa clojure)`, `(jerboa prelude)`, `(std misc alist)` | +| `aset!` | `(jerboa clojure)`, `(jerboa prelude clean)`, `(jerboa prelude safe)`, `(jerboa prelude)`, ... (+2) | +| `asetq` | `(jerboa clojure)`, `(jerboa prelude)`, `(std misc alist)` | +| `asetq!` | `(jerboa clojure)`, `(jerboa prelude clean)`, `(jerboa prelude safe)`, `(jerboa prelude)`, ... (+2) | +| `asetv` | `(jerboa clojure)`, `(jerboa prelude)`, `(std misc alist)` | +| `asetv!` | `(jerboa clojure)`, `(jerboa prelude clean)`, `(jerboa prelude safe)`, `(jerboa prelude)`, ... (+2) | +| `ask` | `(std actor protocol)`, `(std actor)` | +| `ask-sync` | `(std actor protocol)`, `(std actor)` | +| `assert!` | `(jerboa clojure)`, `(jerboa prelude clean)`, `(jerboa prelude safe)`, `(jerboa prelude)`, ... (+5) | +| `assert-contract` | `(std contract)` | +| `assert-equal!` | `(std assert)` | +| `assert-exception` | `(std assert)` | +| `assert-flow` | `(std security flow)` | +| `assert-pred` | `(std assert)` | +| `assert-refined` | `(std typed advanced)`, `(std typed refine)` | +| `assert-type` | `(std macro-types)`, `(std typed)` | +| `assert-untainted` | `(std security taint)` | +| `assoc` | `(jerboa clojure)`, `(std clojure)` | +| `assoc!` | `(jerboa clojure)`, `(std clojure)` | +| `assoc-in` | `(jerboa clojure)`, `(jerboa prelude)`, `(std clojure)`, `(std misc nested)` | +| `assoc-in!` | `(jerboa clojure)`, `(jerboa prelude)`, `(std misc nested)` | +| `assume` | `(std srfi srfi-145)` | +| `ast->nfa` | `(std regex-ct-impl)` | +| `async` | `(std concur async-await)` | +| `async-channel-get` | `(std async)` | +| `async-channel-put` | `(std async)` | +| `async-promise-resolve!` | `(std async)` | +| `async-promise-resolved?` | `(std async)` | +| `async-promise-value` | `(std async)` | +| `async-promise?` | `(std async)` | +| `async-reduce` | `(std csp clj)` | +| `async-sleep` | `(std async)` | +| `async-stream->list` | `(std stream async)` | +| `async-stream-empty?` | `(std stream async)` | +| `async-stream-filter` | `(std stream async)` | +| `async-stream-fold` | `(std stream async)` | +| `async-stream-for-each` | `(std stream async)` | +| `async-stream-map` | `(std stream async)` | +| `async-stream-next!` | `(std stream async)` | +| `async-stream-take` | `(std stream async)` | +| `async-task` | `(std async)` | +| `async-task?` | `(std async)` | +| `at-compile-time` | `(std staging)` | +| `atom` | `(jerboa clojure)`, `(jerboa prelude)`, `(std clojure)`, `(std misc atom)` | +| `atom-deref` | `(jerboa prelude)`, `(std misc atom)` | +| `atom-reset!` | `(jerboa prelude)`, `(std misc atom)` | +| `atom-swap!` | `(jerboa prelude)`, `(std misc atom)` | +| `atom-update!` | `(jerboa prelude)`, `(std misc atom)` | +| `atom?` | `(jerboa clojure)`, `(jerboa prelude)`, `(std clojure)`, `(std misc atom)` | +| `atomically` | `(std concur stm)`, `(std stm)` | +| `attenuate-capability` | `(std security capability)` | +| `attenuate-eval` | `(std capability)` | +| `attenuate-fs` | `(std capability)` | +| `attenuate-net` | `(std capability)` | +| `audit-event-types` | `(std security audit)` | +| `audit-imports-directory` | `(std security import-audit)` | +| `audit-imports-file` | `(std security import-audit)` | +| `audit-log!` | `(std security audit)` | +| `audit-logger-close!` | `(std security audit)` | +| `audit-logger?` | `(std security audit)` | +| `auth-result-authenticated?` | `(std security auth)` | +| `auth-result-identity` | `(std security auth)` | +| `auth-result-roles` | `(std security auth)` | +| `auth-result?` | `(std security auth)` | +| `authenticated-message-hmac` | `(std actor cluster-security)` | +| `authenticated-message-payload` | `(std actor cluster-security)` | +| `authenticated-message-sender` | `(std actor cluster-security)` | +| `authenticated-message-sequence` | `(std actor cluster-security)` | +| `authenticated-message-timestamp` | `(std actor cluster-security)` | +| `authenticated-message?` | `(std actor cluster-security)` | +| `auto-clone` | `(std derive2)` | +| `auto-compare` | `(std derive2)` | +| `auto-display` | `(std derive2)` | +| `auto-equal` | `(std derive2)` | +| `auto-hash` | `(std derive2)` | +| `auto-json` | `(std derive2)` | +| `auto-serialize` | `(std derive2)` | +| `auto-specialization-enabled?` | `(std compiler partial-eval)` | +| `await` | `(std agent)`, `(std concur async-await)` | +| `await-all` | `(std concur async-await)` | +| `await-any` | `(std concur async-await)` | +| `awhen` | `(jerboa clojure)`, `(jerboa prelude)`, `(std gambit-compat)`, `(std prelude)`, ... (+1) | +| `aws-sigv4-sign` | `(std net s3)` | + +### <a name="idx-b"></a>b + +| Symbol | Modules | +| --- | --- | +| `BYTEVECTOR-HEADER-PAYLOAD` | `(jerboa wasm values)` | +| `Bounded` | `(std typed refine)` | +| `bag` | `(std srfi srfi-113)` | +| `bag->list` | `(std srfi srfi-113)` | +| `bag-adjoin` | `(std srfi srfi-113)` | +| `bag-count` | `(std srfi srfi-113)` | +| `bag-delete` | `(std srfi srfi-113)` | +| `bag?` | `(std srfi srfi-113)` | +| `balanced-quotient` | `(std srfi srfi-141)` | +| `balanced-remainder` | `(std srfi srfi-141)` | +| `balanced/` | `(std srfi srfi-141)` | +| `barrier-parties` | `(std misc barrier)` | +| `barrier-reset!` | `(std concur util)`, `(std misc barrier)` | +| `barrier-wait!` | `(std concur util)`, `(std misc barrier)` | +| `barrier-waiting` | `(std misc barrier)` | +| `barrier?` | `(std concur util)`, `(std misc barrier)` | +| `base58-decode` | `(std text base58)` | +| `base58-encode` | `(std text base58)` | +| `base58check-decode` | `(std text base58)` | +| `base58check-encode` | `(std text base58)` | +| `base64-decode` | `(std text base64)` | +| `base64-encode` | `(std text base64)` | +| `base64-string->u8vector` | `(std text base64)` | +| `batch-call` | `(std net json-rpc)` | +| `begin-ffi` | `(jerboa clojure)`, `(jerboa ffi)`, `(jerboa prelude clean)`, `(jerboa prelude)`, ... (+1) | +| `benchmark->alist` | `(std dev benchmark)` | +| `benchmark-compare` | `(std dev benchmark)` | +| `benchmark-faster?` | `(std dev benchmark)` | +| `benchmark-name` | `(std dev benchmark)` | +| `benchmark-report` | `(std dev benchmark)` | +| `benchmark-result-max-ns` | `(std dev benchmark)` | +| `benchmark-result-mean-ns` | `(std dev benchmark)` | +| `benchmark-result-median-ns` | `(std dev benchmark)` | +| `benchmark-result-min-ns` | `(std dev benchmark)` | +| `benchmark-result-name` | `(std dev benchmark)` | +| `benchmark-result-samples` | `(std dev benchmark)` | +| `benchmark-result-stddev-ns` | `(std dev benchmark)` | +| `benchmark-result?` | `(std dev benchmark)` | +| `benchmark-run` | `(std dev benchmark)` | +| `benchmark-setup` | `(std dev benchmark)` | +| `benchmark-teardown` | `(std dev benchmark)` | +| `benchmark?` | `(std dev benchmark)` | +| `bg-color` | `(std misc terminal)` | +| `binary-pack` | `(std binary)` | +| `binary-read` | `(std binary)`, `(std misc binary-type)` | +| `binary-struct-fields` | `(std binary)` | +| `binary-struct-name` | `(std binary)` | +| `binary-struct-size` | `(std binary)` | +| `binary-struct?` | `(std binary)` | +| `binary-unpack` | `(std binary)` | +| `binary-write` | `(std misc binary-type)` | +| `binary-write!` | `(std binary)` | +| `bind-method!` | `(jerboa clojure)`, `(jerboa core)`, `(jerboa prelude clean)`, `(jerboa prelude safe)`, ... (+4) | +| `binding` | `(jerboa clojure)`, `(std clojure)` | +| `bio-close` | `(std net bio)` | +| `bio-flush` | `(std net bio)` | +| `bio-peek-byte` | `(std net bio)` | +| `bio-read-byte` | `(std net bio)` | +| `bio-read-bytes` | `(std net bio)` | +| `bio-read-line` | `(std net bio)` | +| `bio-unread-byte` | `(std net bio)` | +| `bio-write-byte` | `(std net bio)` | +| `bio-write-bytes` | `(std net bio)` | +| `bio-write-string` | `(std net bio)` | +| `bit-count` | `(std srfi srfi-151)` | +| `bit-field` | `(std srfi srfi-151)` | +| `bit-field-any?` | `(std srfi srfi-151)` | +| `bit-field-clear` | `(std srfi srfi-151)` | +| `bit-field-every?` | `(std srfi srfi-151)` | +| `bit-field-replace` | `(std srfi srfi-151)` | +| `bit-field-rotate` | `(std srfi srfi-151)` | +| `bit-field-set` | `(std srfi srfi-151)` | +| `bit-set?` | `(std srfi srfi-151)` | +| `bit-swap` | `(std srfi srfi-151)` | +| `bitwise-and` | `(std srfi srfi-151)` | +| `bitwise-if` | `(std srfi srfi-151)` | +| `bitwise-ior` | `(std srfi srfi-151)` | +| `bitwise-not` | `(std srfi srfi-151)` | +| `bitwise-xor` | `(std srfi srfi-151)` | +| `black` | `(std cli style)` | +| `blank?` | `(std clojure string)` | +| `blink` | `(std misc terminal)` | +| `blue` | `(std cli style)` | +| `bn*` | `(std crypto bn)` | +| `bn+` | `(std crypto bn)` | +| `bn-` | `(std crypto bn)` | +| `bn->bytevector` | `(std crypto bn)` | +| `bn->hex` | `(std crypto bn)` | +| `bn-bit-length` | `(std crypto bn)` | +| `bn-compare` | `(std crypto bn)` | +| `bn-expt-mod` | `(std crypto bn)` | +| `bn-gcd` | `(std crypto bn)` | +| `bn-mod` | `(std crypto bn)` | +| `bn-modinv` | `(std crypto bn)` | +| `bn-negative?` | `(std crypto bn)` | +| `bn-zero?` | `(std crypto bn)` | +| `bn/` | `(std crypto bn)` | +| `bold` | `(std cli style)`, `(std misc terminal)` | +| `boolean-comparator` | `(std srfi srfi-128)` | +| `borrow` | `(std borrow)` | +| `borrow-count` | `(std borrow)` | +| `borrow-mut` | `(std borrow)` | +| `bound-fn` | `(jerboa clojure)`, `(std clojure)` | +| `bounded-deque-capacity` | `(std misc deque)` | +| `bounded-deque?` | `(std misc deque)` | +| `bounded-send` | `(std actor bounded)` | +| `box` | `(std gambit-compat)` | +| `box?` | `(std gambit-compat)` | +| `break-never!` | `(std dev debug)` | +| `break-when!` | `(std dev debug)` | +| `btree->alist` | `(std mmap-btree)` | +| `btree-commit!` | `(std mmap-btree)` | +| `btree-delete!` | `(std mmap-btree)` | +| `btree-fold` | `(std mmap-btree)` | +| `btree-get` | `(std mmap-btree)` | +| `btree-has?` | `(std mmap-btree)` | +| `btree-keys` | `(std mmap-btree)` | +| `btree-order` | `(std mmap-btree)` | +| `btree-path` | `(std mmap-btree)` | +| `btree-put!` | `(std mmap-btree)` | +| `btree-range` | `(std mmap-btree)` | +| `btree-rollback!` | `(std mmap-btree)` | +| `btree-size` | `(std mmap-btree)` | +| `btree-values` | `(std mmap-btree)` | +| `btree?` | `(std mmap-btree)` | +| `buffer-pool-stats` | `(std net zero-copy)` | +| `buffer-pool?` | `(std net zero-copy)` | +| `buffer-slice?` | `(std net zero-copy)` | +| `buffer-spec?` | `(std csp clj)` | +| `buffered-close` | `(std io bio)` | +| `buffered-flush` | `(std io bio)` | +| `buffered-input?` | `(std io bio)` | +| `buffered-output?` | `(std io bio)` | +| `buffered-peek-byte` | `(std io bio)` | +| `buffered-peek-char` | `(std io bio)` | +| `buffered-read-byte` | `(std io bio)` | +| `buffered-read-bytes` | `(std io bio)` | +| `buffered-read-char` | `(std io bio)` | +| `buffered-read-line` | `(std io bio)` | +| `buffered-unread-byte` | `(std io bio)` |