effect-grammar 0.3.0 → 0.5.0

package/README.md

@@ -1,255 +1,194 @@
 # effect-grammar
 
-Invertible grammar combinators and parser-printers for Effect.
-
-Schema models your structured data. `effect-grammar` models the text formats
-inside your strings: connection strings, duration strings (`1h30m`), cron
-expressions, search queries, or DSLs.
-
-You write the grammar definition once. You get four outputs:
-
-- **A parser.** Reads text and outputs structured data, with line and column
-  error messages.
-- **A printer.** Converts structured data back to canonical text.
-- **A `Schema.Codec<A, string>`.** Decoding parses, encoding prints, and Schema
-  refinements compose.
-- **A text renderer.** Formats the grammar as readable text, for documentation
-  and schema descriptions.
-
-## Why effect-grammar?
-
-`Schema.transformOrFail` makes you write and maintain both directions by hand.
-`Schema.TemplateLiteralParser` only handles flat `${a}-${b}` patterns.
-`effect-grammar` derives both directions for you. It handles optional parts,
-repetition, alternation, recursion, and parts that depend on earlier parts.
-
-This is for format strings, not documents. The parser backtracks. There is no
-memoization and no left recursion. Printing is canonical, not pretty.
+Write a grammar once, then use it to parse text, print values, or derive an
+Effect Schema codec. Grammars are bidirectional by design, with explicit
+round-trip checking when you need an invertibility guarantee.
 
 ## Install
 
-```bash
-pnpm add effect-grammar
-```
-
-Requires Effect `4.0.0-rc.112` or newer in the Effect 4 line.
-
-## A grammar
-
-```ts
-import * as Grammar from "effect-grammar"
-
-const endpoint = Grammar.gen(function* () {
-  yield* Grammar.literal("https://")
-  const host = yield* Grammar.regex(/[^:/?#]+/, "host")
-  const port = yield* Grammar.optional(Grammar.prefix(":", Grammar.integer))
-  return { host, port }
-})
-
-Grammar.parse(endpoint, "https://effect.website:8080")
-// Result.succeed({ host: "effect.website", port: 8080 })
-
-Grammar.parse(endpoint, "https://effect.website:abc")
-// Result.fail(ParseError: line 1, column 24: expected integer, found "a")
-
-Grammar.print(endpoint, { host: "effect.website", port: 443 })
-// Result.succeed("https://effect.website:443")
+`effect` is a peer dependency:
 
-Grammar.render(endpoint)
-// "https://" host:<host> port:(":" <integer>)?
+```sh
+npm install effect effect-grammar
 ```
 
-`gen` runs the generator once, when you build the grammar. Nothing is parsed
-yet.
-
-Inside the generator, `yield*` on a value grammar does not give you a value. It
-gives you a `Ref<A>`: a stand-in for the value that will exist at parse and
-print time. `yield*` on a silent grammar, such as `literal` or `symbol`, gives
-nothing back. Silent grammars carry no value.
-
-The generator's return value is a pattern over those refs. It can be a bare ref,
-an object, an array, or constants around them. Parsing fills the pattern in.
-Printing reads each ref back out of the value you hand it. That is what makes
-the grammar invertible.
+## Quick start
 
 ```ts
-const nested = Grammar.gen(function* () {
-  const host = yield* Grammar.regex(/[^:]+/, "host")
-  yield* Grammar.literal(":")
-  const port = yield* Grammar.integer
-  return { kind: "endpoint", address: { host, port } } as const
-})
-// Grammar<{ kind: "endpoint"; address: { host: string; port: number } }>
-```
-
-## The one rule
-
-Every binding must appear in the return pattern exactly once. `gen` throws at
-build time if one does not. A binding the return does not hold is a value the
-printer could not print.
-
-To parse something and then drop it, wrap it with `skip`. The grammar prints its
-canonical form instead.
-
-## Refs are not values
-
-A ref is a stand-in, so JavaScript cannot look inside it. Comparing a ref with
-`===` is a type error. Interpolating one into a string throws.
-
-Branching on a ref is `match`, described below. For everything else there are
-small helpers: `defaulted` supplies a value when a part is absent.
-`get(ref, key)` reads a property of a ref, including reserved names such as
-`then` and `toJSON`.
-
-## Depending on an earlier part
-
-`match` picks a grammar based on an earlier binding. The printer runs the same
-choice backwards.
-
-```ts
-const tagged = Grammar.gen(function* () {
-  const kind = yield* Grammar.choice(
-    Grammar.literal("n:").pipe(Grammar.as("num")),
-    Grammar.literal("w:").pipe(Grammar.as("word")),
-  )
-  const value = yield* Grammar.match(kind, {
-    num: Grammar.integer,
-    word: Grammar.regex(/[a-z]+/, "word"),
-  })
-  return { kind, value }
-})
-// parses "n:12"  →  { kind: "num", value: 12 }
-```
-
-`match` requires the cases to cover every literal of the selector's type.
-`matchValue` is the same idea with number or mixed literal keys. Keys keep their
-type, so `1` and `"1"` are distinct cases.
-
-A property of a ref is a ref to that property. A header parsed by one grammar
-can steer the body of another:
-
-```ts
-const frame = Grammar.gen(function* () {
-  const header = yield* headerGrammar // { kind: "text" | "bin"; size: number }
-  yield* Grammar.literal(":")
-  const body = yield* Grammar.match(header.kind, {
-    text: Grammar.take(header.size),
-    bin: Grammar.repeat(Grammar.regex(/[01]/, "bit"), header.size),
-  })
-  return { header, body }
+import { Schema } from "effect"
+import * as G from "effect-grammar"
+
+const endpoint = G.gen(function* () {
+  yield* G.literal("https://")
+  const host = yield* G.regex(/[^:/?#]+/, "host")
+  yield* G.literal(":")
+  const port = yield* G.integer
+  return { host, port }
 })
-```
 
-`take(n)` reads exactly `n` characters (UTF-16 code units). `repeat(g, n)` reads
-exactly `n` repetitions. The count is a value like any other: return it, and
-printing reads it back. A netstring is:
-
-```ts
-const netstring = Grammar.gen(function* () {
-  const length = yield* Grammar.integer
-  yield* Grammar.literal(":")
-  const payload = yield* Grammar.take(length)
-  yield* Grammar.literal(",")
-  return { length, payload }
-})
-// "5:hello,"  ⇄  { length: 5, payload: "hello" }
-```
-
-`seq(...silents)` builds a silent sequence.
-
-## Values and alternatives
-
-`transform` maps between two types, in both directions. Write plain functions.
-If a callback throws, the grammar fails cleanly. Use `transformOrFail` when a
-direction should return a `Result` instead:
-
-```ts
-const jsonString = Grammar.regex(/"(?:[^"\\]|\\.)*"/, "string").pipe(
-  Grammar.transformOrFail({
-    decode: (text) =>
-      Result.try({
-        try: () => JSON.parse(text),
-        catch: (error) => ({ message: String(error) }),
-      }),
-    encode: (value) => Result.succeed(JSON.stringify(value)),
+const Endpoint = G.codec(
+  endpoint,
+  Schema.Struct({
+    host: Schema.NonEmptyString,
+    port: Schema.Int,
   }),
 )
-```
 
-`decodeTo` checks the value against a Schema on parse and on print. `as` turns a
-silent grammar into a constant. `flag` turns presence into a boolean.
+Schema.decodeSync(Endpoint)("https://effect.website:443")
+// { host: "effect.website", port: 443 }
 
-`choice` tries its options in order and backtracks. It has one round-trip rule:
-the text printed for a branch must not parse as a different value through an
-earlier branch. `taggedChoice` records the chosen branch in the result.
-
-```ts
-const value = Grammar.taggedChoice("kind", {
-  number: Grammar.integer,
-  word: Grammar.regex(/[a-z]+/, "word"),
-})
-// parses "12"      →  { kind: "number", value: 12 }
-// prints the same  →  "12"
+Schema.encodeSync(Endpoint)({ host: "effect.website", port: 443 })
+// "https://effect.website:443"
 ```
 
-Recursion uses `suspend`:
+## Operations
+
+- `parse(grammar, text)` interprets from cursor zero and succeeds only after
+  consuming the whole string.
+- `print(grammar, value)` runs the grammar's printer. It validates local printer
+  requirements but does not verify that the result parses back to the same
+  value.
+- `printChecked(grammar, value)` prints, reparses the whole output, and compares
+  the result with Effect's equality. It fails when that value round trip does
+  not hold.
+- `prepare(grammar)` runs the library's static validation once, then returns
+  `parse`, `print`, and `printChecked` functions bound to the grammar, plus its
+  rendering and fidelity audit. It is not compilation or optimization; runtime
+  failures remain possible.
+- `codec(grammar, schema)` creates an Effect Schema codec. Encoding uses checked
+  printing by default; `{ roundTrip: "off" }` selects unchecked printing.
+
+`regex(re, name)` stores the source and flags without `g` or `y`. During parsing
+it uses a fresh sticky matcher at the current cursor, so `^`, `$`, lookarounds,
+and flags retain JavaScript `RegExp` semantics relative to the original full
+input. Printing requires the value itself to be a string matched in full. The
+caller's `RegExp` and `lastIndex` are not mutated.
+
+## Composition and correctness
+
+`choice` parses branches in order and prints with the first printer that accepts
+the value. `checkedChoice` uses the first accepting branch whose produced text
+reparses to an equal value. `choiceOn(tag, cases)` instead dispatches printing
+from an existing discriminant field; parsing is still ordered and can remain
+ambiguous. `taggedChoice(tag, cases)` wraps each branch's value as
+`{ [tag]: key, value }` and dispatches by that generated tag.
+`literals(...strings)` is a choice of strings whose value is the string that
+matched. It tries longer strings first, so `literals(">", ">=")` still reads
+`>=`.
+
+For explicit branch order or number/boolean discriminants, use
+`choiceOnEntries(tag, entries)` with an array of `[key, grammar]` entries.
+`choiceOn` and `taggedChoice` reject JavaScript array-index keys because object
+enumeration can reorder them.
+
+`gen` result objects are exact printer patterns: printing rejects missing,
+extra, symbol, or otherwise unexpected own keys. Arrays must have exactly the
+expected length.
+
+`many`, `sepBy`, and exact `repeat` require every successfully parsed item to
+advance the cursor; zero-width items fail rather than loop. `validate`/`prepare`
+report repetitions whose item can be proved to match empty input, but validation
+is intentionally not a proof of all behavior.
+
+`take(count)` reads a fixed number of UTF-16 code units and
+`repeat(item, count)` a fixed number of items; the count is a number or a ref
+bound earlier in the same `gen`. `lengthPrefixed(length)` and
+`countPrefixed(item, count)` parse a prefix and then that many UTF-16 code units
+or items, and derive the prefix from the value when printing, so the value does
+not carry it. `filter(predicate, name)` keeps a grammar's value only when the
+predicate accepts it, in both directions.
+
+`merge(...parts)` sequences grammars that produce objects and flattens their
+fields into one object. Each part must have statically known fields: a `struct`,
+a `gen` that returns an object, another `merge`, `Binary.bits`, or a `filter`
+over any of these. A general transform is rejected, because its fields cannot be
+known. Printing splits the value by those fields, so errors keep flat paths.
+Duplicate fields are rejected on construction.
+
+`suspend(() => grammar)` enables recursive definitions. Its thunk is evaluated
+lazily on first resolution and the resolved grammar is cached. Direct left
+recursion at the same parse position and recursive printing that does not
+consume a value are rejected; recursive grammars must be productive.
+
+Transforms state different fidelity intentions:
+
+- `transform` and `transformOrFail` make no inverse claim.
+- `iso` records the author's inverse claim; the library does not prove it.
+- `partialIso` records a fallible pair intended to agree where both directions
+  succeed.
+- `auditFidelity` lists transforms without a full inverse claim; an empty list
+  is not proof of a round trip.
+
+Use `printChecked` or the helpers from `effect-grammar/testing` to test the
+values and accepted texts relevant to your grammar. These are properties to
+verify, not laws guaranteed for every grammar.
+
+## Binary
+
+`effect-grammar/Binary` applies the same grammars to a `Uint8Array`. Bytes pass
+through the engine as a binary string with one code unit per byte, so every core
+combinator composes with the byte-oriented ones.
 
 ```ts
-const jsonValue: Grammar.Grammar<Json> = Grammar.suspend(
-  () =>
-    Grammar.choice(
-      jsonNull,
-      jsonBool,
-      jsonNumber,
-      jsonString,
-      jsonArray,
-      jsonObject,
-    ),
-  "value",
-)
-```
-
-See `examples/` for JSON, Scheme, a Postgres DSN, netstrings, a wire protocol,
-and GitHub's search syntax.
-
-## Products, delimiters, and trivia
-
-`struct` and `tuple` build products without a generator. Their staged form is
-the same as what `gen` builds.
-
-Delimiter combinators work data-first and data-last:
+import { Schema } from "effect"
+import * as Grammar from "effect-grammar"
+import * as Binary from "effect-grammar/Binary"
 
-```ts
-const port = Grammar.integer.pipe(
-  Grammar.prefix(":"),
-  Grammar.optional(),
-  Grammar.defaulted(443),
+const header = Grammar.merge(
+  Grammar.struct({ id: Binary.uint16 }),
+  Binary.bits({ qr: 1, opcode: 4, aa: 1, tc: 1, rd: 1, ra: 1, z: 3, rcode: 4 }),
+  Grammar.struct({ qdcount: Binary.uint16 }),
 )
 
-const pair = Grammar.tuple(
-  Grammar.integer,
-  Grammar.integer.pipe(Grammar.prefix(",")),
+const Header = Binary.codec(
+  header,
+  Schema.Struct({
+    id: Binary.Uint16,
+    qr: Binary.Bit,
+    opcode: Binary.Uint(4),
+    aa: Binary.Bit,
+    tc: Binary.Bit,
+    rd: Binary.Bit,
+    ra: Binary.Bit,
+    z: Binary.Uint(3),
+    rcode: Binary.Uint(4),
+    qdcount: Binary.Uint16,
+  }),
 )
-```
-
-`between` is the two-sided delimiter. `wrap` is another name for it. `lexeme`
-skips trailing whitespace after a token, and prints none. `symbol` is a literal
-lexeme. `space` is one exact space. `spaces` accepts one or more whitespace
-characters and prints one canonical space.
-
-## Rendering
 
-`render` formats a grammar as readable text, including binding paths. `describe`
-returns a short name for a grammar.
-
-The interpreter AST is private. Public grammars expose only `Grammar<A>`,
-`Ref<A>`, and the combinators.
-
-## Errors
-
-Parse errors report the furthest position reached, with every expected form at
-that position, plus line and column.
+Schema.decodeSync(Header)(Uint8Array.of(0xbe, 0xef, 0x01, 0x00, 0x00, 0x01))
+// { id: 48879, qr: 0, opcode: 0, aa: 0, tc: 0, rd: 1, ra: 0, z: 0, rcode: 0, qdcount: 1 }
+```
 
-Print errors carry a `PrintIssue` tree. It records structural paths, missing
-fields, branch failures, and value mismatches. `PrintError.format` renders the
-tree as text.
+- `uint8` to `uint64`, `int8` to `int64`, `float32`, and `float64` are
+  big-endian; the `le` suffix, as in `uint16le`, reads little-endian. 64-bit
+  integers are bigints. `float32` prints only numbers that single precision
+  holds exactly.
+- `varuint` is unsigned LEB128 within the safe integer range, and `varint` its
+  zigzag-encoded signed form for integers from `-(2 ** 52)` to `2 ** 52 - 1`.
+  Parsing accepts padded encodings of any length; printing writes the shortest
+  one.
+- `bits(layout)` splits a whole number of bytes into named fields, first field
+  highest. A one-bit field has type `0 | 1`; wider fields are numbers of up to
+  53 bits. Printing rejects a field that does not fit its width.
+- `bytes(count)` reads a `Uint8Array` of a constant or previously bound length,
+  `lengthPrefixed(length)` derives its prefix, a byte count, when printing, and
+  `literal(...bytes)` matches a fixed sequence such as a magic number.
+- `ascii` and `utf8` turn a `Uint8Array` grammar into a string grammar. Invalid
+  bytes fail to parse and unencodable strings fail to print; `auditFidelity`
+  lists `utf8` as partial.
+- `Bit`, `Uint(bits)` and `Int(bits)` for 1 to 53 bits, `Uint8` to `Uint64`, and
+  `Int8` to `Int64` are schemas for the values these grammars produce, and
+  `hex(bytes)` formats a `Uint8Array` for display.
+- `parse`, `print`, `printChecked`, and `codec` mirror the text operations over
+  `Uint8Array`. Parse failures report a byte offset and the byte found; input
+  that ends inside a fixed-width field fails at the end of the input.
+
+A grammar that prints a character above `0xff` cannot be encoded and fails to
+print.
+
+## Examples
+
+The `examples/` directory includes endpoint and connection-string grammars,
+JSON, HTTP ranges, IP addresses, recursive Scheme syntax, contextual printing,
+Schema error integration, and a binary DNS message codec.

package/dist/binary.d.ts

@@ -0,0 +1,64 @@
+import { Result, Schema } from "effect";
+import { type CodecOptions } from "./codec.ts";
+import { type Grammar, type Ref, type Silent } from "./core.ts";
+import { PrintError } from "./errors.ts";
+export { hex } from "./errors.ts";
+export declare const Bit: Schema.Literals<readonly [0, 1]>;
+export declare const Uint: (size: number) => Schema.Int;
+export declare const Int: (size: number) => Schema.Int;
+export declare const Uint8: Schema.Int;
+export declare const Uint16: Schema.Int;
+export declare const Uint32: Schema.Int;
+export declare const Int8: Schema.Int;
+export declare const Int16: Schema.Int;
+export declare const Int32: Schema.Int;
+export declare const Uint64: Schema.BigInt;
+export declare const Int64: Schema.BigInt;
+declare const ParseError_base: Schema.Class<ParseError, Schema.TaggedStruct<"BinaryParseError", {
+    readonly offset: Schema.Finite;
+    readonly expected: Schema.$Array<Schema.String>;
+    readonly found: Schema.UndefinedOr<Schema.Finite>;
+}>, import("effect/Cause").YieldableError>;
+export declare class ParseError extends ParseError_base {
+    get message(): string;
+}
+export declare const uint8: Grammar<number>;
+export declare const uint16: Grammar<number>;
+export declare const uint32: Grammar<number>;
+export declare const uint64: Grammar<bigint>;
+export declare const uint16le: Grammar<number>;
+export declare const uint32le: Grammar<number>;
+export declare const uint64le: Grammar<bigint>;
+export declare const int8: Grammar<number>;
+export declare const int16: Grammar<number>;
+export declare const int32: Grammar<number>;
+export declare const int64: Grammar<bigint>;
+export declare const int16le: Grammar<number>;
+export declare const int32le: Grammar<number>;
+export declare const int64le: Grammar<bigint>;
+export declare const float32: Grammar<number>;
+export declare const float64: Grammar<number>;
+export declare const float32le: Grammar<number>;
+export declare const float64le: Grammar<number>;
+/**
+ * Unsigned LEB128 within the safe integer range. Parsing accepts padded
+ * encodings of any length; printing writes the shortest one.
+ */
+export declare const varuint: Grammar<number>;
+/** Zigzag-encoded LEB128, as in protobuf `sint64`, for integers from -(2 ** 52) to 2 ** 52 - 1. */
+export declare const varint: Grammar<number>;
+export type BitLayout = Readonly<Record<string, number>>;
+export type Bits<Layout extends BitLayout> = {
+    readonly [K in keyof Layout]: Layout[K] extends 1 ? 0 | 1 : number;
+};
+export declare const bits: <const Layout extends BitLayout>(layout: Layout) => Grammar<Bits<Layout>>;
+export declare const bytes: (count: Ref<number> | number) => Grammar<Uint8Array>;
+export declare const lengthPrefixed: (length: Grammar<number>) => Grammar<Uint8Array>;
+export declare const literal: (...values: ReadonlyArray<number>) => Silent;
+export declare const ascii: (inner: Grammar<Uint8Array<ArrayBufferLike>>) => Grammar<string>;
+export declare const utf8: (inner: Grammar<Uint8Array<ArrayBufferLike>>) => Grammar<string>;
+export declare const parse: <A>(grammar: Grammar<A>, input: Uint8Array) => Result.Result<A, ParseError>;
+export declare const print: <A>(grammar: Grammar<A>, value: A) => Result.Result<Uint8Array, PrintError>;
+export declare const printChecked: typeof print;
+export declare const codec: <S extends Schema.Top, A extends S["Encoded"]>(grammar: Grammar<A>, target: S, options?: CodecOptions) => Schema.decodeTo<S, Schema.Codec<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>, never, never>, never, never>;
+//# sourceMappingURL=binary.d.ts.map

package/dist/binary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary.d.ts","sourceRoot":"","sources":["../src/binary.ts"],"names":[],"mappings":"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"}