Method getParser

packages/effect/src/SchemaAST.ts:2855–2897

@internal

(
    compile: SchemaParser.Compiler,
    compileConstructorDefault?: SchemaParser.Compiler
  )

  }
  /** @internal */
  getParser(
    compile: SchemaParser.Compiler,
    compileConstructorDefault?: SchemaParser.Compiler
  ): SchemaParser.Parser {
    // oxlint-disable-next-line @typescript-eslint/no-this-alias
    const ast = this

    return (input, options) => {
      if (input === InternalParser.missing) {
        return InternalParser.missingExit
      }
      const candidates = getCandidates(input, ast.types, compileConstructorDefault !== undefined)

      if (candidates.length === 1) {
        const result = compile(candidates[0])(input, options)
        if ((result as Exit.Exit<unknown, SchemaIssue.Issue>)._tag === "Success") return result
        return effectIsExit(result)
          ? failSingleUnionCandidate(ast, (result as Exit.Failure<unknown, SchemaIssue.Issue>).cause, input, options)
          : Effect.catchCause(result, (cause) => failSingleUnionCandidate(ast, cause, input, options))
      }

      const state = {
        ast,
        compile,
        input,
        out: undefined,
        successes: ast.mode === "oneOf" ? [] : undefined,
        issues: undefined as Arr.NonEmptyArray<SchemaIssue.Issue> | undefined,
        options
      }
      const concurrency = resolveConcurrency(options?.concurrency)
      const eff = parseUnion(state, candidates, concurrency ? { ...concurrency, orderedStep: true } : undefined)
      if (!eff) {
        if (state.out) return state.out
        return Effect.fail(new SchemaIssue.AnyOf(ast, state.issues ?? [], input, options))
      }
      return Effect.flatMapEager(eff, (_) => {
        if (state.out === InternalParser.sameExit) return Effect.succeed(input)
        if (state.out) return state.out
        return Effect.fail(new SchemaIssue.AnyOf(ast, state.issues ?? [], input, options))
      })
    }
  }
  private _rebuild(recur: (ast: AST) => AST, checks: Checks | undefined, encodingChecks: Checks | undefined) {
    const types = mapOrSame(this.types, recur)
    return types === this.types && checks === this.checks && encodingChecks === this.encodingChecks ?