5ae537474b
- Add SCI bootstrap status (317/317 forms, 46 namespaces) - Quick start with git submodule init - Test section, project structure, 22 special forms count - Core library count updated to 145+ bindings
92 lines
3.4 KiB
Markdown
92 lines
3.4 KiB
Markdown
# Jolt
|
|
|
|
A Clojure interpreter running on [Janet](https://janet-lang.org). Jolt reads Clojure source text, evaluates it using an interpreter written in pure Janet, and exposes a Clojure-compatible standard library. The goal is a Janet-hosted [SCI](https://github.com/borkdude/sci) runtime — minimal bootstrapping, with SCI as the standard library.
|
|
|
|
## What's inside
|
|
|
|
Jolt implements the core of Clojure in a single-process Janet project:
|
|
|
|
**Reader** — A recursive descent parser for Clojure syntax: symbols, keywords, numbers, strings, characters, lists, vectors, maps, sets, quote forms, reader macros (`#()`, `#_`, `#?`), metadata, deref, and tagged literals.
|
|
|
|
**Evaluator** — A tree-walking interpreter with 22 special forms (`quote`, `do`, `if`, `def`, `defmacro`, `fn*`, `let*`, `loop*`/`recur`, `throw`, `try`, `set!`, `var`, `locking`, `instance?`, `defmulti`, `defmethod`, `deftype`, `new`, `.`, etc.), syntax-quote with unquote and unquote-splicing, a macro system with `&env` support, destructuring (`:keys` and sequential), and namespace forms (`ns`, `require`, `in-ns`).
|
|
|
|
**Core library** — 145+ bindings from `clojure.core`: predicates, math with Clojure arity semantics, comparison, collections, sequences, higher-order functions, string functions, I/O, atoms, macros (`when`, `when-not`, `if-let`, `when-let`, `if-some`, `when-some`, `doto`, `fn`, `let`, `defn`, `defrecord`, `defprotocol`), and SCI bootstrap stubs.
|
|
|
|
**SCI bootstrap** — All 317 forms from SCI's 9 core source files (`macros`, `protocols`, `types`, `unrestrict`, `vars`, `lang`, `utils`, `namespaces`, `core`) load with zero failures. 46 namespaces are populated with 900+ bindings. SCI's `eval-string` is replaced with a Jolt-native implementation.
|
|
|
|
## Quick start
|
|
|
|
```bash
|
|
git clone https://github.com/yogthos/jolt.git
|
|
cd jolt
|
|
git submodule update --init # pulls vendor/sci
|
|
jpm build # compiles build/jolt
|
|
build/jolt # drops into REPL
|
|
```
|
|
|
|
## Build
|
|
|
|
```
|
|
jpm build
|
|
```
|
|
|
|
This compiles `src/jolt/*.janet` into a standalone `build/jolt` executable. Requires Janet ≥ 1.36 and `jpm`.
|
|
|
|
## Run
|
|
|
|
```
|
|
build/jolt
|
|
```
|
|
|
|
Drops into a read-eval-print loop where you can type Clojure expressions:
|
|
|
|
```
|
|
user=> (+ 1 2)
|
|
3
|
|
user=> (map inc [1 2 3])
|
|
[2 3 4]
|
|
user=> (defn fib [n] (if (< n 2) n (+ (fib (- n 1)) (fib (- n 2)))))
|
|
#'user/fib
|
|
user=> (fib 10)
|
|
55
|
|
```
|
|
|
|
## Test
|
|
|
|
```
|
|
jpm test
|
|
```
|
|
|
|
Runs all tests: API, bootstrap, core, evaluator, macro, namespace, reader, types, and SCI load.
|
|
|
|
## Use as a library
|
|
|
|
```janet
|
|
(use jolt/api)
|
|
|
|
(def ctx (init))
|
|
(eval-string ctx "(+ 1 2)") ;; → 3
|
|
(eval-string ctx "(map inc [1 2 3])") ;; → [2 3 4]
|
|
(eval-string ctx "(def x 42)") ;; → #'user/x
|
|
(eval-string ctx "x") ;; → 42
|
|
```
|
|
|
|
`(init)` returns a context with `clojure.core` loaded. Pass it to `eval-string` to evaluate Clojure source. Each context is isolated — use separate contexts for separate evaluation environments.
|
|
|
|
## Project structure
|
|
|
|
```
|
|
src/jolt/
|
|
types.janet — Var, Namespace, Context, symbol helpers
|
|
reader.janet — recursive descent parser for Clojure syntax
|
|
evaluator.janet — tree-walking interpreter
|
|
core.janet — 145+ clojure.core bindings
|
|
api.janet — public API: init, eval-string, eval-string*
|
|
main.janet — REPL entry point
|
|
test/ — 8 test suites + SCI load test
|
|
vendor/sci/ — SCI submodule (git submodule)
|
|
```
|
|
|
|
## License
|
|
|
|
[Eclipse Public License 1.0](https://opensource.org/licenses/EPL-1.0)
|