Phase 10: Standard Library — clojure.string, clojure.set, clojure.walk
- src/jolt/clojure/string.clj (123 lines, 20 functions): blank?, capitalize, lower-case, upper-case, includes?, join, replace, replace-first, str-reverse, split, starts-with?, ends-with?, trim, triml, trimr, trim-newline, escape, index-of, last-index-of - src/jolt/clojure/set.clj (124 lines, 10 operations): union, intersection, difference, select, project, rename, rename-keys, map-invert, join, index, subset?, superset? - src/jolt/clojure/walk.clj (77 lines, 9 functions): walk, postwalk, prewalk, postwalk-demo, prewalk-demo, postwalk-replace, prewalk-replace, keywordize-keys, stringify-keys, macroexpand-all - src/jolt/core.janet: 11 Janet string interop bindings (str-trim, str-upper, str-lower, str-find, str-replace, str-replace-all, str-reverse-b, str-join, str-split, str-triml, str-trimr) - test/phase10-test.janet: 2 test sections (40-41) 15+ assertions covering string and set functions - All .clj files use eval-form for multi-form loading - 315 ok, 2 fail (pre-existing, unchanged)
This commit is contained in:
Yogthos
parent
e63c2ce8d5
commit
fdb0f4ab83
10 changed files with 518 additions and 77 deletions
|
|
@ -1,7 +1,9 @@
|
|||
Build: `jpm test` runs all tests; `janet test/<file>.janet` runs single. Source in `src/jolt/`, tests in `test/`. Entry: `src/jolt/main.janet`. Key files: compiler.janet (848L, 2-phase analyze→emit), evaluator.janet (interpreter with 21 special forms), core.janet (~130 Clojure core fns), types.janet (Var/Namespace/Context), reader.janet (parser), phm.janet (PersistentHashMap + LazySeq + PersistentHashSet), api.janet (public API + compile? dispatch), loader.janet (file loading).
|
||||
§
|
||||
Architecture: Two eval modes — compile (`:compile? true`) uses analyze-form→emit-expr→Janet eval; interpreter mode uses tree-walking evaluator.janet. Stateful forms (defmacro, ns, deftype, defmulti, defmethod, syntax-quote, set!, var, ., new) always fall back to interpreter. Macros expand at analyze time. Core fns resolved to actual Janet function values via `core-fn-values` table for direct eval.
|
||||
§
|
||||
Compile-mode eval path: `compile-and-eval` → `compile-ast` (emits Janet data structures with resolved fn values) → Janet `eval`. Source-to-source `compile-form` exists for debugging but NOT used by compile-and-eval. `compile-and-eval` interns def/defn results in Jolt namespace so interpreter can resolve them later.
|
||||
§
|
||||
REPL: `main.janet` initializes context and sets current ns to "user". `print-value` renders scalars inline (prin) and collections via `print-collection` which recursively calls print-value for nested rendering. Collections: tuples→[v1 v2], arrays→(v1 v2), structs→{k v}, deftype tables→{k v} (filtering :jolt/deftype :cnt :buckets :_meta :jolt/type :phm), sets→#{v}. Jolt symbol structs render as `name` or `ns/name`.
|
||||
§
|
||||
REPL collection rendering: print-value in main.janet uses cond with print-value→print-collection mutual recursion (needs forward var declaration). Tuples→[v1 v2], arrays→(v1 v2), structs→{k v}, sets→#{v}, keywords→:kw, symbols→name or ns/name. Use prin for scalars, print only after collection closing bracket. REPL starts in wrong ns after loading persistent structures — must ctx-set-current-ns to "user" after init.
|
||||
§
|
||||
fn* special form dispatch: fn* form emitted by macros MUST be @[...] (array) to enter eval-list's special form match. If wrapped in [...] (tuple), eval-form hits the (tuple? form) branch which maps over items instead of dispatching fn*. Same applies to register-method, protocol-dispatch, and other special form calls emitted by macros — all must be array-wrapped.
|
||||
§
|
||||
Janet's struct? returns true for tuples — cond forms in print-value/eval-form MUST check (tuple? x) before (struct? x) or (get x :key). Otherwise Janet sees a tuple, says yes to struct?, and calls (get tuple :name) which fails with "expected integer key for tuple in range [0, N), got :name". This hit us in print-value rendering and eval-form struct handling.
|
||||
§
|
||||
Protocol system: Type registry in context env (:type-registry) maps type-tag→proto-name→method-name→fn. Three dispatch special forms: protocol-dispatch (resolves method via registry or reified methods), register-method (stores impl in registry), make-reified (creates anonymous object with :jolt/protocol-methods). fn* forms emitted by extend-type/extend-protocol MUST be @[...] (array) for eval-list dispatch. Protocols are maps with :jolt/type :jolt/protocol and :methods map.
|
||||
|
|
|
|||
|
|
@ -1,7 +1,5 @@
|
|||
Janet `break` does NOT work inside `let` — it only breaks from loops (`while`, `loop`). When searching for a key in a bucket and needing to return a value, use `(var found nil)` + `(set found val) (break)` pattern then check `found` after the loop. Same for `break nil` in bucket-dissoc: capture index in a var, break, then construct result after loop.
|
||||
§
|
||||
Keywords containing `#` (like `:#inst`, `:#uuid`) are invalid Janet literal syntax. Use dynamic table construction: `(let [dr @{}] (put dr (keyword "#inst") fn) dr)` instead of `@{:#inst fn}`. This hit us in types.janet make-ctx :data-readers initialization.
|
||||
§
|
||||
PHM/Set internal metadata keys (`:jolt/deftype`, `:cnt`, `:buckets`, `:_meta`, `:jolt/type`, `:phm`) leak into `pairs`/`keys` iteration. Must filter them in core fns like merge, merge-with, keys, vals, and in print-rendering code. `core-merge` without filtering produced corrupted PHMs with metadata as entries. Commit `9c44021` fixed this for merge; `c366963` for print-value.
|
||||
§
|
||||
Janet's `case` for multi-arity dispatch: `(defn f [& args] (case (length args) 1 ... 2 ...))`. Used in core-derive, core-isa?, core-ancestors, core-descendants because Janet doesn't support Clojure-style `([arg1] body1) ([arg1 arg2] body2)` multi-arity defn syntax.
|
||||
§
|
||||
Janet's boolean function doesn't exist — use (if x true false). Janet's defn doesn't support Clojure-style multi-arity syntax ([args] body) — use [& args] with case (length args) dispatch. fn? exists as Janet builtin (not Jolt core fn) — use (or (function? x) (cfunction? x)) in tests.
|
||||
§
|
||||
Janet's `cond` treats the last position as a test clause, NOT a catch-all body. A bare expression like `(push-str buf val)` in the last position runs as a test (always truthy, but executed for side effects between other cond clauses). Use `true (push-str buf val)` to make it a proper catch-all body. Hit us in buffer-based write-value — raw tuple addresses leaked into output because `(push-str buf (string v))` ran as a test clause between other branches.
|
||||
|
|
|
|||
|
|
@ -1,69 +1,71 @@
|
|||
{
|
||||
"jolt-dev": {
|
||||
"created_by": "agent",
|
||||
"use_count": 35,
|
||||
"view_count": 62,
|
||||
"patch_count": 42,
|
||||
"last_used_at": "2026-06-03T03:49:43.510599+00:00",
|
||||
"last_viewed_at": "2026-06-03T04:20:32.579847+00:00",
|
||||
"last_patched_at": "2026-06-03T03:34:09.007253+00:00",
|
||||
"created_at": "2026-06-01T21:26:06.614465+00:00",
|
||||
"state": "active",
|
||||
"pinned": false
|
||||
},
|
||||
"jolt-compiler": {
|
||||
"created_by": "agent",
|
||||
"use_count": 9,
|
||||
"view_count": 25,
|
||||
"use_count": 10,
|
||||
"view_count": 128,
|
||||
"patch_count": 9,
|
||||
"last_used_at": "2026-06-03T03:49:43.470444+00:00",
|
||||
"last_viewed_at": "2026-06-03T04:20:32.574065+00:00",
|
||||
"last_used_at": "2026-06-03T13:32:50.977662+00:00",
|
||||
"last_viewed_at": "2026-06-03T14:12:07.880363+00:00",
|
||||
"last_patched_at": "2026-06-03T03:03:27.524946+00:00",
|
||||
"created_at": "2026-06-02T17:54:38.690279+00:00",
|
||||
"state": "active",
|
||||
"pinned": false
|
||||
},
|
||||
"jpm-build": {
|
||||
"created_by": "agent",
|
||||
"use_count": 0,
|
||||
"view_count": 27,
|
||||
"patch_count": 0,
|
||||
"last_viewed_at": "2026-06-03T04:20:32.597461+00:00",
|
||||
"created_at": "2026-06-01T20:56:39.144222+00:00",
|
||||
"state": "active",
|
||||
"pinned": false
|
||||
},
|
||||
"jolt-bootstrap": {
|
||||
"created_by": "agent",
|
||||
"use_count": 9,
|
||||
"view_count": 36,
|
||||
"patch_count": 10,
|
||||
"last_used_at": "2026-06-02T18:45:23.336653+00:00",
|
||||
"last_viewed_at": "2026-06-03T04:20:32.567542+00:00",
|
||||
"last_patched_at": "2026-06-02T03:44:45.935676+00:00",
|
||||
"created_at": "2026-06-01T21:49:51.101718+00:00",
|
||||
"state": "active",
|
||||
"pinned": false
|
||||
},
|
||||
"jolt-gotchas": {
|
||||
"created_by": "agent",
|
||||
"use_count": 0,
|
||||
"view_count": 11,
|
||||
"patch_count": 0,
|
||||
"last_viewed_at": "2026-06-03T04:20:32.585916+00:00",
|
||||
"created_at": "2026-06-03T03:50:41.474730+00:00",
|
||||
"state": "active",
|
||||
"pinned": false
|
||||
},
|
||||
"jolt-persistent-structures": {
|
||||
"created_by": "agent",
|
||||
"use_count": 1,
|
||||
"view_count": 13,
|
||||
"view_count": 115,
|
||||
"patch_count": 0,
|
||||
"last_used_at": "2026-06-03T03:49:43.520839+00:00",
|
||||
"last_viewed_at": "2026-06-03T04:20:32.591070+00:00",
|
||||
"last_viewed_at": "2026-06-03T14:12:07.898607+00:00",
|
||||
"created_at": "2026-06-03T03:35:04.130959+00:00",
|
||||
"state": "active",
|
||||
"pinned": false
|
||||
},
|
||||
"jolt-gotchas": {
|
||||
"created_by": "agent",
|
||||
"use_count": 3,
|
||||
"view_count": 116,
|
||||
"patch_count": 3,
|
||||
"last_used_at": "2026-06-03T13:35:01.902830+00:00",
|
||||
"last_viewed_at": "2026-06-03T14:12:07.892405+00:00",
|
||||
"last_patched_at": "2026-06-03T13:35:14.859032+00:00",
|
||||
"created_at": "2026-06-03T03:50:41.474730+00:00",
|
||||
"state": "active",
|
||||
"pinned": false
|
||||
},
|
||||
"jolt-bootstrap": {
|
||||
"created_by": "agent",
|
||||
"use_count": 9,
|
||||
"view_count": 138,
|
||||
"patch_count": 10,
|
||||
"last_used_at": "2026-06-02T18:45:23.336653+00:00",
|
||||
"last_viewed_at": "2026-06-03T14:12:07.874318+00:00",
|
||||
"last_patched_at": "2026-06-02T03:44:45.935676+00:00",
|
||||
"created_at": "2026-06-01T21:49:51.101718+00:00",
|
||||
"state": "active",
|
||||
"pinned": false
|
||||
},
|
||||
"jpm-build": {
|
||||
"created_by": "agent",
|
||||
"use_count": 0,
|
||||
"view_count": 129,
|
||||
"patch_count": 0,
|
||||
"last_viewed_at": "2026-06-03T14:12:07.904433+00:00",
|
||||
"created_at": "2026-06-01T20:56:39.144222+00:00",
|
||||
"state": "active",
|
||||
"pinned": false
|
||||
},
|
||||
"jolt-dev": {
|
||||
"created_by": "agent",
|
||||
"use_count": 37,
|
||||
"view_count": 166,
|
||||
"patch_count": 44,
|
||||
"last_used_at": "2026-06-03T13:32:50.995757+00:00",
|
||||
"last_viewed_at": "2026-06-03T14:12:07.886018+00:00",
|
||||
"last_patched_at": "2026-06-03T13:34:25.654327+00:00",
|
||||
"created_at": "2026-06-01T21:26:06.614465+00:00",
|
||||
"state": "active",
|
||||
"pinned": false
|
||||
}
|
||||
}
|
||||
|
|
@ -1,4 +1,8 @@
|
|||
# jolt-dev
|
||||
---
|
||||
name: jolt-dev
|
||||
description: Jolt development workflow — build, test, special form patterns, Janet gotchas
|
||||
---
|
||||
|
||||
# jolt-dev
|
||||
|
||||
Jolt development workflow — build, test, special form patterns, Janet gotchas
|
||||
|
|
@ -20,14 +24,14 @@ To add a new special form to the evaluator:
|
|||
|
||||
1. Add the name to `special-symbol?` in `src/jolt/evaluator.janet`
|
||||
2. Add a match arm in `eval-list` (the match on `name`)
|
||||
3. Add tests in `test/evaluator-test.janet`
|
||||
3. Add tests
|
||||
|
||||
The match arm receives `ctx`, `bindings`, and `form` (the full list). Use `(in form 1)` for first arg, etc.
|
||||
|
||||
**Non-symbol heads** (keywords, etc.): `eval-list` first checks `(and (struct? first-form) (= :symbol (...)))` before extracting `name`. If not a symbol, falls through to default function application.
|
||||
|
||||
### Current special forms (29):
|
||||
`quote`, `syntax-quote`, `unquote`, `unquote-splicing`, `do`, `if`, `def`, `defmacro`, `fn*`, `let*`, `loop*`, `recur`, `throw`, `try`, `set!`, `var`, `locking`, `instance?`, `defmulti`, `defmethod`, `deftype`, `new`, `.`, `var-get`, `var-set`, `var?`, `alter-var-root`, `find-var`, `intern`, `alter-meta!`, `reset-meta!`, `disj`, `set?`
|
||||
### Current special forms (37):
|
||||
`quote`, `syntax-quote`, `unquote`, `unquote-splicing`, `do`, `if`, `def`, `defmacro`, `fn*`, `let*`, `loop*`, `recur`, `throw`, `try`, `set!`, `var`, `locking`, `instance?`, `defmulti`, `defmethod`, `deftype`, `new`, `.`, `var-get`, `var-set`, `var?`, `alter-var-root`, `find-var`, `intern`, `alter-meta!`, `reset-meta!`, `disj`, `set?`, `protocol-dispatch`, `register-method`, `make-reified`, `satisfies?`
|
||||
|
||||
## Compiler Architecture
|
||||
|
||||
|
|
@ -37,6 +41,40 @@ Two-phase: `analyze-form [form bindings ctx]` → `emit-ast` (string) or `emit-e
|
|||
|
||||
**eval-string dispatch** (compile mode): stateful forms → interpreter; everything else → `compile-and-eval`. Macros expand at analyze time.
|
||||
|
||||
## Protocol System
|
||||
|
||||
Protocols are maps with `:jolt/type :jolt/protocol` and `:methods` map.
|
||||
Type registry in context env (`:type-registry`) maps `type-tag → proto-name → method-name → fn`.
|
||||
|
||||
**Special forms:**
|
||||
- `protocol-dispatch [proto-sym method-sym obj rest-args]` — resolves method via type registry or reified methods
|
||||
- `register-method [type-sym proto-sym method-sym fn-form]` — stores impl in type registry
|
||||
- `make-reified [proto-sym methods-map]` — creates anonymous object with `:jolt/protocol-methods`
|
||||
|
||||
**Critical rule:** fn* form inside extend-type/extend-protocol MUST be `@[...]` (array) to trigger eval-list's special form dispatch. Tuples `[...]` hit `(tuple? form)` branch instead. Same for register-method, protocol-dispatch calls.
|
||||
|
||||
## REPL Collection Rendering (Buffer-Based)
|
||||
|
||||
Use `write-value` + `write-collection` with a StringBuffer (`@""`) rather than `prin`/`print` directly. Build the entire output string in a buffer, then atomically `(print (string buf))`. Prevents Janet's C runtime (in `jpm build` executables) from interleaving its native `<tuple 0x...>` printer between incremental `prin` calls.
|
||||
|
||||
```janet
|
||||
(var write-value nil) ; forward declaration
|
||||
|
||||
(defn- write-collection [v buf]
|
||||
(cond (tuple? v) (do (buffer/push-string buf "[") ...)
|
||||
(array? v) (do (buffer/push-string buf "(") ...) ...))
|
||||
|
||||
(set write-value (fn [v buf]
|
||||
(cond (nil? v) (buffer/push-string buf "nil")
|
||||
(number? v) (buffer/push-string buf (string v))
|
||||
(tuple? v) (write-collection v buf)
|
||||
true (buffer/push-string buf (string v))))) ; true REQUIRED
|
||||
|
||||
(defn print-value [v] (def buf @"") (write-value v buf) (print (string buf)))
|
||||
```
|
||||
|
||||
**Critical:** Janet's `cond` treats a bare expression in the last position as a **test** clause, not a catch-all body. Use `true` as the guard.
|
||||
|
||||
## PersistentHashMap Gotchas
|
||||
|
||||
- `core-map?`: `(if (and (table? x) (get x :jolt/deftype)) true false)` — `and` returns last truthy, not boolean
|
||||
|
|
@ -45,9 +83,9 @@ Two-phase: `analyze-form [form bindings ctx]` → `emit-ast` (string) or `emit-e
|
|||
|
||||
## defrecord / deftype Patterns
|
||||
|
||||
- defrecord emits `(deftype TypeName [fields])` + arrow factory `(fn fields-vec (TypeName. field1 field2...))`
|
||||
- defrecord emits `(deftype TypeName [fields])` + arrow factory
|
||||
- Records are tables with `:jolt/deftype` = type name string
|
||||
- `set!` field mutation: `(set! (.-x obj) val)` parses as array with `.-x` symbol head — check symbol name before dispatch
|
||||
- `set!` field mutation: `(set! (.-x obj) val)` parses as array with `.-x` symbol head
|
||||
|
||||
## Binding Macro
|
||||
|
||||
|
|
@ -55,22 +93,20 @@ Uses `array-map` (plain Janet struct) not `hash-map` (PHM) to avoid PHM get() in
|
|||
|
||||
## Tagged Literals (#inst, #uuid)
|
||||
|
||||
`:#inst` is invalid Janet keyword syntax (contains `#`). Use dynamic table construction:
|
||||
```janet
|
||||
(let [dr @{}] (put dr (keyword "#inst") (fn [s] s)) dr)
|
||||
```
|
||||
Use dynamic table construction: `(let [dr @{}] (put dr (keyword "#inst") fn) dr)`
|
||||
|
||||
## LazySeq Patterns
|
||||
|
||||
- Use `indexed?` not `tuple?` for realized sequences (may be arrays from `cons`/`concat`)
|
||||
- Avoid `val'` (apostrophe in symbol names) — causes Janet parse errors; use `vf` instead
|
||||
- `ls-first`/`ls-rest`/`ls-seq` all call `realize-ls` first (caches result, realizes once)
|
||||
- Avoid `val'` (apostrophe in symbol names) — use `vf` instead
|
||||
|
||||
## Janet Gotchas
|
||||
|
||||
- `def` creates constants; use `(var x nil)` for mutable locals
|
||||
- Bare tuples in `eval` are function calls: `[1 2 3]` tries to call `1`. Use `['tuple 1 2 3]`
|
||||
- Bare tuples in `eval` are function calls: `[1 2 3]` tries to call `1`
|
||||
- `try` format: `(try body ([err] handler))` NOT `(try body (catch sym handler))`
|
||||
- core-renames MUST match actual fn names: `"-"` → `"core-sub"` (not `"core--"`)
|
||||
- Janet `parse` vs `parser/new`: use `parser/new` + `parser/consume` + `parser/eof` + `parser/produce` for full source parsing
|
||||
- `(break val)` breaks from a while loop returning val — useful in bucket search patterns
|
||||
- `(break val)` breaks from loop returning val — useful in bucket search patterns
|
||||
- `boolean` doesn't exist — use `(if x true false)`
|
||||
- Janet doesn't support Clojure-style multi-arity defn — use `[& args]` with `case (length args)`
|
||||
- Janet's `cond` treats bare expression in last position as test, not catch-all — use `true` guard
|
||||
|
|
@ -43,3 +43,26 @@ Both tables must be updated together when adding core fns. Missing entries = sil
|
|||
## `set!` Field Mutation Reader Quirk
|
||||
|
||||
`(set! (.-x obj) val)` parses as array with `.-x` symbol head — not as standalone `.-x` symbol. Check for this case before the `(. obj -field)` shorthand.
|
||||
|
||||
## Janet `cond` Requires `true` Guard for Catch-All
|
||||
|
||||
A bare expression in the last position of `cond` is treated as a **test** clause (not body). Use `true` as the test:
|
||||
|
||||
```janet
|
||||
(cond (nil? x) (buf "nil") (number? x) (buf (string x)) true (buf (string x)))
|
||||
```
|
||||
|
||||
Without `true`, the last expression executes as a side-effect test between branches. Hit us in buffer-based write-value — raw tuple addresses leaked into REPL output.
|
||||
|
||||
## Janet `cond` Requires `true` Guard for Catch-All
|
||||
|
||||
A bare expression in the last position of `cond` is treated as a **test** clause (not body). It executes between other branches as a side-effect test. Use `true` as the test to make it a proper catch-all:
|
||||
|
||||
```janet
|
||||
(cond
|
||||
(nil? x) (buf "nil")
|
||||
(number? x) (buf (string x))
|
||||
true (buf (string x))) ; ← `true` required
|
||||
```
|
||||
|
||||
Without `true`, `(push-str buf (string v))` in the last position leaked raw tuple addresses into REPL output.
|
||||
Loading…
Add table
Add a link
Reference in a new issue