@thomasfosterau/effect-parse 0.1.0 → 0.2.0

package/dist/Encoding.js

@@ -1,85 +1,86 @@
-/**
- * Text encodings for the `Text` module.
- *
- * An {@link Encoding} tells the `Text` parsers how to read Unicode code
- * points out of an input. JavaScript strings are read natively, without any
- * conversion. Byte inputs are decoded as they are parsed, so offsets stay
- * byte offsets, slices that are kept as bytes (`Parser.taken`) are
- * zero-copy views, and partial input that ends in the middle of a character
- * reports `Incomplete`.
- *
- * ```ts
- * import { Encoding, Text } from "@thomasfosterau/effect-parse"
- *
- * Text.utf8.encoding === Encoding.utf8
- * Text.make(Encoding.latin1) // the Text parsers for any Encoding, including your own
- * ```
- *
- * @since 0.1.0
- */
 import * as Option from "effect/Option";
 import * as internal from "./internal/text.js";
+//#region src/Encoding.ts
+/**
+* Text encodings for the `Text` module.
+*
+* An {@link Encoding} tells the `Text` parsers how to read Unicode code
+* points out of an input. JavaScript strings are read natively, without any
+* conversion. Byte inputs are decoded as they are parsed, so offsets stay
+* byte offsets, slices that are kept as bytes (`Parser.taken`) are
+* zero-copy views, and partial input that ends in the middle of a character
+* reports `Incomplete`.
+*
+* ```ts
+* import { Encoding, Text } from "@thomasfosterau/effect-parse"
+*
+* Text.utf8.encoding === Encoding.utf8
+* Text.make(Encoding.latin1) // the Text parsers for any Encoding, including your own
+* ```
+*
+* @since 0.1.0
+*/
 /**
- * JavaScript strings, read as UTF-16 code units. Offsets are code-unit
- * indices and slices are plain `String.prototype.slice`s. Unpaired
- * surrogates are malformed.
- *
- * @since 0.1.0
- * @category encodings
- */
-export const string = internal.string;
+* JavaScript strings, read as UTF-16 code units. Offsets are code-unit
+* indices and slices are plain `String.prototype.slice`s. Unpaired
+* surrogates are malformed.
+*
+* @since 0.1.0
+* @category encodings
+*/
+const string = internal.string;
 /**
- * UTF-8 bytes. Overlong encodings, surrogates and code points above
- * U+10FFFF are malformed.
- *
- * @since 0.1.0
- * @category encodings
- */
-export const utf8 = internal.utf8;
+* UTF-8 bytes. Overlong encodings, surrogates and code points above
+* U+10FFFF are malformed.
+*
+* @since 0.1.0
+* @category encodings
+*/
+const utf8 = internal.utf8;
 /**
- * UTF-16 bytes, little endian. Unpaired surrogates are malformed.
- *
- * @since 0.1.0
- * @category encodings
- */
-export const utf16le = internal.utf16le;
+* UTF-16 bytes, little endian. Unpaired surrogates are malformed.
+*
+* @since 0.1.0
+* @category encodings
+*/
+const utf16le = internal.utf16le;
 /**
- * UTF-16 bytes, big endian. Unpaired surrogates are malformed.
- *
- * @since 0.1.0
- * @category encodings
- */
-export const utf16be = internal.utf16be;
+* UTF-16 bytes, big endian. Unpaired surrogates are malformed.
+*
+* @since 0.1.0
+* @category encodings
+*/
+const utf16be = internal.utf16be;
 /**
- * ISO-8859-1 (Latin-1) bytes: each byte is the code point U+0000 to U+00FF
- * of the same value.
- *
- * @since 0.1.0
- * @category encodings
- */
-export const latin1 = internal.latin1;
+* ISO-8859-1 (Latin-1) bytes: each byte is the code point U+0000 to U+00FF
+* of the same value.
+*
+* @since 0.1.0
+* @category encodings
+*/
+const latin1 = internal.latin1;
 /**
- * Detects the encoding of bytes from a byte order mark: UTF-8
- * (`EF BB BF`), UTF-16LE (`FF FE`) or UTF-16BE (`FE FF`). The mark itself
- * is not skipped; parse it with `Text.bom`.
- *
- * @example
- * ```ts
- * import { Encoding } from "@thomasfosterau/effect-parse"
- *
- * Encoding.sniff(new Uint8Array([0xff, 0xfe, 0x41, 0x00])) // Option.some(Encoding.utf16le)
- * ```
- *
- * @since 0.1.0
- * @category utils
- */
-export const sniff = (bytes) => {
-    if (bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf)
-        return Option.some(utf8);
-    if (bytes[0] === 0xff && bytes[1] === 0xfe)
-        return Option.some(utf16le);
-    if (bytes[0] === 0xfe && bytes[1] === 0xff)
-        return Option.some(utf16be);
-    return Option.none();
+* Detects the encoding of bytes from a byte order mark: UTF-8
+* (`EF BB BF`), UTF-16LE (`FF FE`) or UTF-16BE (`FE FF`). The mark itself
+* is not skipped; parse it with `Text.bom`.
+*
+* @example
+* ```ts
+* import { Encoding } from "@thomasfosterau/effect-parse"
+*
+* Encoding.sniff(new Uint8Array([0xff, 0xfe, 0x41, 0x00])) // Option.some(Encoding.utf16le)
+* ```
+*
+* @since 0.1.0
+* @category utils
+*/
+const sniff = (bytes) => {
+	if (bytes[0] === 239 && bytes[1] === 187 && bytes[2] === 191) return Option.some(utf8);
+	if (bytes[0] === 255 && bytes[1] === 254) return Option.some(utf16le);
+	if (bytes[0] === 254 && bytes[1] === 255) return Option.some(utf16be);
+	return Option.none();
 };
+//#endregion
+export { latin1, sniff, string, utf16be, utf16le, utf8 };
+
 //# sourceMappingURL=Encoding.js.map

package/dist/Encoding.js.map

@@ -1 +1 @@
-{"version":3,"file":"Encoding.js","sourceRoot":"","sources":["../src/Encoding.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,QAAQ,MAAM,oBAAoB,CAAA;AA2C9C;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,MAAM,GAAqB,QAAQ,CAAC,MAAM,CAAA;AAEvD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,IAAI,GAAyB,QAAQ,CAAC,IAAI,CAAA;AAEvD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,OAAO,GAAyB,QAAQ,CAAC,OAAO,CAAA;AAE7D;;;;;GAKG;AACH,MAAM,CAAC,MAAM,OAAO,GAAyB,QAAQ,CAAC,OAAO,CAAA;AAE7D;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,MAAM,GAAyB,QAAQ,CAAC,MAAM,CAAA;AAE3D;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,KAAiB,EAAuC,EAAE;IAC9E,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI;QAAE,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IACzF,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI;QAAE,OAAO,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;IACvE,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI;QAAE,OAAO,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;IACvE,OAAO,MAAM,CAAC,IAAI,EAAE,CAAA;AACtB,CAAC,CAAA"}
+{"version":3,"file":"Encoding.js","names":[],"sources":["../src/Encoding.ts"],"sourcesContent":["/**\n * Text encodings for the `Text` module.\n *\n * An {@link Encoding} tells the `Text` parsers how to read Unicode code\n * points out of an input. JavaScript strings are read natively, without any\n * conversion. Byte inputs are decoded as they are parsed, so offsets stay\n * byte offsets, slices that are kept as bytes (`Parser.taken`) are\n * zero-copy views, and partial input that ends in the middle of a character\n * reports `Incomplete`.\n *\n * ```ts\n * import { Encoding, Text } from \"@thomasfosterau/effect-parse\"\n *\n * Text.utf8.encoding === Encoding.utf8\n * Text.make(Encoding.latin1) // the Text parsers for any Encoding, including your own\n * ```\n *\n * @since 0.1.0\n */\nimport * as Option from \"effect/Option\"\nimport * as internal from \"./internal/text.js\"\n\n/**\n * A text encoding: how to read Unicode code points out of an input. The\n * `Text` module is generic over encodings, so one grammar can parse\n * JavaScript strings, UTF-8 bytes, UTF-16 bytes and so on.\n *\n * Decoding is strict: malformed sequences (invalid UTF-8, unpaired UTF-16\n * surrogates) are reported as invalid, never replaced.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Encoding<I extends string | Uint8Array = string | Uint8Array> {\n  /** The name of the encoding, e.g. `\"UTF-8\"`. Used in error messages. */\n  readonly name: string\n  /**\n   * The size of a code unit, in input units: 1 for strings, UTF-8 and\n   * Latin-1, 2 for UTF-16 bytes. Code points start at multiples of it.\n   */\n  readonly unit: number\n  /**\n   * Whether every input unit below `0x80` encodes the ASCII character with\n   * that value, and is never part of a longer sequence. Enables fast paths.\n   */\n  readonly asciiCompatible: boolean\n  /**\n   * Decodes the code point starting at `offset` (with `offset < end`).\n   * Returns the code point, `-1` if the input is malformed there, or `-2` if\n   * the input ends inside a sequence (more input could complete it).\n   */\n  readonly decode: (input: I, offset: number, end: number) => number\n  /** The number of input units that encode a code point. */\n  readonly width: (codePoint: number) => number\n  /** Encodes a string. Throws if the string can't be represented. */\n  readonly encode: (text: string) => I\n  /**\n   * Decodes the units `[start, end)` to a string. The parsers only call it\n   * on ranges they have checked are well formed.\n   */\n  readonly text: (input: I, start: number, end: number) => string\n}\n\n/**\n * JavaScript strings, read as UTF-16 code units. Offsets are code-unit\n * indices and slices are plain `String.prototype.slice`s. Unpaired\n * surrogates are malformed.\n *\n * @since 0.1.0\n * @category encodings\n */\nexport const string: Encoding<string> = internal.string\n\n/**\n * UTF-8 bytes. Overlong encodings, surrogates and code points above\n * U+10FFFF are malformed.\n *\n * @since 0.1.0\n * @category encodings\n */\nexport const utf8: Encoding<Uint8Array> = internal.utf8\n\n/**\n * UTF-16 bytes, little endian. Unpaired surrogates are malformed.\n *\n * @since 0.1.0\n * @category encodings\n */\nexport const utf16le: Encoding<Uint8Array> = internal.utf16le\n\n/**\n * UTF-16 bytes, big endian. Unpaired surrogates are malformed.\n *\n * @since 0.1.0\n * @category encodings\n */\nexport const utf16be: Encoding<Uint8Array> = internal.utf16be\n\n/**\n * ISO-8859-1 (Latin-1) bytes: each byte is the code point U+0000 to U+00FF\n * of the same value.\n *\n * @since 0.1.0\n * @category encodings\n */\nexport const latin1: Encoding<Uint8Array> = internal.latin1\n\n/**\n * Detects the encoding of bytes from a byte order mark: UTF-8\n * (`EF BB BF`), UTF-16LE (`FF FE`) or UTF-16BE (`FE FF`). The mark itself\n * is not skipped; parse it with `Text.bom`.\n *\n * @example\n * ```ts\n * import { Encoding } from \"@thomasfosterau/effect-parse\"\n *\n * Encoding.sniff(new Uint8Array([0xff, 0xfe, 0x41, 0x00])) // Option.some(Encoding.utf16le)\n * ```\n *\n * @since 0.1.0\n * @category utils\n */\nexport const sniff = (bytes: Uint8Array): Option.Option<Encoding<Uint8Array>> => {\n  if (bytes[0] === 0xef && bytes[1] === 0xbb && bytes[2] === 0xbf) return Option.some(utf8)\n  if (bytes[0] === 0xff && bytes[1] === 0xfe) return Option.some(utf16le)\n  if (bytes[0] === 0xfe && bytes[1] === 0xff) return Option.some(utf16be)\n  return Option.none()\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuEA,MAAa,SAA2B,SAAS;;;;;;;;AASjD,MAAa,OAA6B,SAAS;;;;;;;AAQnD,MAAa,UAAgC,SAAS;;;;;;;AAQtD,MAAa,UAAgC,SAAS;;;;;;;;AAStD,MAAa,SAA+B,SAAS;;;;;;;;;;;;;;;;AAiBrD,MAAa,SAAS,UAA2D;CAC/E,IAAI,MAAM,OAAO,OAAQ,MAAM,OAAO,OAAQ,MAAM,OAAO,KAAM,OAAO,OAAO,KAAK,IAAI;CACxF,IAAI,MAAM,OAAO,OAAQ,MAAM,OAAO,KAAM,OAAO,OAAO,KAAK,OAAO;CACtE,IAAI,MAAM,OAAO,OAAQ,MAAM,OAAO,KAAM,OAAO,OAAO,KAAK,OAAO;CACtE,OAAO,OAAO,KAAK;AACrB"}

package/dist/Expression.d.ts

@@ -1,41 +1,6 @@
-/**
- * Operator-precedence expression parsing with a Pratt parser (from
- * `nom-language`'s `precedence`, and winnow's expression parser).
- *
- * Describe the operand parser and a table of prefix, postfix and infix
- * operators with their precedence (higher binds tighter) and associativity.
- * Each operator carries a function that folds its operands into a result.
- *
- * @example
- * ```ts
- * import { Ascii, Expression, Parser, Token } from "@thomasfosterau/effect-parse"
- *
- * const op = (s: string) => Parser.delimited(Ascii.space0, Token.literal(s), Ascii.space0)
- *
- * const arithmetic: Parser.Parser<number, string> = Expression.make({
- *   operand: Parser.alt(
- *     Ascii.decInt,
- *     Parser.delimited(op("("), Parser.suspend(() => arithmetic), op(")"))
- *   ),
- *   operators: [
- *     Expression.prefix(op("-"), 4, (_, x) => -x),
- *     Expression.postfix(op("!"), 5, (x) => factorial(x)),
- *     Expression.infixRight(op("^"), 3, (l, _, r) => l ** r),
- *     Expression.infixLeft(op("*"), 2, (l, _, r) => l * r),
- *     Expression.infixLeft(op("/"), 2, (l, _, r) => l / r),
- *     Expression.infixLeft(op("+"), 1, (l, _, r) => l + r),
- *     Expression.infixLeft(op("-"), 1, (l, _, r) => l - r)
- *   ]
- * })
- *
- * declare const factorial: (n: number) => number
- * Parser.parse(arithmetic, "1 + 2 * 3 ^ 2") // Result.succeed(19)
- * ```
- *
- * @since 0.1.0
- */
-import type { Input } from "./Input.js";
-import type { Parser } from "./Parser.js";
+import { Input } from "./Input.js";
+import { Parser } from "./Parser.js";
+//#region src/Expression.d.ts
 /**
  * An operator in an expression grammar.
  *
@@ -44,33 +9,33 @@ import type { Parser } from "./Parser.js";
  */
 export type Operator<A, E = never, R = never, I extends Input = string> = Prefix<A, E, R, I> | Postfix<A, E, R, I> | Infix<A, E, R, I>;
 interface OperatorBase<E, R, I extends Input> {
-    readonly parser: Parser<unknown, E, R, I>;
-    readonly precedence: number;
+  readonly parser: Parser<unknown, E, R, I>;
+  readonly precedence: number;
 }
 /**
  * @since 0.1.0
  * @category models
  */
 export interface Prefix<A, E = never, R = never, I extends Input = string> extends OperatorBase<E, R, I> {
-    readonly _tag: "Prefix";
-    readonly fold: (op: any, operand: A) => A;
+  readonly _tag: "Prefix";
+  readonly fold: (op: any, operand: A) => A;
 }
 /**
  * @since 0.1.0
  * @category models
  */
 export interface Postfix<A, E = never, R = never, I extends Input = string> extends OperatorBase<E, R, I> {
-    readonly _tag: "Postfix";
-    readonly fold: (operand: A, op: any) => A;
+  readonly _tag: "Postfix";
+  readonly fold: (operand: A, op: any) => A;
 }
 /**
  * @since 0.1.0
  * @category models
  */
 export interface Infix<A, E = never, R = never, I extends Input = string> extends OperatorBase<E, R, I> {
-    readonly _tag: "Infix";
-    readonly associativity: "left" | "right";
-    readonly fold: (left: A, op: any, right: A) => A;
+  readonly _tag: "Infix";
+  readonly associativity: "left" | "right";
+  readonly fold: (left: A, op: any, right: A) => A;
 }
 /**
  * A prefix operator, e.g. unary minus.
@@ -117,8 +82,9 @@ type OpInput<Op> = [Op] extends [never] ? Input : [Op] extends [OperatorBase<inf
  * @category constructors
  */
 export declare const make: <A, E, R, I extends Input, const Ops extends ReadonlyArray<Operator<A, any, any, any>>>(options: {
-    readonly operand: Parser<A, E, R, I>;
-    readonly operators: Ops;
+  readonly operand: Parser<A, E, R, I>;
+  readonly operators: Ops;
 }) => Parser<A, E | OpError<Ops[number]>, R | OpServices<Ops[number]>, I & OpInput<Ops[number]>>;
+//#endregion
 export {};
 //# sourceMappingURL=Expression.d.ts.map

package/dist/Expression.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Expression.d.ts","sourceRoot":"","sources":["../src/Expression.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"Expression.d.ts","names":[],"sources":["../src/Expression.ts"],"mappings":";;;;;;;;;YAgDY,SAAS,GAAG,WAAW,WAAW,UAAU,kBACpD,OAAO,GAAG,GAAG,GAAG,KAChB,QAAQ,GAAG,GAAG,GAAG,KACjB,MAAM,GAAG,GAAG,GAAG;UAET,aAAa,GAAG,GAAG,UAAU;WAC5B,QAAQ,gBAAgB,GAAG,GAAG;WAC9B;;;;;;iBAOM,OAAO,GAAG,WAAW,WAAW,UAAU,wBAAwB,aAAa,GAAG,GAAG;WAC3F;WACA,OAAO,SAAS,SAAS,MAAM;;;;;;iBAOzB,QAAQ,GAAG,WAAW,WAAW,UAAU,wBAAwB,aAAa,GAAG,GAAG;WAC5F;WACA,OAAO,SAAS,GAAG,YAAY;;;;;;iBAOzB,MAAM,GAAG,WAAW,WAAW,UAAU,wBAAwB,aAAa,GAAG,GAAG;WAC1F;WACA;WACA,OAAO,MAAM,GAAG,SAAS,OAAO,MAAM;;;;;;;;qBASpC,SAAU,GAAG,GAAG,GAAG,UAAU,OAAO,GAC/C,QAAQ,OAAO,GAAG,GAAG,GAAG,IACxB,oBACA,OAAO,IAAI,GAAG,SAAS,MAAM,MAC5B,OAAO,GAAG,GAAG,GAAG;;;;;;;qBAQN,UAAW,GAAG,GAAG,GAAG,UAAU,OAAO,GAChD,QAAQ,OAAO,GAAG,GAAG,GAAG,IACxB,oBACA,OAAO,SAAS,GAAG,IAAI,MAAM,MAC5B,QAAQ,GAAG,GAAG,GAAG;;;;;;;qBAQP,YAAa,GAAG,GAAG,GAAG,UAAU,OAAO,GAClD,QAAQ,OAAO,GAAG,GAAG,GAAG,IACxB,oBACA,OAAO,MAAM,GAAG,IAAI,GAAG,OAAO,MAAM,MACnC,MAAM,GAAG,GAAG,GAAG;;;;;;;qBAQL,aAAc,GAAG,GAAG,GAAG,UAAU,OAAO,GACnD,QAAQ,OAAO,GAAG,GAAG,GAAG,IACxB,oBACA,OAAO,MAAM,GAAG,IAAI,GAAG,OAAO,MAAM,MACnC,MAAM,GAAG,GAAG,GAAG;KAEb,QAAQ,MAAM,WAAW,mBAAmB,SAAS,UAAU,MAAM;KACrE,WAAW,MAAM,WAAW,mBAAmB,UAAU,SAAS,MAAM;KACxE,QAAQ,OAAO,sBAAsB,SAAS,aAAa,mBAAmB,UAAU,UAAU,MAAM;;;;;;;;;;;;;;qBAehG,OAAQ,GAAG,GAAG,GAAG,UAAU,aAAa,YAAY,cAAc,SAAS,oBAAoB;WACjG,SAAS,OAAO,GAAG,GAAG,GAAG;WACzB,WAAW;MAClB,OAAO,GAAG,IAAI,QAAQ,cAAc,IAAI,WAAW,cAAc,IAAI,QAAQ"}

package/dist/Expression.js

@@ -1,139 +1,151 @@
 import { Fail, mergeFailures } from "./Input.js";
-import { make as makeParser } from "./Parser.js";
+import { make as make$1 } from "./Parser.js";
+//#region src/Expression.ts
 /**
- * A prefix operator, e.g. unary minus.
- *
- * @since 0.1.0
- * @category operators
- */
-export const prefix = (parser, precedence, fold) => ({ _tag: "Prefix", parser, precedence, fold });
+* A prefix operator, e.g. unary minus.
+*
+* @since 0.1.0
+* @category operators
+*/
+const prefix = (parser, precedence, fold) => ({
+	_tag: "Prefix",
+	parser,
+	precedence,
+	fold
+});
 /**
- * A postfix operator, e.g. factorial or a function call suffix.
- *
- * @since 0.1.0
- * @category operators
- */
-export const postfix = (parser, precedence, fold) => ({ _tag: "Postfix", parser, precedence, fold });
+* A postfix operator, e.g. factorial or a function call suffix.
+*
+* @since 0.1.0
+* @category operators
+*/
+const postfix = (parser, precedence, fold) => ({
+	_tag: "Postfix",
+	parser,
+	precedence,
+	fold
+});
 /**
- * A left-associative infix operator: `a - b - c` is `(a - b) - c`.
- *
- * @since 0.1.0
- * @category operators
- */
-export const infixLeft = (parser, precedence, fold) => ({ _tag: "Infix", associativity: "left", parser, precedence, fold });
+* A left-associative infix operator: `a - b - c` is `(a - b) - c`.
+*
+* @since 0.1.0
+* @category operators
+*/
+const infixLeft = (parser, precedence, fold) => ({
+	_tag: "Infix",
+	associativity: "left",
+	parser,
+	precedence,
+	fold
+});
 /**
- * A right-associative infix operator: `a ^ b ^ c` is `a ^ (b ^ c)`.
- *
- * @since 0.1.0
- * @category operators
- */
-export const infixRight = (parser, precedence, fold) => ({ _tag: "Infix", associativity: "right", parser, precedence, fold });
+* A right-associative infix operator: `a ^ b ^ c` is `a ^ (b ^ c)`.
+*
+* @since 0.1.0
+* @category operators
+*/
+const infixRight = (parser, precedence, fold) => ({
+	_tag: "Infix",
+	associativity: "right",
+	parser,
+	precedence,
+	fold
+});
 /**
- * Builds an expression parser from an operand parser and an operator table.
- *
- * Precedences are compared numerically: higher binds tighter. A prefix
- * operator applies to everything that binds tighter than it, so with `-`
- * at precedence 4 and `^` at 3, `-2 ^ 2` parses as `(-2) ^ 2`.
- *
- * When several operators of the same kind match, the first one in the
- * table wins, so list longer operators (`<=`) before their prefixes (`<`).
- *
- * @since 0.1.0
- * @category constructors
- */
-export const make = (options) => {
-    const operand = options.operand.step;
-    const prefixes = options.operators.filter((o) => o._tag === "Prefix");
-    const postfixes = options.operators.filter((o) => o._tag === "Postfix");
-    const infixes = options.operators.filter((o) => o._tag === "Infix");
-    // Attempts each operator in turn. Returns the index of the first match
-    // (with its output in `matched`), -1 if none matched, or -2 on a fatal
-    // failure. Expectations of failed attempts are accumulated in `failure`.
-    let matched;
-    let failure;
-    const tryOps = (state, ops, mustConsume) => {
-        const start = state.pos;
-        for (let i = 0; i < ops.length; i++) {
-            const out = ops[i].parser.step(state);
-            if (out !== Fail) {
-                // A prefix or postfix operator matching nothing would apply forever
-                if (mustConsume && state.pos === start) {
-                    state.failMessage("Cut", "Assert", "prefix and postfix operators must always consume");
-                    return -2;
-                }
-                matched = out;
-                return i;
-            }
-            if (state.mode !== "Backtrack")
-                return -2;
-            failure = failure === undefined ? state.failure : mergeFailures(failure, state.failure);
-            state.pos = start;
-        }
-        return -1;
-    };
-    const expr = (state, minPower) => {
-        let lhs;
-        failure = undefined;
-        const p = tryOps(state, prefixes, true);
-        if (p === -2)
-            return Fail;
-        if (p >= 0) {
-            const op = prefixes[p];
-            const opOut = matched;
-            const operandValue = expr(state, op.precedence * 2);
-            if (operandValue === Fail)
-                return Fail;
-            lhs = op.fold(opOut, operandValue);
-        }
-        else {
-            const prefixFailure = failure;
-            lhs = operand(state);
-            if (lhs === Fail) {
-                if (prefixFailure !== undefined && state.mode === "Backtrack") {
-                    state.failWith("Backtrack", mergeFailures(prefixFailure, state.failure));
-                }
-                return Fail;
-            }
-        }
-        while (true) {
-            const start = state.pos;
-            failure = undefined;
-            const q = tryOps(state, postfixes, true);
-            if (q === -2)
-                return Fail;
-            if (q >= 0) {
-                const op = postfixes[q];
-                if (op.precedence * 2 < minPower) {
-                    state.pos = start;
-                    break;
-                }
-                lhs = op.fold(lhs, matched);
-                continue;
-            }
-            const postfixFailure = failure;
-            const i = tryOps(state, infixes, false);
-            if (i === -2)
-                return Fail;
-            if (i < 0) {
-                const f = postfixFailure === undefined ? failure : failure === undefined ? postfixFailure : mergeFailures(postfixFailure, failure);
-                if (f !== undefined && f.offset === state.pos)
-                    state.setHint(f.offset, f.expected);
-                break;
-            }
-            const op = infixes[i];
-            const leftPower = op.precedence * 2;
-            if (leftPower < minPower) {
-                state.pos = start;
-                break;
-            }
-            const opOut = matched;
-            const rhs = expr(state, op.associativity === "left" ? leftPower + 1 : leftPower);
-            if (rhs === Fail)
-                return Fail;
-            lhs = op.fold(lhs, opOut, rhs);
-        }
-        return lhs;
-    };
-    return makeParser((state) => expr(state, 0), "expression");
+* Builds an expression parser from an operand parser and an operator table.
+*
+* Precedences are compared numerically: higher binds tighter. A prefix
+* operator applies to everything that binds tighter than it, so with `-`
+* at precedence 4 and `^` at 3, `-2 ^ 2` parses as `(-2) ^ 2`.
+*
+* When several operators of the same kind match, the first one in the
+* table wins, so list longer operators (`<=`) before their prefixes (`<`).
+*
+* @since 0.1.0
+* @category constructors
+*/
+const make = (options) => {
+	const operand = options.operand.step;
+	const prefixes = options.operators.filter((o) => o._tag === "Prefix");
+	const postfixes = options.operators.filter((o) => o._tag === "Postfix");
+	const infixes = options.operators.filter((o) => o._tag === "Infix");
+	let matched;
+	let failure;
+	const tryOps = (state, ops, mustConsume) => {
+		const start = state.pos;
+		for (let i = 0; i < ops.length; i++) {
+			const out = ops[i].parser.step(state);
+			if (out !== Fail) {
+				if (mustConsume && state.pos === start) {
+					state.failMessage("Cut", "Assert", "prefix and postfix operators must always consume");
+					return -2;
+				}
+				matched = out;
+				return i;
+			}
+			if (state.mode !== "Backtrack") return -2;
+			failure = failure === void 0 ? state.failure : mergeFailures(failure, state.failure);
+			state.pos = start;
+		}
+		return -1;
+	};
+	const expr = (state, minPower) => {
+		let lhs;
+		failure = void 0;
+		const p = tryOps(state, prefixes, true);
+		if (p === -2) return Fail;
+		if (p >= 0) {
+			const op = prefixes[p];
+			const opOut = matched;
+			const operandValue = expr(state, op.precedence * 2);
+			if (operandValue === Fail) return Fail;
+			lhs = op.fold(opOut, operandValue);
+		} else {
+			const prefixFailure = failure;
+			lhs = operand(state);
+			if (lhs === Fail) {
+				if (prefixFailure !== void 0 && state.mode === "Backtrack") state.failWith("Backtrack", mergeFailures(prefixFailure, state.failure));
+				return Fail;
+			}
+		}
+		while (true) {
+			const start = state.pos;
+			failure = void 0;
+			const q = tryOps(state, postfixes, true);
+			if (q === -2) return Fail;
+			if (q >= 0) {
+				const op = postfixes[q];
+				if (op.precedence * 2 < minPower) {
+					state.pos = start;
+					break;
+				}
+				lhs = op.fold(lhs, matched);
+				continue;
+			}
+			const postfixFailure = failure;
+			const i = tryOps(state, infixes, false);
+			if (i === -2) return Fail;
+			if (i < 0) {
+				const f = postfixFailure === void 0 ? failure : failure === void 0 ? postfixFailure : mergeFailures(postfixFailure, failure);
+				if (f !== void 0 && f.offset === state.pos) state.setHint(f.offset, f.expected);
+				break;
+			}
+			const op = infixes[i];
+			const leftPower = op.precedence * 2;
+			if (leftPower < minPower) {
+				state.pos = start;
+				break;
+			}
+			const opOut = matched;
+			const rhs = expr(state, op.associativity === "left" ? leftPower + 1 : leftPower);
+			if (rhs === Fail) return Fail;
+			lhs = op.fold(lhs, opOut, rhs);
+		}
+		return lhs;
+	};
+	return make$1((state) => expr(state, 0), "expression");
 };
+//#endregion
+export { infixLeft, infixRight, make, postfix, prefix };
+
 //# sourceMappingURL=Expression.js.map

package/dist/Expression.js.map

@@ -1 +1 @@
-{"version":3,"file":"Expression.js","sourceRoot":"","sources":["../src/Expression.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"Expression.js","names":["makeParser"],"sources":["../src/Expression.ts"],"sourcesContent":["/**\n * Operator-precedence expression parsing with a Pratt parser (from\n * `nom-language`'s `precedence`, and winnow's expression parser).\n *\n * Describe the operand parser and a table of prefix, postfix and infix\n * operators with their precedence (higher binds tighter) and associativity.\n * Each operator carries a function that folds its operands into a result.\n *\n * @example\n * ```ts\n * import { Ascii, Expression, Parser, Token } from \"@thomasfosterau/effect-parse\"\n *\n * const op = (s: string) => Parser.delimited(Ascii.space0, Token.literal(s), Ascii.space0)\n *\n * const arithmetic: Parser.Parser<number, string> = Expression.make({\n *   operand: Parser.alt(\n *     Ascii.decInt,\n *     Parser.delimited(op(\"(\"), Parser.suspend(() => arithmetic), op(\")\"))\n *   ),\n *   operators: [\n *     Expression.prefix(op(\"-\"), 4, (_, x) => -x),\n *     Expression.postfix(op(\"!\"), 5, (x) => factorial(x)),\n *     Expression.infixRight(op(\"^\"), 3, (l, _, r) => l ** r),\n *     Expression.infixLeft(op(\"*\"), 2, (l, _, r) => l * r),\n *     Expression.infixLeft(op(\"/\"), 2, (l, _, r) => l / r),\n *     Expression.infixLeft(op(\"+\"), 1, (l, _, r) => l + r),\n *     Expression.infixLeft(op(\"-\"), 1, (l, _, r) => l - r)\n *   ]\n * })\n *\n * declare const factorial: (n: number) => number\n * Parser.parse(arithmetic, \"1 + 2 * 3 ^ 2\") // Result.succeed(19)\n * ```\n *\n * @since 0.1.0\n */\nimport type { Input, State } from \"./Input.js\"\nimport { Fail, mergeFailures } from \"./Input.js\"\nimport type { Failure } from \"./Input.js\"\nimport type { Parser } from \"./Parser.js\"\nimport { make as makeParser } from \"./Parser.js\"\n\n/**\n * An operator in an expression grammar.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Operator<A, E = never, R = never, I extends Input = string> =\n  | Prefix<A, E, R, I>\n  | Postfix<A, E, R, I>\n  | Infix<A, E, R, I>\n\ninterface OperatorBase<E, R, I extends Input> {\n  readonly parser: Parser<unknown, E, R, I>\n  readonly precedence: number\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface Prefix<A, E = never, R = never, I extends Input = string> extends OperatorBase<E, R, I> {\n  readonly _tag: \"Prefix\"\n  readonly fold: (op: any, operand: A) => A\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface Postfix<A, E = never, R = never, I extends Input = string> extends OperatorBase<E, R, I> {\n  readonly _tag: \"Postfix\"\n  readonly fold: (operand: A, op: any) => A\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface Infix<A, E = never, R = never, I extends Input = string> extends OperatorBase<E, R, I> {\n  readonly _tag: \"Infix\"\n  readonly associativity: \"left\" | \"right\"\n  readonly fold: (left: A, op: any, right: A) => A\n}\n\n/**\n * A prefix operator, e.g. unary minus.\n *\n * @since 0.1.0\n * @category operators\n */\nexport const prefix = <O, E, R, I extends Input, A>(\n  parser: Parser<O, E, R, I>,\n  precedence: number,\n  fold: (op: O, operand: A) => A\n): Prefix<A, E, R, I> => ({ _tag: \"Prefix\", parser, precedence, fold })\n\n/**\n * A postfix operator, e.g. factorial or a function call suffix.\n *\n * @since 0.1.0\n * @category operators\n */\nexport const postfix = <O, E, R, I extends Input, A>(\n  parser: Parser<O, E, R, I>,\n  precedence: number,\n  fold: (operand: A, op: O) => A\n): Postfix<A, E, R, I> => ({ _tag: \"Postfix\", parser, precedence, fold })\n\n/**\n * A left-associative infix operator: `a - b - c` is `(a - b) - c`.\n *\n * @since 0.1.0\n * @category operators\n */\nexport const infixLeft = <O, E, R, I extends Input, A>(\n  parser: Parser<O, E, R, I>,\n  precedence: number,\n  fold: (left: A, op: O, right: A) => A\n): Infix<A, E, R, I> => ({ _tag: \"Infix\", associativity: \"left\", parser, precedence, fold })\n\n/**\n * A right-associative infix operator: `a ^ b ^ c` is `a ^ (b ^ c)`.\n *\n * @since 0.1.0\n * @category operators\n */\nexport const infixRight = <O, E, R, I extends Input, A>(\n  parser: Parser<O, E, R, I>,\n  precedence: number,\n  fold: (left: A, op: O, right: A) => A\n): Infix<A, E, R, I> => ({ _tag: \"Infix\", associativity: \"right\", parser, precedence, fold })\n\ntype OpError<Op> = Op extends OperatorBase<infer E, infer _R, infer _I> ? E : never\ntype OpServices<Op> = Op extends OperatorBase<infer _E, infer R, infer _I> ? R : never\ntype OpInput<Op> = [Op] extends [never] ? Input : [Op] extends [OperatorBase<infer _E, infer _R, infer I>] ? I : never\n\n/**\n * Builds an expression parser from an operand parser and an operator table.\n *\n * Precedences are compared numerically: higher binds tighter. A prefix\n * operator applies to everything that binds tighter than it, so with `-`\n * at precedence 4 and `^` at 3, `-2 ^ 2` parses as `(-2) ^ 2`.\n *\n * When several operators of the same kind match, the first one in the\n * table wins, so list longer operators (`<=`) before their prefixes (`<`).\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const make = <A, E, R, I extends Input, const Ops extends ReadonlyArray<Operator<A, any, any, any>>>(options: {\n  readonly operand: Parser<A, E, R, I>\n  readonly operators: Ops\n}): Parser<A, E | OpError<Ops[number]>, R | OpServices<Ops[number]>, I & OpInput<Ops[number]>> => {\n  const operand = options.operand.step\n  const prefixes = options.operators.filter((o): o is Prefix<A, any, any, any> => o._tag === \"Prefix\")\n  const postfixes = options.operators.filter((o): o is Postfix<A, any, any, any> => o._tag === \"Postfix\")\n  const infixes = options.operators.filter((o): o is Infix<A, any, any, any> => o._tag === \"Infix\")\n\n  // Attempts each operator in turn. Returns the index of the first match\n  // (with its output in `matched`), -1 if none matched, or -2 on a fatal\n  // failure. Expectations of failed attempts are accumulated in `failure`.\n  let matched: unknown\n  let failure: Failure | undefined\n  const tryOps = (state: State<any>, ops: ReadonlyArray<OperatorBase<any, any, any>>, mustConsume: boolean): number => {\n    const start = state.pos\n    for (let i = 0; i < ops.length; i++) {\n      const out = ops[i].parser.step(state)\n      if (out !== Fail) {\n        // A prefix or postfix operator matching nothing would apply forever\n        if (mustConsume && state.pos === start) {\n          state.failMessage(\"Cut\", \"Assert\", \"prefix and postfix operators must always consume\")\n          return -2\n        }\n        matched = out\n        return i\n      }\n      if (state.mode !== \"Backtrack\") return -2\n      failure = failure === undefined ? state.failure : mergeFailures(failure, state.failure)\n      state.pos = start\n    }\n    return -1\n  }\n\n  const expr = (state: State<any>, minPower: number): A | Fail => {\n    let lhs: A | Fail\n    failure = undefined\n    const p = tryOps(state, prefixes, true)\n    if (p === -2) return Fail\n    if (p >= 0) {\n      const op = prefixes[p]\n      const opOut = matched\n      const operandValue = expr(state, op.precedence * 2)\n      if (operandValue === Fail) return Fail\n      lhs = op.fold(opOut, operandValue)\n    } else {\n      const prefixFailure = failure\n      lhs = operand(state)\n      if (lhs === Fail) {\n        if (prefixFailure !== undefined && state.mode === \"Backtrack\") {\n          state.failWith(\"Backtrack\", mergeFailures(prefixFailure, state.failure))\n        }\n        return Fail\n      }\n    }\n\n    while (true) {\n      const start = state.pos\n      failure = undefined\n      const q = tryOps(state, postfixes, true)\n      if (q === -2) return Fail\n      if (q >= 0) {\n        const op = postfixes[q]\n        if (op.precedence * 2 < minPower) {\n          state.pos = start\n          break\n        }\n        lhs = op.fold(lhs, matched)\n        continue\n      }\n      const postfixFailure = failure\n      const i = tryOps(state, infixes, false)\n      if (i === -2) return Fail\n      if (i < 0) {\n        const f =\n          postfixFailure === undefined\n            ? failure\n            : failure === undefined\n              ? postfixFailure\n              : mergeFailures(postfixFailure, failure)\n        if (f !== undefined && f.offset === state.pos) state.setHint(f.offset, f.expected)\n        break\n      }\n      const op = infixes[i]\n      const leftPower = op.precedence * 2\n      if (leftPower < minPower) {\n        state.pos = start\n        break\n      }\n      const opOut = matched\n      const rhs = expr(state, op.associativity === \"left\" ? leftPower + 1 : leftPower)\n      if (rhs === Fail) return Fail\n      lhs = op.fold(lhs, opOut, rhs)\n    }\n    return lhs\n  }\n\n  return makeParser((state: State<any>) => expr(state, 0), \"expression\")\n}\n"],"mappings":"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"}