A MoonBit parsing toolkit for two user workflows: composing parsers with nom-like combinators, or turning .g4 grammars into generated parseable packages.

• Rust nom–shaped combinators — tag, take_while, many0, many1, alt, pair, preceded, terminated, delimited, opt, verify, map, map_res, separated_list0/1, and more
• ANTLR CLI workflow — run parkit generate antlr ./hello.g4, import the generated package, and call @hello.parse(...)
• Evidence-driven compatibility — repository-managed fixtures, snapshots, suite catalogs, and CI-backed contract tests
• Cross-language validation — Rust nom reference tests and benchmarks keep the combinator surface honest
• MoonBit-native workflow — make ci drives format, static checks, and tests across MoonBit and Rust reference code

The original parkit surface: a nom-like combinator toolkit for directly composing parsers in MoonBit.

The user-facing flow is straightforward: write a .g4, run parkit generate antlr, import the generated package, and call parse in normal MoonBit code.

See the package guide: src/antlr/READMD.md

src/
  nom/            — the parkit parser combinator library (cogna-dev/parkit/nom)
  antlr/          — frontend, runtime, CST, typed CST, fixtures, and specs
examples/
  antlr/          — generated-package ANTLR sample built with `parkit generate antlr --out`
  json/           — JSON parser sample built with parkit (not published to mooncakes)
  benchmark/      — MoonBit benchmarks (not published to mooncakes)
reference/
  nom-json/       — Rust nom reference JSON parser (cross-language validation + benchmarks)

// Tag: match an exact string
let p = @nom.tag("hello")
assert_eq!(p.parse("hello world"), Ok((" world", "hello")))

// many0: repeat zero or more times
let nums = @nom.many0(@nom.digit1())
assert_eq!(nums.parse("123 456"), Ok((" 456", ["123"])))

// JSON parsing
let json = @json.parse("{\"key\": 42}")
// => Ok(Object([("key", Number(42.0))]))

The shortest path on the ANTLR side is:

1. Write a normal .g4 grammar.
2. Run parkit generate antlr ./hello.g4 --out ./src/hello.
3. Import the generated package with an alias such as @hello.
4. Call @hello.parse(...) and use typed fields such as fields.id_token.lexeme.

The full end-to-end guide lives in src/antlr/READMD.md. A checked-in sample project lives in examples/antlr/app/main.mbt and its grammar source in examples/antlr/grammar/hello.g4. The deeper design and contract documents stay indexed in src/antlr/spec/README.md.

moon test --manifest-path moon.work

make format        # rewrite MoonBit and Rust formatting in place
make format-check  # verify formatting without changing files
make lint          # MoonBit static checks plus Rust compile checks
make test          # MoonBit workspace tests plus Rust reference tests
make ci            # format-check, lint, then test

# MoonBit benchmarks (native target)
moon bench --manifest-path moon.work --target native

# Rust criterion benchmarks
cargo bench --manifest-path reference/nom-json/Cargo.toml

Benchmarks run on ubuntu-latest. MoonBit targets the native backend; Rust uses criterion.rs with a native release build. Both use the same 3-object JSON array input.

Note: The performance difference reflects the overhead of MoonBit's runtime and memory model compared to Rust's zero-cost abstractions, not algorithmic differences — both parsers implement the same combinator logic and produce identical results.

MoonBit native benchmark details:

reference/nom-json/ contains an equivalent JSON parser built with Rust nom 8. The test suite in reference/nom-json/src/lib.rs mirrors every case in examples/json/json_test.mbt, ensuring both implementations produce the same result for every input.

cargo test --manifest-path reference/nom-json/Cargo.toml

1. ECMA-404 JSON specification
2. nom — Rust parser combinator library
3. criterion.rs — Rust benchmarking library
4. MoonBit benchmarks documentation

Apache-2.0