jolt/docs/libraries.md
Yogthos 4cf95dc27c core.async: higher-level API over native channels + two general fixes
Adds clojure.core.async's higher-level dataflow API as a Clojure overlay
(stdlib/clojure/core/async.clj) over jolt's native channel primitives, plus
clojure.core.async.lab. The native layer (host/chez/java/async.ss) gains
offer!/poll!, put specs and :priority/:default in alts!, a transducer
ex-handler arg to chan, unblocking-buffer?, promise-buffer, and on-caller?
handling for put!/take!. The overlay covers alts!/pipe/pipeline/split/
reduce/transduce/into/take/mult/mix/pub-sub/map/merge/onto-chan/to-chan and
the deprecated map</map>/filter>/... family (rewritten as go-loops since the
JVM versions reify the impl handler protocol jolt doesn't expose).

Loading: the native primitives pre-seed clojure.core.async, so the loader now
drops it from the loaded set and a require pulls the overlay from the source
roots like clojure.test (AOT-bundled into built binaries).

Running clojure/core.async's own suite shook out two general bugs:
- :refer with a list form, (:require [ns :refer (a b c)]), dropped the names
  (only the vector form was handled) — chez-register-spec! now accepts both.
- (range 0) / (range 5 5) returned nil instead of the empty seq () — empty
  ranges now match Clojure, so (= () (range 0)) holds.

Suite: async_test 15/20, pipeline_test 7/7, timers_test 2/2, lab_test 2/2.
The five non-passing async_test cases all assert JVM go-machine limitations
jolt's thread-based model is a superset of (the 1024 pending-op cap, parking
ops that must throw outside a go block, expanding-transducer buffer
backpressure) or dispatch-thread identity, not data semantics.

make test green (0 new divergences, +4 range corpus rows), shakesmoke
byte-identical.
2026-06-27 13:05:19 -04:00

3.6 KiB

Clojure libraries known to work with Jolt

Libraries confirmed to load and pass their conformance checks on Jolt. A library listed here works. See the examples, e.g. the ring-app example.

  • aero — EDN configuration with tag literals (#ref/#env/#or/#profile/#long/…)
  • config — environment configuration
  • Selmer — Django-style templates
  • medley — collection utilities
  • cuerdas — string manipulation
  • ring-core — via :deps/root "ring-core", on the ring-app example
  • ring-codec — URL/form encoding
  • ring-defaults — the standard middleware stack (params, static resources + content-type, session, security headers); its session/CSRF crypto comes from jolt-lang/jolt-crypto (OpenSSL)
  • reitit-core — data-driven routing; the reitit.Trie Java class is mirrored by jolt-lang/router.
  • integrant — data-driven system configuration (#ig/ref), with its dependency and meta-merge deps
  • honeysql — SQL formatter and helpers
  • clojure.jdbc — as jolt-lang/db's jdbc.core, over the built-in SQLite access (libsqlite3 via Chez's FFI)
  • next.jdbc — a compatibility layer in jolt-lang/db over jdbc.core
  • tools.logging — runs verbatim over a native clojure.tools.logging.impl stderr backend
  • migratus — database migrations over the next.jdbc layer
  • malli — data schema validation, on the malli-app example.
  • markdown-clj — Markdown → HTML, on the markdown-app example
  • hiccup — HTML from Clojure data, on the hiccup-app example
  • clojure.data.json — JSON reading and writing
  • clojure.spec.alpha — data specs
  • core.match — pattern matching.
  • core.cache — caching (Basic/FIFO/LRU/ LU/TTL/Soft + the wrapped atom API), over data.priority-map.
  • core.memoize — function memoization over core.cache.
  • core.async — CSP channels and go blocks (<!/>!/alts!, pipeline, mult/mix/pub/sub) on real OS threads.
  • core.logic — relational logic programming (unification, run/fresh/conde, finite domains).
  • tick — date/time over Jolt's java.time; #time/… literals via time-literals.
  • transit-jolt — Transit (JSON) read/write