@clayroach/effect 3.19.14-source-capture.6 → 3.19.14-source-capture.8

package/src/internal/matcher.ts

@@ -1,652 +0,0 @@
-import * as Either from "../Either.js"
-import { dual, identity } from "../Function.js"
-import type {
-  Case,
-  Matcher,
-  MatcherTypeId,
-  Not,
-  SafeRefinement,
-  TypeMatcher,
-  Types,
-  ValueMatcher,
-  When
-} from "../Match.js"
-import * as Option from "../Option.js"
-import { pipeArguments } from "../Pipeable.js"
-import type * as Predicate from "../Predicate.js"
-import type { Unify } from "../Unify.js"
-
-/** @internal */
-export const TypeId: MatcherTypeId = Symbol.for(
-  "@effect/matcher/Matcher"
-) as MatcherTypeId
-
-const TypeMatcherProto: Omit<TypeMatcher<any, any, any, any>, "cases"> = {
-  [TypeId]: {
-    _input: identity,
-    _filters: identity,
-    _remaining: identity,
-    _result: identity,
-    _return: identity
-  },
-  _tag: "TypeMatcher",
-  add<I, R, RA, A>(
-    this: TypeMatcher<any, any, any, any>,
-    _case: Case
-  ): TypeMatcher<I, R, RA, A> {
-    return makeTypeMatcher([...this.cases, _case])
-  },
-  pipe() {
-    return pipeArguments(this, arguments)
-  }
-}
-
-function makeTypeMatcher<I, R, RA, A>(
-  cases: ReadonlyArray<Case>
-): TypeMatcher<I, R, RA, A> {
-  const matcher = Object.create(TypeMatcherProto)
-  matcher.cases = cases
-  return matcher
-}
-
-const ValueMatcherProto: Omit<
-  ValueMatcher<any, any, any, any, any>,
-  "provided" | "value"
-> = {
-  [TypeId]: {
-    _input: identity,
-    _filters: identity,
-    _remaining: identity,
-    _result: identity,
-    _provided: identity,
-    _return: identity
-  },
-  _tag: "ValueMatcher",
-  add<I, R, RA, A, Pr>(
-    this: ValueMatcher<any, any, any, any, any>,
-    _case: Case
-  ): ValueMatcher<I, R, RA, A, Pr> {
-    if (this.value._tag === "Right") {
-      return this
-    }
-
-    if (_case._tag === "When" && _case.guard(this.provided) === true) {
-      return makeValueMatcher(
-        this.provided,
-        Either.right(_case.evaluate(this.provided))
-      )
-    } else if (_case._tag === "Not" && _case.guard(this.provided) === false) {
-      return makeValueMatcher(
-        this.provided,
-        Either.right(_case.evaluate(this.provided))
-      )
-    }
-
-    return this
-  },
-  pipe() {
-    return pipeArguments(this, arguments)
-  }
-}
-
-function makeValueMatcher<I, R, RA, A, Pr>(
-  provided: Pr,
-  value: Either.Either<Pr, RA>
-): ValueMatcher<I, R, RA, A, Pr> {
-  const matcher = Object.create(ValueMatcherProto)
-  matcher.provided = provided
-  matcher.value = value
-  return matcher
-}
-
-const makeWhen = (
-  guard: (u: unknown) => boolean,
-  evaluate: (input: unknown) => any
-): When => ({
-  _tag: "When",
-  guard,
-  evaluate
-})
-
-const makeNot = (
-  guard: (u: unknown) => boolean,
-  evaluate: (input: unknown) => any
-): Not => ({
-  _tag: "Not",
-  guard,
-  evaluate
-})
-
-const makePredicate = (pattern: unknown): Predicate.Predicate<unknown> => {
-  if (typeof pattern === "function") {
-    return pattern as Predicate.Predicate<unknown>
-  } else if (Array.isArray(pattern)) {
-    const predicates = pattern.map(makePredicate)
-    const len = predicates.length
-
-    return (u: unknown) => {
-      if (!Array.isArray(u)) {
-        return false
-      }
-
-      for (let i = 0; i < len; i++) {
-        if (predicates[i](u[i]) === false) {
-          return false
-        }
-      }
-
-      return true
-    }
-  } else if (pattern !== null && typeof pattern === "object") {
-    const keysAndPredicates = Object.entries(pattern).map(
-      ([k, p]) => [k, makePredicate(p)] as const
-    )
-    const len = keysAndPredicates.length
-
-    return (u: unknown) => {
-      if (typeof u !== "object" || u === null) {
-        return false
-      }
-
-      for (let i = 0; i < len; i++) {
-        const [key, predicate] = keysAndPredicates[i]
-        if (!(key in u) || predicate((u as any)[key]) === false) {
-          return false
-        }
-      }
-
-      return true
-    }
-  }
-
-  return (u: unknown) => u === pattern
-}
-
-const makeOrPredicate = (
-  patterns: ReadonlyArray<unknown>
-): Predicate.Predicate<unknown> => {
-  const predicates = patterns.map(makePredicate)
-  const len = predicates.length
-
-  return (u: unknown) => {
-    for (let i = 0; i < len; i++) {
-      if (predicates[i](u) === true) {
-        return true
-      }
-    }
-
-    return false
-  }
-}
-
-const makeAndPredicate = (
-  patterns: ReadonlyArray<unknown>
-): Predicate.Predicate<unknown> => {
-  const predicates = patterns.map(makePredicate)
-  const len = predicates.length
-
-  return (u: unknown) => {
-    for (let i = 0; i < len; i++) {
-      if (predicates[i](u) === false) {
-        return false
-      }
-    }
-
-    return true
-  }
-}
-
-/** @internal */
-export const type = <I>(): Matcher<
-  I,
-  Types.Without<never>,
-  I,
-  never,
-  never
-> => makeTypeMatcher([])
-
-/** @internal */
-export const value = <const I>(
-  i: I
-): Matcher<I, Types.Without<never>, I, never, I> => makeValueMatcher(i, Either.left(i))
-
-/** @internal */
-export const valueTags: {
-  <
-    const I,
-    P extends
-      & { readonly [Tag in Types.Tags<"_tag", I> & string]: (_: Extract<I, { readonly _tag: Tag }>) => any }
-      & { readonly [Tag in Exclude<keyof P, Types.Tags<"_tag", I>>]: never }
-  >(fields: P): (input: I) => Unify<ReturnType<P[keyof P]>>
-  <
-    const I,
-    P extends
-      & { readonly [Tag in Types.Tags<"_tag", I> & string]: (_: Extract<I, { readonly _tag: Tag }>) => any }
-      & { readonly [Tag in Exclude<keyof P, Types.Tags<"_tag", I>>]: never }
-  >(input: I, fields: P): Unify<ReturnType<P[keyof P]>>
-} = dual(
-  2,
-  <
-    const I,
-    P extends
-      & { readonly [Tag in Types.Tags<"_tag", I> & string]: (_: Extract<I, { readonly _tag: Tag }>) => any }
-      & { readonly [Tag in Exclude<keyof P, Types.Tags<"_tag", I>>]: never }
-  >(input: I, fields: P): Unify<ReturnType<P[keyof P]>> => {
-    const match: any = tagsExhaustive(fields as any)(makeTypeMatcher([]))
-    return match(input)
-  }
-)
-
-/** @internal */
-export const typeTags = <I>() =>
-<
-  P extends {
-    readonly [Tag in Types.Tags<"_tag", I> & string]: (
-      _: Extract<I, { readonly _tag: Tag }>
-    ) => any
-  }
->(
-  fields: P
-) => {
-  const match: any = tagsExhaustive(fields as any)(makeTypeMatcher([]))
-  return (input: I): Unify<ReturnType<P[keyof P]>> => match(input)
-}
-
-/** @internal */
-export const withReturnType = <Ret>() =>
-<I, F, R, A, Pr, _>(self: Matcher<I, F, R, A, Pr, _>): [Ret] extends [
-  [A] extends [never] ? any : A
-] ? Matcher<I, F, R, A, Pr, Ret>
-  : "withReturnType constraint does not extend Result type" => self as any
-
-/** @internal */
-export const when = <
-  R,
-  const P extends Types.PatternPrimitive<R> | Types.PatternBase<R>,
-  Ret,
-  Fn extends (_: Types.WhenMatch<R, P>) => Ret
->(
-  pattern: P,
-  f: Fn
-) =>
-<I, F, A, Pr>(
-  self: Matcher<I, F, R, A, Pr, Ret>
-): Matcher<
-  I,
-  Types.AddWithout<F, Types.PForExclude<P>>,
-  Types.ApplyFilters<I, Types.AddWithout<F, Types.PForExclude<P>>>,
-  A | ReturnType<Fn>,
-  Pr,
-  Ret
-> => (self as any).add(makeWhen(makePredicate(pattern), f as any))
-
-/** @internal */
-export const whenOr = <
-  R,
-  const P extends ReadonlyArray<
-    Types.PatternPrimitive<R> | Types.PatternBase<R>
-  >,
-  Ret,
-  Fn extends (_: Types.WhenMatch<R, P[number]>) => Ret
->(
-  ...args: [...patterns: P, f: Fn]
-) =>
-<I, F, A, Pr>(
-  self: Matcher<I, F, R, A, Pr, Ret>
-): Matcher<
-  I,
-  Types.AddWithout<F, Types.PForExclude<P[number]>>,
-  Types.ApplyFilters<I, Types.AddWithout<F, Types.PForExclude<P[number]>>>,
-  A | ReturnType<Fn>,
-  Pr,
-  Ret
-> => {
-  const onMatch = args[args.length - 1] as any
-  const patterns = args.slice(0, -1) as unknown as P
-  return (self as any).add(makeWhen(makeOrPredicate(patterns), onMatch))
-}
-
-/** @internal */
-export const whenAnd = <
-  R,
-  const P extends ReadonlyArray<
-    Types.PatternPrimitive<R> | Types.PatternBase<R>
-  >,
-  Ret,
-  Fn extends (_: Types.WhenMatch<R, Types.ArrayToIntersection<P>>) => Ret
->(
-  ...args: [...patterns: P, f: Fn]
-) =>
-<I, F, A, Pr>(
-  self: Matcher<I, F, R, A, Pr, Ret>
-): Matcher<
-  I,
-  Types.AddWithout<F, Types.PForExclude<Types.ArrayToIntersection<P>>>,
-  Types.ApplyFilters<
-    I,
-    Types.AddWithout<F, Types.PForExclude<Types.ArrayToIntersection<P>>>
-  >,
-  A | ReturnType<Fn>,
-  Pr
-> => {
-  const onMatch = args[args.length - 1] as any
-  const patterns = args.slice(0, -1) as unknown as P
-  return (self as any).add(makeWhen(makeAndPredicate(patterns), onMatch))
-}
-
-/** @internal */
-export const discriminator = <D extends string>(field: D) =>
-<
-  R,
-  P extends Types.Tags<D, R> & string,
-  Ret,
-  Fn extends (_: Extract<R, Record<D, P>>) => Ret
->(
-  ...pattern: [
-    first: P,
-    ...values: Array<P>,
-    f: Fn
-  ]
-) => {
-  const f = pattern[pattern.length - 1]
-  const values: Array<P> = pattern.slice(0, -1) as any
-  const pred = values.length === 1
-    ? (_: any) => _[field] === values[0]
-    : (_: any) => values.includes(_[field])
-
-  return <I, F, A, Pr>(
-    self: Matcher<I, F, R, A, Pr, Ret>
-  ): Matcher<
-    I,
-    Types.AddWithout<F, Extract<R, Record<D, P>>>,
-    Types.ApplyFilters<I, Types.AddWithout<F, Extract<R, Record<D, P>>>>,
-    A | ReturnType<Fn>,
-    Pr,
-    Ret
-  > => (self as any).add(makeWhen(pred, f as any)) as any
-}
-
-/** @internal */
-export const discriminatorStartsWith = <D extends string>(field: D) =>
-<
-  R,
-  P extends string,
-  Ret,
-  Fn extends (_: Extract<R, Record<D, `${P}${string}`>>) => Ret
->(
-  pattern: P,
-  f: Fn
-) => {
-  const pred = (_: any) => typeof _[field] === "string" && _[field].startsWith(pattern)
-
-  return <I, F, A, Pr>(
-    self: Matcher<I, F, R, A, Pr, Ret>
-  ): Matcher<
-    I,
-    Types.AddWithout<F, Extract<R, Record<D, `${P}${string}`>>>,
-    Types.ApplyFilters<
-      I,
-      Types.AddWithout<F, Extract<R, Record<D, `${P}${string}`>>>
-    >,
-    A | ReturnType<Fn>,
-    Pr,
-    Ret
-  > => (self as any).add(makeWhen(pred, f as any)) as any
-}
-
-/** @internal */
-export const discriminators = <D extends string>(field: D) =>
-<
-  R,
-  Ret,
-  P extends
-    & {
-      readonly [Tag in Types.Tags<D, R> & string]?:
-        | ((_: Extract<R, Record<D, Tag>>) => Ret)
-        | undefined
-    }
-    & { readonly [Tag in Exclude<keyof P, Types.Tags<D, R>>]: never }
->(
-  fields: P
-) => {
-  const predicate = makeWhen(
-    (arg: any) => arg != null && arg[field] in fields,
-    (data: any) => (fields as any)[data[field]](data)
-  )
-
-  return <I, F, A, Pr>(
-    self: Matcher<I, F, R, A, Pr, Ret>
-  ): Matcher<
-    I,
-    Types.AddWithout<F, Extract<R, Record<D, keyof P>>>,
-    Types.ApplyFilters<I, Types.AddWithout<F, Extract<R, Record<D, keyof P>>>>,
-    A | ReturnType<P[keyof P] & {}>,
-    Pr,
-    Ret
-  > => (self as any).add(predicate)
-}
-
-/** @internal */
-export const discriminatorsExhaustive: <D extends string>(
-  field: D
-) => <
-  R,
-  Ret,
-  P extends
-    & {
-      readonly [Tag in Types.Tags<D, R> & string]: (
-        _: Extract<R, Record<D, Tag>>
-      ) => Ret
-    }
-    & { readonly [Tag in Exclude<keyof P, Types.Tags<D, R>>]: never }
->(
-  fields: P
-) => <I, F, A, Pr>(
-  self: Matcher<I, F, R, A, Pr, Ret>
-) => [Pr] extends [never] ? (u: I) => Unify<A | ReturnType<P[keyof P]>>
-  : Unify<A | ReturnType<P[keyof P]>> = (field: string) => (fields: object) => {
-    const addCases = discriminators(field)(fields)
-    return (matcher: any) => exhaustive(addCases(matcher))
-  }
-
-/** @internal */
-export const tag: <
-  R,
-  P extends Types.Tags<"_tag", R> & string,
-  Ret,
-  Fn extends (_: Extract<R, Record<"_tag", P>>) => Ret
->(
-  ...pattern: [
-    first: P,
-    ...values: Array<P>,
-    f: Fn
-  ]
-) => <I, F, A, Pr>(
-  self: Matcher<I, F, R, A, Pr, Ret>
-) => Matcher<
-  I,
-  Types.AddWithout<F, Extract<R, Record<"_tag", P>>>,
-  Types.ApplyFilters<I, Types.AddWithout<F, Extract<R, Record<"_tag", P>>>>,
-  ReturnType<Fn> | A,
-  Pr,
-  Ret
-> = discriminator("_tag")
-
-/** @internal */
-export const tagStartsWith = discriminatorStartsWith("_tag")
-
-/** @internal */
-export const tags = discriminators("_tag")
-
-/** @internal */
-export const tagsExhaustive = discriminatorsExhaustive("_tag")
-
-/** @internal */
-export const not = <
-  R,
-  const P extends Types.PatternPrimitive<R> | Types.PatternBase<R>,
-  Ret,
-  Fn extends (_: Types.NotMatch<R, P>) => Ret
->(
-  pattern: P,
-  f: Fn
-) =>
-<I, F, A, Pr>(
-  self: Matcher<I, F, R, A, Pr, Ret>
-): Matcher<
-  I,
-  Types.AddOnly<F, Types.WhenMatch<R, P>>,
-  Types.ApplyFilters<I, Types.AddOnly<F, Types.WhenMatch<R, P>>>,
-  A | ReturnType<Fn>,
-  Pr,
-  Ret
-> => (self as any).add(makeNot(makePredicate(pattern), f as any))
-
-/** @internal */
-export const nonEmptyString: SafeRefinement<string, never> =
-  ((u: unknown) => typeof u === "string" && u.length > 0) as any
-
-/** @internal */
-export const is: <
-  Literals extends ReadonlyArray<string | number | boolean | null | bigint>
->(
-  ...literals: Literals
-) => SafeRefinement<Literals[number]> = (...literals): any => {
-  const len = literals.length
-  return (u: unknown) => {
-    for (let i = 0; i < len; i++) {
-      if (u === literals[i]) {
-        return true
-      }
-    }
-    return false
-  }
-}
-
-/** @internal */
-export const any: SafeRefinement<unknown, any> = (() => true) as any
-
-/** @internal */
-export const defined = <A>(u: A): u is A & {} => (u !== undefined && u !== null) as any
-
-/** @internal */
-export const instanceOf = <A extends abstract new(...args: any) => any>(
-  constructor: A
-): SafeRefinement<InstanceType<A>, never> => ((u: unknown) => u instanceof constructor) as any
-
-/** @internal */
-export const instanceOfUnsafe: <A extends abstract new(...args: any) => any>(
-  constructor: A
-) => SafeRefinement<InstanceType<A>, InstanceType<A>> = instanceOf
-
-/** @internal */
-export const orElse =
-  <RA, Ret, F extends (_: RA) => Ret>(f: F) =>
-  <I, R, A, Pr>(self: Matcher<I, R, RA, A, Pr, Ret>): [Pr] extends [never] ? (input: I) => Unify<ReturnType<F> | A>
-    : Unify<ReturnType<F> | A> =>
-  {
-    const result = either(self)
-
-    if (Either.isEither(result)) {
-      // @ts-expect-error
-      return result._tag === "Right" ? result.right : f(result.left)
-    }
-
-    // @ts-expect-error
-    return (input: I) => {
-      const a = result(input)
-      return a._tag === "Right" ? a.right : f(a.left)
-    }
-  }
-
-/** @internal */
-export const orElseAbsurd = <I, R, RA, A, Pr, Ret>(
-  self: Matcher<I, R, RA, A, Pr, Ret>
-): [Pr] extends [never] ? (input: I) => Unify<A> : Unify<A> =>
-  orElse(() => {
-    throw new Error("effect/Match/orElseAbsurd: absurd")
-  })(self)
-
-/** @internal */
-export const either: <I, F, R, A, Pr, Ret>(
-  self: Matcher<I, F, R, A, Pr, Ret>
-) => [Pr] extends [never] ? (input: I) => Either.Either<Unify<A>, R>
-  : Either.Either<Unify<A>, R> = (<I, R, RA, A>(self: Matcher<I, R, RA, A, I>) => {
-    if (self._tag === "ValueMatcher") {
-      return self.value
-    }
-
-    const len = self.cases.length
-    if (len === 1) {
-      const _case = self.cases[0]
-      return (input: I): Either.Either<A, RA> => {
-        if (_case._tag === "When" && _case.guard(input) === true) {
-          return Either.right(_case.evaluate(input))
-        } else if (_case._tag === "Not" && _case.guard(input) === false) {
-          return Either.right(_case.evaluate(input))
-        }
-        return Either.left(input as any)
-      }
-    }
-    return (input: I): Either.Either<A, RA> => {
-      for (let i = 0; i < len; i++) {
-        const _case = self.cases[i]
-        if (_case._tag === "When" && _case.guard(input) === true) {
-          return Either.right(_case.evaluate(input))
-        } else if (_case._tag === "Not" && _case.guard(input) === false) {
-          return Either.right(_case.evaluate(input))
-        }
-      }
-
-      return Either.left(input as any)
-    }
-  }) as any
-
-/** @internal */
-export const option: <I, F, R, A, Pr, Ret>(
-  self: Matcher<I, F, R, A, Pr, Ret>
-) => [Pr] extends [never] ? (input: I) => Option.Option<Unify<A>>
-  : Option.Option<Unify<A>> = (<I, A>(self: Matcher<I, any, any, A, I>) => {
-    const toEither = either(self)
-    if (Either.isEither(toEither)) {
-      return Either.match(toEither, {
-        onLeft: () => Option.none(),
-        onRight: Option.some
-      })
-    }
-    return (input: I): Option.Option<A> =>
-      Either.match((toEither as any)(input), {
-        onLeft: () => Option.none(),
-        onRight: Option.some as any
-      })
-  }) as any
-
-const getExhaustiveAbsurdErrorMessage = "effect/Match/exhaustive: absurd"
-
-/** @internal */
-export const exhaustive: <I, F, A, Pr, Ret>(
-  self: Matcher<I, F, never, A, Pr, Ret>
-) => [Pr] extends [never] ? (u: I) => Unify<A> : Unify<A> = (<I, F, A>(
-  self: Matcher<I, F, never, A, I>
-) => {
-  const toEither = either(self as any)
-
-  if (Either.isEither(toEither)) {
-    if (toEither._tag === "Right") {
-      return toEither.right
-    }
-
-    throw new Error(getExhaustiveAbsurdErrorMessage)
-  }
-
-  return (u: I): A => {
-    // @ts-expect-error
-    const result = toEither(u)
-
-    if (result._tag === "Right") {
-      return result.right as any
-    }
-
-    throw new Error(getExhaustiveAbsurdErrorMessage)
-  }
-}) as any