@thomasfosterau/effect-parse 0.0.0 → 0.2.0

package/src/ParserStream.ts

@@ -23,6 +23,7 @@
  *
  * @since 0.1.0
  */
+import * as Predicate from "effect/Predicate"
 import type * as Context from "effect/Context"
 import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
@@ -31,8 +32,10 @@ import * as Stream from "effect/Stream"
 import type { BinaryInput, Input, Source } from "./Input.js"
 import { Fail, Failure, fromSource, State } from "./Input.js"
 import * as ParseError from "./ParseError.js"
-import * as Compiler from "./internal/compiler/registry.js"
+import * as Registry from "./internal/compiler/registry.js"
 import type * as Resume from "./internal/resume.js"
+import * as Run from "./internal/run.js"
+import * as Stack from "./internal/stack.js"
 import type { Parser } from "./Parser.js"
 
 /**
@@ -44,7 +47,7 @@ import type { Parser } from "./Parser.js"
 export type Chunkable = string | Uint8Array | ReadonlyArray<unknown>
 
 const concat = <I extends Chunkable>(a: I, b: I): I => {
-  if (typeof a === "string") return (a + (b as string)) as I
+  if (Predicate.isString(a)) return (a + (b as string)) as I
   if (a instanceof Uint8Array) {
     if (a.length === 0) return b
     const out = new Uint8Array(a.length + (b as Uint8Array).length)
@@ -56,7 +59,7 @@ const concat = <I extends Chunkable>(a: I, b: I): I => {
 }
 
 const sliceFrom = <I extends Chunkable>(input: I, offset: number): I =>
-  (typeof input === "string" ? input.slice(offset) : input.slice(offset)) as I
+  (Predicate.isString(input) ? input.slice(offset) : input.slice(offset)) as I
 
 const noProgress = (input: Input, offset: number) =>
   ParseError.fromFailure<never>(
@@ -84,6 +87,11 @@ export interface ParseManyOptions<I> {
  * Error offsets are relative to the internal buffer of unconsumed input,
  * which is also the `input` of the reported `ParseError`.
  *
+ * A parser compiled with the `Compiler` module runs compiled, with the
+ * build that handles partial input (see `Parser.run`); a value that fails
+ * or needs more input is parsed again interpreted, so errors and
+ * `Incomplete` are the interpreter's.
+ *
  * @since 0.1.0
  * @category combinators
  */
@@ -97,54 +105,57 @@ export const parseMany: {
     parser: Parser<A, E, R, I>,
     options?: ParseManyOptions<I>
   ): Stream.Stream<A, E0 | ParseError.ParseError<E>, R0 | R>
-} = dual((args) => Stream.isStream(args[0]), <I extends Chunkable, E0, R0, A, E, R>(
-  self: Stream.Stream<Source<I>, E0, R0>,
-  parser: Parser<A, E, R, I>,
-  options?: ParseManyOptions<I>
-): Stream.Stream<A, E0 | ParseError.ParseError<E>, R0 | R> =>
-  Stream.suspend(() => {
-    const step = parser.step
-    let buffer: I | undefined = options?.empty === undefined ? undefined : fromSource<I>(options.empty)
+} = /*#__PURE__*/ dual(
+  (args) => Stream.isStream(args[0]),
+  <I extends Chunkable, E0, R0, A, E, R>(
+    self: Stream.Stream<Source<I>, E0, R0>,
+    parser: Parser<A, E, R, I>,
+    options?: ParseManyOptions<I>
+  ): Stream.Stream<A, E0 | ParseError.ParseError<E>, R0 | R> =>
+    Stream.suspend(() => {
+      const step = parser.step
+      let buffer: I | undefined = options?.empty === undefined ? undefined : fromSource<I>(options.empty)
 
-    const drain = (
-      context: any,
-      partial: boolean
-    ): Effect.Effect<Array<A>, ParseError.ParseError<E>> => {
-      const out: Array<A> = []
-      if (buffer === undefined) return Effect.succeed(out)
-      const input = buffer
-      let offset = 0
-      while (offset < input.length) {
-        const state = new State(input, { partial, context, offset })
-        const a = step(state)
-        if (a === Fail) {
-          if (partial && state.mode === "Incomplete") break
-          return Effect.fail(ParseError.fromFailure<E>(input, state.reportedFailure(), state.mode, state.encoding))
+      const drain = (context: any, partial: boolean): Effect.Effect<Array<A>, ParseError.ParseError<E>> => {
+        const out: Array<A> = []
+        if (buffer === undefined) return Effect.succeed(out)
+        const input = buffer
+        // One state for the whole buffer, reset before each value
+        const state = new State(input)
+        let offset = 0
+        while (offset < input.length) {
+          state.reset(offset, { partial, context })
+          const a = Run.runOn(parser, step, state)
+          if (a === Fail) {
+            if (partial && state.mode === "Incomplete") break
+            return Effect.fail(ParseError.fromFailure<E>(input, state.reportedFailure(), state.mode, state.encoding))
+          }
+          if (state.pos === offset) return Effect.fail(noProgress(input, offset))
+          out.push(a)
+          offset = state.pos
         }
-        if (state.pos === offset) return Effect.fail(noProgress(input, offset))
-        out.push(a)
-        offset = state.pos
+        buffer = sliceFrom(input, offset)
+        return Effect.succeed(out)
       }
-      buffer = sliceFrom(input, offset)
-      return Effect.succeed(out)
-    }
 
-    const feed = (source: Source<I>) =>
-      Effect.flatMap(Effect.context<R>(), (context) =>
-        Effect.suspend(() => {
-          const chunk = fromSource<I>(source)
-          buffer = buffer === undefined ? chunk : concat(buffer, chunk)
-          return drain(context, true)
-        }))
+      const feed = (source: Source<I>) =>
+        Effect.flatMap(Effect.context<R>(), (context) =>
+          Effect.suspend(() => {
+            const chunk = fromSource<I>(source)
+            buffer = buffer === undefined ? chunk : concat(buffer, chunk)
+            return drain(context, true)
+          })
+        )
 
-    const finish = Effect.flatMap(Effect.context<R>(), (context) => Effect.suspend(() => drain(context, false)))
+      const finish = Effect.flatMap(Effect.context<R>(), (context) => Effect.suspend(() => drain(context, false)))
 
-    return self.pipe(
-      Stream.mapEffect(feed),
-      Stream.flattenIterable,
-      Stream.concat(Stream.unwrap(Effect.map(finish, Stream.fromIterable)))
-    )
-  }))
+      return self.pipe(
+        Stream.mapEffect(feed),
+        Stream.flattenIterable,
+        Stream.concat(Stream.unwrap(Effect.map(finish, Stream.fromIterable)))
+      )
+    })
+)
 
 /**
  * Parses a stream of chunks incrementally, as one input. Chunks are parsed
@@ -175,7 +186,7 @@ class Incremental<A, E, I extends Chunkable> {
   }
 
   private append(chunk: I): void {
-    if (typeof chunk === "string") {
+    if (Predicate.isString(chunk)) {
       this.kind ??= 0
       this.text += chunk
       this.length += chunk.length
@@ -225,7 +236,7 @@ class Incremental<A, E, I extends Chunkable> {
 
   /** The step attempts run: the parser's resumable compiled code if it was compiled, else the interpreter. */
   private step(state: State<I>): unknown {
-    return (Compiler.stepFor(this.parser, state, true) ?? this.parser.step)(state)
+    return Stack.run(Registry.stepFor(this.parser, state, true) ?? this.parser.step, state)
   }
 
   private attempt(): void {
@@ -257,7 +268,7 @@ class Incremental<A, E, I extends Chunkable> {
     // same as if the input had been parsed in one go
     const all = this.input()
     const state = new State(all, { context: this.context })
-    const a = this.parser.step(state)
+    const a = Stack.run(this.parser.step, state)
     if (a !== Fail && state.pos === state.end) return Effect.succeed(a)
     if (a !== Fail) state.backtrack("Eof", ["end of input"])
     return Effect.fail(ParseError.fromFailure<E>(all, state.reportedFailure(), state.mode, state.encoding))
@@ -277,8 +288,8 @@ class Incremental<A, E, I extends Chunkable> {
  *
  * The result and any `ParseError` are those of parsing the whole input at
  * once: errors are reported once the stream has ended, by an ordinary
- * interpreted parse of the whole input. A parser compiled with
- * `Parser.compile` streams compiled too (with a build that handles partial
+ * interpreted parse of the whole input. A parser compiled with the
+ * `Compiler` module streams compiled too (with a build that handles partial
  * input), which is several times faster. As with compiled parsers,
  * callbacks should be pure: the elements parsed before a checkpoint are
  * not parsed again, and on failure everything is parsed again.
@@ -296,20 +307,24 @@ export const parseAll: {
     parser: Parser<A, E, R, I>,
     options?: ParseManyOptions<I>
   ): Effect.Effect<A, E0 | ParseError.ParseError<E>, R0 | R>
-} = dual((args) => Stream.isStream(args[0]), <I extends Chunkable, E0, R0, A, E, R>(
-  self: Stream.Stream<Source<I>, E0, R0>,
-  parser: Parser<A, E, R, I>,
-  options?: ParseManyOptions<I>
-): Effect.Effect<A, E0 | ParseError.ParseError<E>, R0 | R> =>
-  Effect.flatMap(Effect.context<R>(), (context) =>
-    Effect.suspend(() => {
-      const empty = options?.empty === undefined ? undefined : fromSource<I>(options.empty)
-      const incremental = new Incremental(parser, context as Context.Context<never>, empty)
-      return Effect.flatMap(
-        Stream.runForEach(self, (chunk) => Effect.sync(() => incremental.push(fromSource<I>(chunk)))),
-        () => Effect.suspend(() => incremental.finish())
-      )
-    })))
+} = /*#__PURE__*/ dual(
+  (args) => Stream.isStream(args[0]),
+  <I extends Chunkable, E0, R0, A, E, R>(
+    self: Stream.Stream<Source<I>, E0, R0>,
+    parser: Parser<A, E, R, I>,
+    options?: ParseManyOptions<I>
+  ): Effect.Effect<A, E0 | ParseError.ParseError<E>, R0 | R> =>
+    Effect.flatMap(Effect.context<R>(), (context) =>
+      Effect.suspend(() => {
+        const empty = options?.empty === undefined ? undefined : fromSource<I>(options.empty)
+        const incremental = new Incremental(parser, context as Context.Context<never>, empty)
+        return Effect.flatMap(
+          Stream.runForEach(self, (chunk) => Effect.sync(() => incremental.push(fromSource<I>(chunk)))),
+          () => Effect.suspend(() => incremental.finish())
+        )
+      })
+    )
+)
 
 /**
  * An error reading a `ReadableStream` given to {@link parseReadable} or
@@ -318,7 +333,7 @@ export const parseAll: {
  * @since 0.1.0
  * @category errors
  */
-export class ReadError extends Data.TaggedError("ReadError")<{ readonly cause: unknown }> {}
+export class ReadError extends /*#__PURE__*/ Data.TaggedError("ReadError")<{ readonly cause: unknown }> {}
 
 /**
  * Parses a web `ReadableStream` of bytes, such as the body of a `fetch`
@@ -349,15 +364,18 @@ export const parseReadable: {
     self: ReadableStream<BinaryInput>,
     parser: Parser<A, E, R, Uint8Array>
   ): Effect.Effect<A, ParseError.ParseError<E> | ReadError, R>
-} = dual(2, <A, E, R>(
-  self: ReadableStream<BinaryInput>,
-  parser: Parser<A, E, R, Uint8Array>
-): Effect.Effect<A, ParseError.ParseError<E> | ReadError, R> =>
-  parseAll(
-    Stream.fromReadableStream({ evaluate: () => self, onError: (cause) => new ReadError({ cause }) }),
-    parser,
-    { empty: new Uint8Array(0) }
-  ))
+} = /*#__PURE__*/ dual(
+  2,
+  <A, E, R>(
+    self: ReadableStream<BinaryInput>,
+    parser: Parser<A, E, R, Uint8Array>
+  ): Effect.Effect<A, ParseError.ParseError<E> | ReadError, R> =>
+    parseAll(
+      Stream.fromReadableStream({ evaluate: () => self, onError: (cause) => new ReadError({ cause }) }),
+      parser,
+      { empty: new Uint8Array(0) }
+    )
+)
 
 /**
  * Parses the body of a `fetch` `Response` incrementally, as it downloads
@@ -382,9 +400,15 @@ export const parseResponse: {
   <A, E, R>(
     parser: Parser<A, E, R, Uint8Array>
   ): (self: Response) => Effect.Effect<A, ParseError.ParseError<E> | ReadError, R>
-  <A, E, R>(self: Response, parser: Parser<A, E, R, Uint8Array>): Effect.Effect<A, ParseError.ParseError<E> | ReadError, R>
-} = dual(2, <A, E, R>(
-  self: Response,
-  parser: Parser<A, E, R, Uint8Array>
-): Effect.Effect<A, ParseError.ParseError<E> | ReadError, R> =>
-  parseReadable(self.body ?? new ReadableStream<Uint8Array>({ start: (c) => c.close() }), parser))
+  <A, E, R>(
+    self: Response,
+    parser: Parser<A, E, R, Uint8Array>
+  ): Effect.Effect<A, ParseError.ParseError<E> | ReadError, R>
+} = /*#__PURE__*/ dual(
+  2,
+  <A, E, R>(
+    self: Response,
+    parser: Parser<A, E, R, Uint8Array>
+  ): Effect.Effect<A, ParseError.ParseError<E> | ReadError, R> =>
+    parseReadable(self.body ?? new ReadableStream<Uint8Array>({ start: (c) => c.close() }), parser)
+)