@ossedb/patmat - v1.0.0
    Preparing search index...

    Variable PConst

    P: {
        _: Pat<unknown, {}>;
        array: {
            (): Pat<unknown[], {}>;
            <const Pt extends Pattern>(element: Pt): Pat<MatchedOf<Pt>[], {}>;
        };
        bind: {
            <N extends string>(name: N): Pat<unknown, { [K in string]: unknown }>;
            <N extends string, const Pt extends Pattern>(
                name: N,
                inner: Pt,
            ): Pat<
                MatchedOf<Pt>,
                {
                    [K in string | number | symbol]: (
                        { [K in string]: MatchedOf<Pt> } & (
                            Pt extends Pat<unknown, C>
                                ? { [K in string | number | symbol]: C[K] }
                                : Pt extends Primitive
                                    ? {}
                                    : Pt extends readonly unknown[]
                                        ? { [K in (...)
                                        | (...)
                                        | (...)]: (...)[(...)] }
                                        : Pt extends object ? { [K in (...)]: (...) } : {}
                        )
                    )[K]
                },
            >;
        };
        boolean: Pat<boolean, {}>;
        instanceOf: <T>(ctor: new (...args: never[]) => T) => Pat<T, {}>;
        nullish: Pat<null | undefined, {}>;
        number: Pat<number, {}>;
        range: (lo: number, hi: number) => Pat<number, {}>;
        rest: {
            (): RestPattern<undefined>;
            <N extends string>(name: N): RestPattern<N>;
        };
        string: Pat<string, {}>;
        union: <const Pts extends readonly Pattern[]>(
            ...patterns: Pts,
        ) => Pat<
            MatchedOf<Pts[number]>,
            Partial<
                {
                    [K in string
                    | number
                    | symbol]: UnionToIntersection<
                        | {}
                        | (
                            Pts[number] extends Pat<unknown, C>
                                ? { [K in (...) | (...) | (...)]: (...)[(...)] }
                                : (...)[(...)] extends Primitive
                                    ? {}
                                    : (...) extends (...) ? (...) : (...)
                        ),
                    >[K]
                },
            >,
        >;
        when: {
            <T>(predicate: (value: unknown) => value is T): Pat<T, {}>;
            <T>(predicate: (value: T) => boolean): Pat<T, {}>;
        };
    } = ...

    The pattern combinators.

    Combinator Matches
    P._ anything (wildcard)
    P.number, P.string, P.boolean values of that primitive type
    P.nullish null or undefined
    P.bind(name, pattern?) anything (or the inner pattern), capturing the value
    P.rest(name?) the remaining elements of an array pattern
    P.array(element?) arrays (of elements matching element)
    P.range(lo, hi) numbers in the inclusive range
    P.when(predicate) values satisfying the predicate
    P.union(...patterns) values matching any branch
    P.instanceOf(Class) instances of Class

    Type Declaration

    • Readonly_: Pat<unknown, {}>
    • array: {
          (): Pat<unknown[], {}>;
          <const Pt extends Pattern>(element: Pt): Pat<MatchedOf<Pt>[], {}>;
      }
    • bind: {
          <N extends string>(name: N): Pat<unknown, { [K in string]: unknown }>;
          <N extends string, const Pt extends Pattern>(
              name: N,
              inner: Pt,
          ): Pat<
              MatchedOf<Pt>,
              {
                  [K in string | number | symbol]: (
                      { [K in string]: MatchedOf<Pt> } & (
                          Pt extends Pat<unknown, C>
                              ? { [K in string | number | symbol]: C[K] }
                              : Pt extends Primitive
                                  ? {}
                                  : Pt extends readonly unknown[]
                                      ? { [K in (...)
                                      | (...)
                                      | (...)]: (...)[(...)] }
                                      : Pt extends object ? { [K in (...)]: (...) } : {}
                      )
                  )[K]
              },
          >;
      }
    • Readonlyboolean: Pat<boolean, {}>
    • instanceOf: <T>(ctor: new (...args: never[]) => T) => Pat<T, {}>
    • Readonlynullish: Pat<null | undefined, {}>
    • Readonlynumber: Pat<number, {}>
    • range: (lo: number, hi: number) => Pat<number, {}>
    • rest: { (): RestPattern<undefined>; <N extends string>(name: N): RestPattern<N> }
    • Readonlystring: Pat<string, {}>
    • union: <const Pts extends readonly Pattern[]>(
          ...patterns: Pts,
      ) => Pat<
          MatchedOf<Pts[number]>,
          Partial<
              {
                  [K in string
                  | number
                  | symbol]: UnionToIntersection<
                      | {}
                      | (
                          Pts[number] extends Pat<unknown, C>
                              ? { [K in (...) | (...) | (...)]: (...)[(...)] }
                              : (...)[(...)] extends Primitive
                                  ? {}
                                  : (...) extends (...) ? (...) : (...)
                      ),
                  >[K]
              },
          >,
      >
    • when: {
          <T>(predicate: (value: unknown) => value is T): Pat<T, {}>;
          <T>(predicate: (value: T) => boolean): Pat<T, {}>;
      }

    Settings
    Member Visibility