>;
+): (value: unknown) => value is P.infer;
/**
* `isMatching` takes pattern and a value and checks if the value matches this pattern.
*
@@ -34,10 +33,10 @@ export function isMatching
>(
* return input.name
* }
*/
-export function isMatching
>(
+export function isMatching
>(
pattern: p,
- value: any
-): value is MatchedValue>;
+ value: unknown
+): value is P.infer;
export function isMatching
>(
...args: [pattern: p, value?: any]
diff --git a/src/match.ts b/src/match.ts
index 8ebeefc0..f4b94d5d 100644
--- a/src/match.ts
+++ b/src/match.ts
@@ -1,17 +1,14 @@
import { Pattern } from './types/Pattern';
-import { GuardValue } from './types/helpers';
-import { Match, PickReturnValue } from './types/Match';
+import { Match } from './types/Match';
import * as symbols from './internals/symbols';
import { matchPattern } from './internals/helpers';
/**
* `match` creates a **pattern matching expression**.
+ * * Use `.with(pattern, handler)` to pattern match on the input.
+ * * Use `.exhaustive()` or `.otherwise(() => defaultValue)` to end the expression and get the result.
*
- * Use `.with(pattern, handler)` to pattern match on the input.
- *
- * Use `.exhaustive()` or `.otherwise(() => defaultValue)` to end the expression and get the result.
- *
- * [Read documentation for `match` on GitHub](https://github.com/gvergnaud/ts-pattern#match)
+ * [Read the documentation for `match` on GitHub](https://github.com/gvergnaud/ts-pattern#match)
*
* @example
* declare let input: "A" | "B";
@@ -22,18 +19,21 @@ import { matchPattern } from './internals/helpers';
* .exhaustive();
*
*/
-export function match;
-export function match(
- value: input
-): Match;
-export function match(
+export function match(
value: input
): Match {
- return new MatchExpression(value, []) as any;
+ return new MatchExpression(value) as any;
}
+type MatchState =
+ | { matched: true; value: output }
+ | { matched: false; value: undefined };
+
+const unmatched: MatchState = {
+ matched: false,
+ value: undefined,
+};
+
/**
* This class represents a match expression. It follows the
* builder pattern, we chain methods to add features to the expression
@@ -43,20 +43,20 @@ export function match(
* The types of this class aren't public, the public type definition
* can be found in src/types/Match.ts.
*/
-class MatchExpression {
+class MatchExpression {
constructor(
- private value: i,
- private cases: {
- match: (value: i) => { matched: boolean; value: any };
- handler: (...args: any) => any;
- }[]
+ private input: input,
+ private state: MatchState = unmatched
) {}
- with(...args: any[]) {
- const handler = args[args.length - 1];
+ with(...args: any[]): MatchExpression {
+ if (this.state.matched) return this;
+
+ const handler: (selection: unknown, value: input) => output =
+ args[args.length - 1];
- const patterns: Pattern[] = [args[0]];
- const predicates: ((value: i) => unknown)[] = [];
+ const patterns: Pattern {
patterns.push(...args.slice(1, args.length - 1));
}
- return new MatchExpression(
- this.value,
- this.cases.concat([
- {
- match: (value: i) => {
- let selected: Record = {};
- const matched = Boolean(
- patterns.some((pattern) =>
- matchPattern(pattern, value, (key, value) => {
- selected[key] = value;
- })
- ) && predicates.every((predicate) => predicate(value as any))
- );
- return {
- matched,
- value:
- matched && Object.keys(selected).length
- ? symbols.anonymousSelectKey in selected
- ? selected[symbols.anonymousSelectKey]
- : selected
- : value,
- };
- },
- handler,
- },
- ])
+ let selected: Record = {};
+
+ const matched = Boolean(
+ patterns.some((pattern) =>
+ matchPattern(pattern, this.input, (key, value) => {
+ selected[key] = value;
+ })
+ ) && predicates.every((predicate) => predicate(this.input))
);
+
+ const state = matched
+ ? {
+ matched: true as const,
+ value: handler(
+ Object.keys(selected).length
+ ? symbols.anonymousSelectKey in selected
+ ? selected[symbols.anonymousSelectKey]
+ : selected
+ : this.input,
+ this.input
+ ),
+ }
+ : unmatched;
+
+ return new MatchExpression(this.input, state);
}
- when unknown, c>(
- predicate: p,
- handler: (value: GuardValue
) => PickReturnValue
- ) {
- return new MatchExpression>(
- this.value,
- this.cases.concat([
- {
- match: (value) => ({
- matched: Boolean(predicate(value)),
- value,
- }),
- handler,
- },
- ])
+ when(
+ predicate: (value: input) => unknown,
+ handler: (selection: input, value: input) => output
+ ): MatchExpression {
+ if (this.state.matched) return this;
+
+ const matched = Boolean(predicate(this.input));
+
+ return new MatchExpression(
+ this.input,
+ matched
+ ? { matched: true, value: handler(this.input, this.input) }
+ : unmatched
);
}
- otherwise(
- handler: (value: i) => PickReturnValue
- ): PickReturnValue {
- return new MatchExpression>(
- this.value,
- this.cases.concat([
- {
- match: (value) => ({
- matched: true,
- value,
- }),
- handler,
- },
- ])
- ).run();
+ otherwise(handler: (value: input) => output): output {
+ if (this.state.matched) return this.state.value;
+ return handler(this.input);
}
- exhaustive() {
+ exhaustive(): output {
return this.run();
}
- run() {
- let selected = this.value;
- let handler: undefined | ((...args: any) => any) = undefined;
-
- for (let i = 0; i < this.cases.length; i++) {
- const entry = this.cases[i];
- const matchResult = entry.match(this.value);
- if (matchResult.matched) {
- selected = matchResult.value;
- handler = entry.handler;
- break;
- }
- }
- if (!handler) {
- let displayedValue;
- try {
- displayedValue = JSON.stringify(this.value);
- } catch (e) {
- displayedValue = this.value;
- }
- throw new Error(
- `Pattern matching error: no pattern matches value ${displayedValue}`
- );
+ run(): output {
+ if (this.state.matched) return this.state.value;
+
+ let displayedValue;
+ try {
+ displayedValue = JSON.stringify(this.input);
+ } catch (e) {
+ displayedValue = this.input;
}
- return handler(selected, this.value);
+
+ throw new Error(
+ `Pattern matching error: no pattern matches value ${displayedValue}`
+ );
+ }
+
+ returnType() {
+ return this;
}
}
diff --git a/src/patterns.ts b/src/patterns.ts
index 35621fc6..4003e83b 100644
--- a/src/patterns.ts
+++ b/src/patterns.ts
@@ -1,12 +1,17 @@
import { matchPattern, getSelectionKeys, flatMap } from './internals/helpers';
import * as symbols from './internals/symbols';
-import { GuardFunction, IsNever, Primitives } from './types/helpers';
+import { matcher } from './internals/symbols';
+import { isMatching } from './is-matching';
+import { ExtractPreciseValue } from './types/ExtractPreciseValue';
+import { Fn } from './types/helpers';
import { InvertPattern } from './types/InvertPattern';
import {
Pattern,
UnknownPattern,
OptionalP,
ArrayP,
+ MapP,
+ SetP,
AndP,
OrP,
NotP,
@@ -14,40 +19,228 @@ import {
SelectP,
AnonymousSelectP,
GuardExcludeP,
+ CustomP,
+ Matcher,
} from './types/Pattern';
-export { Pattern };
+export { Pattern, Fn as unstable_Fn };
+
+export { matcher };
+
+/**
+ * @experimental
+ * A `Matchable` is an object implementing
+ * the Matcher Protocol. It must have a `[P.matcher]: P.Matcher`
+ * key, which defines how this object should be matched by TS-Pattern.
+ *
+ * Note that this api is unstable.
+ *
+ * @example
+ * ```ts
+ * class Some implements P.unstable_Matchable {
+ * [P.matcher](): P.unstable_Matcher>
+ * }
+ * ```
+ */
+export type unstable_Matchable<
+ narrowedOrFn,
+ input = unknown,
+ pattern = never
+> = CustomP;
+
+/**
+ * @experimental
+ * A `Matcher` is an object with `match` function, which
+ * defines how this object should be matched by TS-Pattern.
+ *
+ * Note that this api is unstable.
+ *
+ * @example
+ * ```ts
+ * class Some implements P.unstable_Matchable {
+ * [P.matcher](): P.unstable_Matcher>
+ * }
+ * ```
+ */
+export type unstable_Matcher<
+ narrowedOrFn,
+ input = unknown,
+ pattern = never
+> = ReturnType[matcher]>;
/**
* `P.infer` will return the type of the value
* matched by this pattern.
*
- * [Read documentation for `P.infer` on GitHub](https://github.com/gvergnaud/ts-pattern#Pinfer)
+ * [Read the documentation for `P.infer` on GitHub](https://github.com/gvergnaud/ts-pattern#Pinfer)
*
* @example
* const userPattern = { name: P.string }
* type User = P.infer
*/
-export type infer> = InvertPattern
;
+export type infer
> = InvertPattern;
+
+export type narrow> = ExtractPreciseValue<
+ i,
+ InvertPattern
+>;
+
+type Chainable = p &
+ Omit<
+ {
+ /**
+ * `.optional()` returns a pattern which matches if the
+ * key is undefined or if it is defined and the previous pattern matches its value.
+ *
+ * [Read the documentation for `P.optional` on GitHub](https://github.com/gvergnaud/ts-pattern#Poptional-patterns)
+ *
+ * @example
+ * match(value)
+ * .with({ greeting: P.string.optional() }, () => 'will match { greeting?: string}')
+ */
+ optional, omitted | 'optional'>;
+ /**
+ * `pattern.and(pattern)` returns a pattern that matches
+ * if the previous pattern and the next one match the input.
+ *
+ * [Read the documentation for `P.intersection` on GitHub](https://github.com/gvergnaud/ts-pattern#Pintersection-patterns)
+ *
+ * @example
+ * match(value)
+ * .with(
+ * P.string.and(P.when(isUsername)),
+ * (username) => '...'
+ * )
+ */
+ and>(
+ pattern: p2
+ ): Chainable, omitted>;
+ /**
+ * `pattern.or(pattern)` returns a pattern that matches
+ * if **either** the previous pattern or the next one match the input.
+ *
+ * [Read the documentation for `P.union` on GitHub](https://github.com/gvergnaud/ts-pattern#Punion-patterns)
+ *
+ * @example
+ * match(value)
+ * .with(
+ * { value: P.string.or(P.number) },
+ * ({ value }) => 'value: number | string'
+ * )
+ */
+ or>(
+ pattern: p2
+ ): Chainable, omitted>;
+ /**
+ * `P.select()` will inject this property into the handler function's arguments.
+ *
+ * [Read the documentation for `P.select` on GitHub](https://github.com/gvergnaud/ts-pattern#Pselect-patterns)
+ *
+ * @example
+ * match<{ age: number }>(value)
+ * .with({ age: P.string.select() }, (age) => 'age: number')
+ */
+ select,
+ omitted | 'select' | 'or' | 'and'
+ >;
+ select(
+ key: k
+ ): Chainable, omitted | 'select' | 'or' | 'and'>;
+ },
+ omitted
+ >;
+
+function chainable>(
+ pattern: p
+): Chainable
{
+ return Object.assign(pattern, {
+ optional: () => optional(pattern),
+ and: (p2: any) => intersection(pattern, p2),
+ or: (p2: any) => union(pattern, p2),
+ select: (key: any) =>
+ key === undefined ? select(pattern) : select(key, pattern),
+ }) as Chainable
;
+}
+
+type Variadic
= p & Iterable
;
+
+const variadic =
(pattern: p): Variadic
=>
+ Object.assign(pattern, {
+ *[Symbol.iterator]() {
+ yield Object.assign(pattern, {
+ [symbols.isVariadic]: true,
+ });
+ },
+ });
+
+type ArrayChainable = Variadic &
+ Omit<
+ {
+ /**
+ * `.optional()` returns a pattern which matches if the
+ * key is undefined or if it is defined and the previous pattern matches its value.
+ *
+ * [Read the documentation for `P.optional` on GitHub](https://github.com/gvergnaud/ts-pattern#Poptional-patterns)
+ *
+ * @example
+ * match(value)
+ * .with({ greeting: P.string.optional() }, () => 'will match { greeting?: string}')
+ */
+ optional,
+ omitted | 'optional'
+ >;
+ /**
+ * `P.select()` will inject this property into the handler function's arguments.
+ *
+ * [Read the documentation for `P.select` on GitHub](https://github.com/gvergnaud/ts-pattern#Pselect-patterns)
+ *
+ * @example
+ * match<{ age: number }>(value)
+ * .with({ age: P.string.select() }, (age) => 'age: number')
+ */
+ select,
+ omitted | 'select'
+ >;
+ select(
+ key: k
+ ): Chainable, omitted | 'select'>;
+ },
+ omitted
+ >;
+
+function arrayChainable>(
+ pattern: p
+): ArrayChainable
{
+ return Object.assign(variadic(pattern), {
+ optional: () => arrayChainable(optional(pattern)),
+ select: (key: any) =>
+ arrayChainable(
+ key === undefined ? select(pattern) : select(key, pattern)
+ ),
+ }) as any;
+}
/**
* `P.optional(subpattern)` takes a sub pattern and returns a pattern which matches if the
* key is undefined or if it is defined and the sub pattern matches its value.
*
- * [Read documentation for `P.optional` on GitHub](https://github.com/gvergnaud/ts-pattern#Poptional-patterns)
-
-* @example
+ * [Read the documentation for `P.optional` on GitHub](https://github.com/gvergnaud/ts-pattern#Poptional-patterns)
+ *
+ * @example
* match(value)
* .with({ greeting: P.optional('Hello') }, () => 'will match { greeting?: "Hello" }')
*/
export function optional<
input,
- p extends unknown extends input ? UnknownPattern : Pattern {
- return {
- [symbols.matcher]() {
+ const p extends unknown extends input ? UnknownPattern : Pattern, 'optional'> {
+ return chainable({
+ [matcher]() {
return {
- match: (value: I | input) => {
+ match: (value: UnknownInput | input) => {
let selections: Record = {};
const selector = (key: string, value: any) => {
selections[key] = value;
@@ -65,31 +258,46 @@ export function optional<
matcherType: 'optional',
};
},
- };
+ });
}
-type Elem = xs extends readonly (infer x)[] ? x : never;
+type UnwrapArray = xs extends readonly (infer x)[] ? x : never;
+
+type UnwrapSet = xs extends Set ? x : never;
+
+type UnwrapMapKey = xs extends Map ? k : never;
+
+type UnwrapMapValue = xs extends Map ? v : never;
+
+type WithDefault = [a] extends [never] ? b : a;
/**
* `P.array(subpattern)` takes a sub pattern and returns a pattern, which matches
* arrays if all their elements match the sub pattern.
*
- * [Read documentation for `P.array` on GitHub](https://github.com/gvergnaud/ts-pattern#Parray-patterns)
+ * [Read the documentation for `P.array` on GitHub](https://github.com/gvergnaud/ts-pattern#Parray-patterns)
*
* @example
* match(value)
* .with({ users: P.array({ name: P.string }) }, () => 'will match { name: string }[]')
*/
+export function array>;
export function array<
input,
- p extends unknown extends input ? UnknownPattern : Pattern>
->(pattern: p): ArrayP {
- return {
- [symbols.matcher]() {
+ const p extends Pattern, unknown>>
+>(pattern: p): ArrayChainable>;
+export function array(
+ ...args: [pattern?: any]
+): ArrayChainable> {
+ return arrayChainable({
+ [matcher]() {
return {
- match: (value: I | input) => {
+ match: (value: any) => {
if (!Array.isArray(value)) return { matched: false };
+ if (args.length === 0) return { matched: true };
+
+ const pattern = args[0];
let selections: Record = {};
if (value.length === 0) {
@@ -109,17 +317,153 @@ export function array<
return { matched, selections };
},
- getSelectionKeys: () => getSelectionKeys(pattern),
+ getSelectionKeys: () =>
+ args.length === 0 ? [] : getSelectionKeys(args[0]),
};
},
- };
+ });
+}
+
+/**
+ * `P.set(subpattern)` takes a sub pattern and returns a pattern that matches
+ * sets if all their elements match the sub pattern.
+ *
+ * [Read `P.set` documentation on GitHub](https://github.com/gvergnaud/ts-pattern#Pset-patterns)
+ *
+ * @example
+ * match(value)
+ * .with({ users: P.set(P.string) }, () => 'will match Set')
+ */
+export function set>;
+export function set<
+ input,
+ const p extends Pattern, unknown>>
+>(pattern: p): Chainable>;
+export function set<
+ input,
+ const p extends Pattern, unknown>>
+>(...args: [pattern?: p]): Chainable> {
+ return chainable({
+ [matcher]() {
+ return {
+ match: (value: UnknownInput | input) => {
+ if (!(value instanceof Set)) return { matched: false };
+
+ let selections: Record = {};
+
+ if (value.size === 0) {
+ return { matched: true, selections };
+ }
+
+ if (args.length === 0) return { matched: true };
+
+ const selector = (key: string, value: unknown) => {
+ selections[key] = (selections[key] || []).concat([value]);
+ };
+
+ const pattern = args[0];
+
+ const matched = setEvery(value, (v) =>
+ matchPattern(pattern, v, selector)
+ );
+
+ return { matched, selections };
+ },
+ getSelectionKeys: () =>
+ args.length === 0 ? [] : getSelectionKeys(args[0]),
+ };
+ },
+ });
+}
+
+const setEvery = (set: Set, predicate: (value: T) => boolean) => {
+ for (const value of set) {
+ if (predicate(value)) continue;
+ return false;
+ }
+ return true;
+};
+
+/**
+ * `P.set(subpattern)` takes a sub pattern and returns a pattern that matches
+ * sets if all their elements match the sub pattern.
+ *
+ * [Read `P.set` documentation on GitHub](https://github.com/gvergnaud/ts-pattern#Pset-patterns)
+ *
+ * @example
+ * match(value)
+ * .with({ users: P.set(P.string) }, () => 'will match Set')
+ */
+export function map>;
+export function map<
+ input,
+ const pkey extends Pattern, unknown>>,
+ const pvalue extends Pattern, unknown>>
+>(patternKey: pkey, patternValue: pvalue): Chainable>;
+export function map<
+ input,
+ const pkey extends Pattern, unknown>>,
+ const pvalue extends Pattern, unknown>>
+>(
+ ...args: [patternKey?: pkey, patternValue?: pvalue]
+): Chainable> {
+ return chainable({
+ [matcher]() {
+ return {
+ match: (value: UnknownInput | input) => {
+ if (!(value instanceof Map)) return { matched: false };
+
+ let selections: Record = {};
+
+ if (value.size === 0) {
+ return { matched: true, selections };
+ }
+
+ const selector = (key: string, value: unknown) => {
+ selections[key] = (selections[key] || []).concat([value]);
+ };
+
+ if (args.length === 0) return { matched: true };
+ if (args.length === 1) {
+ throw new Error(
+ `\`P.map\` wasn\'t given enough arguments. Expected (key, value), received ${args[0]?.toString()}`
+ );
+ }
+ const [patternKey, patternValue] = args;
+
+ const matched = mapEvery(value, (v, k) => {
+ const keyMatch = matchPattern(patternKey, k, selector);
+ const valueMatch = matchPattern(patternValue, v, selector);
+ return keyMatch && valueMatch;
+ });
+
+ return { matched, selections };
+ },
+ getSelectionKeys: () =>
+ args.length === 0
+ ? []
+ : [...getSelectionKeys(args[0]), ...getSelectionKeys(args[1])],
+ };
+ },
+ });
}
+const mapEvery = (
+ map: Map,
+ predicate: (value: T, key: K) => boolean
+) => {
+ for (const [key, value] of map.entries()) {
+ if (predicate(value, key)) continue;
+ return false;
+ }
+ return true;
+};
+
/**
* `P.intersection(...patterns)` returns a pattern which matches
* only if **every** patterns provided in parameter match the input.
*
- * [Read documentation for `P.intersection` on GitHub](https://github.com/gvergnaud/ts-pattern#Pintersection-patterns)
+ * [Read the documentation for `P.intersection` on GitHub](https://github.com/gvergnaud/ts-pattern#Pintersection-patterns)
*
* @example
* match(value)
@@ -136,100 +480,98 @@ export function array<
*/
export function intersection<
input,
- ps extends unknown extends input
- ? [UnknownPattern, ...UnknownPattern[]]
- : [Pattern {
- return {
- [symbols.matcher]: () => ({
+ const ps extends readonly [Pattern> {
+ return chainable({
+ [matcher]: () => ({
match: (value) => {
let selections: Record = {};
const selector = (key: string, value: any) => {
selections[key] = value;
};
- const matched = (patterns as UnknownPattern[]).every((p) =>
+ const matched = (patterns as readonly UnknownPattern[]).every((p) =>
matchPattern(p, value, selector)
);
return { matched, selections };
},
getSelectionKeys: () =>
- flatMap(patterns as UnknownPattern[], getSelectionKeys),
+ flatMap(patterns as readonly UnknownPattern[], getSelectionKeys),
matcherType: 'and',
}),
- };
+ });
}
/**
* `P.union(...patterns)` returns a pattern which matches
* if **at least one** of the patterns provided in parameter match the input.
*
- * [Read documentation for `P.union` on GitHub](https://github.com/gvergnaud/ts-pattern#Punion-patterns)
+ * [Read the documentation for `P.union` on GitHub](https://github.com/gvergnaud/ts-pattern#Punion-patterns)
*
* @example
* match(value)
* .with(
* { type: P.union('a', 'b', 'c') },
- * ({ user }) => 'will match { type: "a" | "b" | "c" }'
+ * ({ type }) => 'will match { type: "a" | "b" | "c" }'
* )
*/
export function union<
input,
- ps extends unknown extends input
- ? [UnknownPattern, ...UnknownPattern[]]
- : [Pattern {
- return {
- [symbols.matcher]: () => ({
- match: (value: I | input) => {
+ const ps extends readonly [Pattern> {
+ return chainable({
+ [matcher]: () => ({
+ match: (value: UnknownInput | input) => {
let selections: Record = {};
const selector = (key: string, value: any) => {
selections[key] = value;
};
- flatMap(patterns as UnknownPattern[], getSelectionKeys).forEach((key) =>
- selector(key, undefined)
- );
- const matched = (patterns as UnknownPattern[]).some((p) =>
+ flatMap(
+ patterns as readonly UnknownPattern[],
+ getSelectionKeys
+ ).forEach((key) => selector(key, undefined));
+ const matched = (patterns as readonly UnknownPattern[]).some((p) =>
matchPattern(p, value, selector)
);
return { matched, selections };
},
getSelectionKeys: () =>
- flatMap(patterns as UnknownPattern[], getSelectionKeys),
+ flatMap(patterns as readonly UnknownPattern[], getSelectionKeys),
matcherType: 'or',
}),
- };
+ });
}
/**
* `P.not(pattern)` returns a pattern which matches if the sub pattern
* doesn't match.
*
- * [Read documentation for `P.not` on GitHub](https://github.com/gvergnaud/ts-pattern#Pnot-patterns)
+ * [Read the documentation for `P.not` on GitHub](https://github.com/gvergnaud/ts-pattern#Pnot-patterns)
*
* @example
* match<{ a: string | number }>(value)
* .with({ a: P.not(P.string) }, (x) => 'will match { a: number }'
* )
*/
-export function not | Primitives>(
+
+export function not | UnknownPattern>(
pattern: p
-): NotP {
- return {
- [symbols.matcher]: () => ({
- match: (value: I | input) => ({
+): Chainable> {
+ return chainable({
+ [matcher]: () => ({
+ match: (value: UnknownInput | input) => ({
matched: !matchPattern(pattern, value, () => {}),
}),
getSelectionKeys: () => [],
matcherType: 'not',
}),
- };
+ });
}
/**
* `P.when((value) => boolean)` returns a pattern which matches
* if the predicate returns true for the current input.
*
- * [Read documentation for `P.when` on GitHub](https://github.com/gvergnaud/ts-pattern#Pwhen-patterns)
+ * [Read the documentation for `P.when` on GitHub](https://github.com/gvergnaud/ts-pattern#Pwhen-patterns)
*
* @example
* match<{ age: number }>(value)
@@ -252,8 +594,8 @@ export function when unknown>(
p extends (value: any) => value is infer narrowed ? narrowed : never
> {
return {
- [symbols.matcher]: () => ({
- match: (value: I | input) => ({
+ [matcher]: () => ({
+ match: (value: UnknownInput | input) => ({
matched: Boolean(predicate(value as input)),
}),
}),
@@ -264,32 +606,35 @@ export function when unknown>(
* `P.select()` is a pattern which will always match,
* and will inject the selected piece of input in the handler function.
*
- * [Read documentation for `P.select` on GitHub](https://github.com/gvergnaud/ts-pattern#Pselect-patterns)
+ * [Read the documentation for `P.select` on GitHub](https://github.com/gvergnaud/ts-pattern#Pselect-patterns)
*
* @example
* match<{ age: number }>(value)
* .with({ age: P.select() }, (age) => 'age: number'
* )
*/
-export function select(): AnonymousSelectP;
+export function select(): Chainable;
export function select<
input,
- patternOrKey extends
+ const patternOrKey extends
| string
| (unknown extends input ? UnknownPattern : Pattern
- : SelectP;
+ ? Chainable>
+ : Chainable<
+ SelectP,
+ 'select' | 'or' | 'and'
+ >;
export function select<
input,
- p extends unknown extends input ? UnknownPattern : Pattern;
+ const p extends unknown extends input ? UnknownPattern : Pattern, 'select' | 'or' | 'and'>;
export function select(
...args: [keyOrPattern?: unknown | string, pattern?: unknown]
-): SelectP {
+): Chainable, 'select' | 'or' | 'and'> {
const key: string | undefined =
typeof args[0] === 'string' ? args[0] : undefined;
const pattern: unknown =
@@ -298,8 +643,8 @@ export function select(
: typeof args[0] === 'string'
? undefined
: args[0];
- return {
- [symbols.matcher]() {
+ return chainable({
+ [matcher]() {
return {
match: (value) => {
let selections: Record = {
@@ -322,7 +667,7 @@ export function select(
),
};
},
- };
+ });
}
function isUnknown(x: unknown): x is unknown {
@@ -360,22 +705,31 @@ function isInstanceOf(classConstructor: T) {
val instanceof classConstructor;
}
+// These aliases could be inferred, but lead to nicer display names in IDEs.
+type AnyPattern = Chainable, never>;
+type StringPattern = StringChainable, never>;
+type NumberPattern = NumberChainable, never>;
+type BooleanPattern = Chainable, never>;
+type BigIntPattern = BigIntChainable, never>;
+type SymbolPattern = Chainable, never>;
+type NullishPattern = Chainable, never>;
+
/**
* `P.any` is a wildcard pattern, matching **any value**.
*
- * [Read documentation for `P.any` on GitHub](https://github.com/gvergnaud/ts-pattern#P_-wildcard)
+ * [Read the documentation for `P.any` on GitHub](https://github.com/gvergnaud/ts-pattern#P_-wildcard)
*
* @example
* match(value)
* .with(P.any, () => 'will always match')
*/
-export const any = when(isUnknown);
+export const any: AnyPattern = chainable(when(isUnknown));
/**
* `P._` is a wildcard pattern, matching **any value**.
* It's an alias to `P.any`.
*
- * [Read documentation for `P._` on GitHub](https://github.com/gvergnaud/ts-pattern#P_-wildcard)
+ * [Read the documentation for `P._` on GitHub](https://github.com/gvergnaud/ts-pattern#P_-wildcard)
*
* @example
* match(value)
@@ -384,131 +738,808 @@ export const any = when(isUnknown);
export const _ = any;
/**
- * `P.string` is a wildcard pattern matching any **string**.
+ * `P.string.startsWith(start)` is a pattern, matching **strings** starting with `start`.
+ *
+ * [Read the documentation for `P.string.startsWith` on GitHub](https://github.com/gvergnaud/ts-pattern#PstringstartsWith)
+ *
+ * @example
+ * match(value)
+ * .with(P.string.startsWith('A'), () => 'value starts with an A')
+ */
+
+const startsWith = (
+ start: start
+): GuardP =>
+ when((value) => isString(value) && value.startsWith(start));
+
+/**
+ * `P.string.endsWith(end)` is a pattern, matching **strings** ending with `end`.
+ *
+ * [Read the documentation for `P.string.endsWith` on GitHub](https://github.com/gvergnaud/ts-pattern#PstringendsWith)
+ *
+ * @example
+ * match(value)
+ * .with(P.string.endsWith('!'), () => 'value ends with an !')
+ */
+const endsWith = (
+ end: end
+): GuardP =>
+ when((value) => isString(value) && value.endsWith(end));
+
+/**
+ * `P.string.minLength(min)` is a pattern, matching **strings** with at least `min` characters.
+ *
+ * [Read the documentation for `P.string.minLength` on GitHub](https://github.com/gvergnaud/ts-pattern#PstringminLength)
+ *
+ * @example
+ * match(value)
+ * .with(P.string.minLength(10), () => 'string with more length >= 10')
+ */
+const minLength = (min: min) =>
+ when((value) => isString(value) && value.length >= min);
+
+/**
+ * `P.string.maxLength(max)` is a pattern, matching **strings** with at most `max` characters.
+ *
+ * [Read the documentation for `P.string.maxLength` on GitHub](https://github.com/gvergnaud/ts-pattern#PstringmaxLength)
+ *
+ * @example
+ * match(value)
+ * .with(P.string.maxLength(10), () => 'string with more length <= 10')
+ */
+const maxLength = (max: max) =>
+ when((value) => isString(value) && value.length <= max);
+
+/**
+ * `P.string.includes(substr)` is a pattern, matching **strings** containing `substr`.
+ *
+ * [Read the documentation for `P.string.includes` on GitHub](https://github.com/gvergnaud/ts-pattern#Pstringincludes)
+ *
+ * @example
+ * match(value)
+ * .with(P.string.includes('http'), () => 'value contains http')
+ */
+const includes = (
+ substr: substr
+): GuardExcludeP =>
+ when((value) => isString(value) && value.includes(substr));
+
+/**
+ * `P.string.regex(expr)` is a pattern, matching **strings** that `expr` regular expression.
+ *
+ * [Read the documentation for `P.string.regex` on GitHub](https://github.com/gvergnaud/ts-pattern#Pstringregex)
+ *
+ * @example
+ * match(value)
+ * .with(P.string.regex(/^https?:\/\//), () => 'url')
+ */
+const regex = (
+ expr: expr
+): GuardExcludeP =>
+ when((value) => isString(value) && Boolean(value.match(expr)));
+
+type MaybeAnd = [omitted] extends [never]
+ ? p2
+ : AndP;
+
+type StringChainable<
+ p extends Matcher,
+ omitted extends string = never
+> = Chainable &
+ Omit<
+ {
+ /**
+ * `P.string.startsWith(start)` is a pattern, matching **strings** starting with `start`.
+ *
+ * [Read the documentation for `P.string.startsWith` on GitHub](https://github.com/gvergnaud/ts-pattern#PstringstartsWith)
+ *
+ * @example
+ * match(value)
+ * .with(P.string.startsWith('A'), () => 'value starts with an A')
+ */
+ startsWith(
+ start: start
+ ): StringChainable<
+ MaybeAnd>,
+ omitted | 'startsWith'
+ >;
+ /**
+ * `P.string.endsWith(end)` is a pattern, matching **strings** ending with `end`.
+ *
+ * [Read the documentation for `P.string.endsWith` on GitHub](https://github.com/gvergnaud/ts-pattern#PstringendsWith)
+ *
+ * @example
+ * match(value)
+ * .with(P.string.endsWith('!'), () => 'value ends with an !')
+ */
+ endsWith(
+ end: end
+ ): StringChainable<
+ MaybeAnd>,
+ omitted | 'endsWith'
+ >;
+ /**
+ * `P.string.minLength(min)` is a pattern, matching **strings** with at least `min` characters.
+ *
+ * [Read the documentation for `P.string.minLength` on GitHub](https://github.com/gvergnaud/ts-pattern#PstringminLength)
+ *
+ * @example
+ * match(value)
+ * .with(P.string.minLength(10), () => 'string with more length <= 10')
+ */
+ minLength(
+ min: min
+ ): StringChainable<
+ MaybeAnd>,
+ omitted | 'minLength'
+ >;
+ /**
+ * `P.string.maxLength(max)` is a pattern, matching **strings** with at most `max` characters.
+ *
+ * [Read the documentation for `P.string.maxLength` on GitHub](https://github.com/gvergnaud/ts-pattern#PstringmaxLength)
+ *
+ * @example
+ * match(value)
+ * .with(P.string.maxLength(10), () => 'string with more length >= 10')
+ */
+ maxLength(
+ max: max
+ ): StringChainable<
+ MaybeAnd>,
+ omitted | 'maxLength'
+ >;
+ /**
+ * `P.string.includes(substr)` is a pattern, matching **strings** containing `substr`.
+ *
+ * [Read the documentation for `P.string.includes` on GitHub](https://github.com/gvergnaud/ts-pattern#Pstringincludes)
+ *
+ * @example
+ * match(value)
+ * .with(P.string.includes('http'), () => 'value contains http')
+ */
+ includes(
+ substr: substr
+ ): StringChainable<
+ MaybeAnd>,
+ omitted
+ >;
+ /**
+ * `P.string.regex(expr)` is a pattern, matching **strings** that `expr` regular expression.
+ *
+ * [Read the documentation for `P.string.regex` on GitHub](https://github.com/gvergnaud/ts-pattern#Pstringregex)
+ *
+ * @example
+ * match(value)
+ * .with(P.string.regex(/^https?:\/\//), () => 'url')
+ */
+ regex(
+ expr: expr
+ ): StringChainable<
+ MaybeAnd>,
+ omitted
+ >;
+ },
+ omitted
+ >;
+
+const stringChainable = >(
+ pattern: p
+): StringChainable
=>
+ Object.assign(chainable(pattern), {
+ startsWith: (str: string) =>
+ stringChainable(intersection(pattern, startsWith(str))),
+ endsWith: (str: string) =>
+ stringChainable(intersection(pattern, endsWith(str))),
+ minLength: (min: number) =>
+ stringChainable(intersection(pattern, minLength(min))),
+ maxLength: (max: number) =>
+ stringChainable(intersection(pattern, maxLength(max))),
+ includes: (str: string) =>
+ stringChainable(intersection(pattern, includes(str))),
+ regex: (str: string) => stringChainable(intersection(pattern, regex(str))),
+ }) as any;
+
+/**
+ * `P.string` is a wildcard pattern, matching any **string**.
*
- * [Read documentation for `P.string` on GitHub](https://github.com/gvergnaud/ts-pattern#Pstring-wildcard)
+ * [Read the documentation for `P.string` on GitHub](https://github.com/gvergnaud/ts-pattern#Pstring-wildcard)
*
* @example
* match(value)
* .with(P.string, () => 'will match on strings')
*/
+export const string: StringPattern = stringChainable(when(isString));
+
+/**
+ * `P.number.between(min, max)` matches **number** between `min` and `max`,
+ * equal to min or equal to max.
+ *
+ * [Read the documentation for `P.number.between` on GitHub](https://github.com/gvergnaud/ts-pattern#Pnumberbetween)
+ *
+ * @example
+ * match(value)
+ * .with(P.number.between(0, 10), () => '0 <= numbers <= 10')
+ */
+export const between = <
+ input,
+ const min extends number,
+ const max extends number
+>(
+ min: min,
+ max: max
+): GuardExcludeP =>
+ when((value) => isNumber(value) && min <= value && max >= value);
+
+/**
+ * `P.number.lt(max)` matches **number** smaller than `max`.
+ *
+ * [Read the documentation for `P.number.lt` on GitHub](https://github.com/gvergnaud/ts-pattern#Pnumberlt)
+ *
+ * @example
+ * match(value)
+ * .with(P.number.lt(10), () => 'numbers < 10')
+ */
+export const lt = (
+ max: max
+): GuardExcludeP =>
+ when((value) => isNumber(value) && value < max);
+
+/**
+ * `P.number.gt(min)` matches **number** greater than `min`.
+ *
+ * [Read the documentation for `P.number.gt` on GitHub](https://github.com/gvergnaud/ts-pattern#Pnumbergt)
+ *
+ * @example
+ * match(value)
+ * .with(P.number.gt(10), () => 'numbers > 10')
+ */
+export const gt = (
+ min: min
+): GuardExcludeP =>
+ when((value) => isNumber(value) && value > min);
+
+/**
+ * `P.number.lte(max)` matches **number** smaller than or equal to `max`.
+ *
+ * [Read the documentation for `P.number.lte` on GitHub](https://github.com/gvergnaud/ts-pattern#Pnumberlte)
+ *
+ * @example
+ * match(value)
+ * .with(P.number.lte(10), () => 'numbers <= 10')
+ */
+export const lte = (
+ max: max
+): GuardExcludeP =>
+ when((value) => isNumber(value) && value <= max);
+
+/**
+ * `P.number.gte(min)` matches **number** greater than or equal to `min`.
+ *
+ * [Read the documentation for `P.number.gte` on GitHub](https://github.com/gvergnaud/ts-pattern#Pnumbergte)
+ *
+ * @example
+ * match(value)
+ * .with(P.number.gte(10), () => 'numbers >= 10')
+ */
+export const gte = (
+ min: min
+): GuardExcludeP =>
+ when((value) => isNumber(value) && value >= min);
+
+/**
+ * `P.number.int` matches **integer** numbers.
+ *
+ * [Read the documentation for `P.number.int` on GitHub](https://github.com/gvergnaud/ts-pattern#Pnumberint)
+ *
+ * @example
+ * match(value)
+ * .with(P.number.int, () => 'an integer')
+ */
+export const int = =>
+ when((value) => isNumber(value) && Number.isInteger(value));
+
+/**
+ * `P.number.finite` matches **finite numbers**.
+ *
+ * [Read the documentation for `P.number.finite` on GitHub](https://github.com/gvergnaud/ts-pattern#Pnumberfinite)
+ *
+ * @example
+ * match(value)
+ * .with(P.number.finite, () => 'not Infinity')
+ */
+export const finite = =>
+ when((value) => isNumber(value) && Number.isFinite(value));
+
+/**
+ * `P.number.positive` matches **positive** numbers.
+ *
+ * [Read the documentation for `P.number.positive` on GitHub](https://github.com/gvergnaud/ts-pattern#Pnumberpositive)
+ *
+ * @example
+ * match(value)
+ * .with(P.number.positive, () => 'number > 0')
+ */
+export const positive = =>
+ when((value) => isNumber(value) && value > 0);
+
+/**
+ * `P.number.negative` matches **negative** numbers.
+ *
+ * [Read the documentation for `P.number.negative` on GitHub](https://github.com/gvergnaud/ts-pattern#Pnumbernegative)
+ *
+ * @example
+ * match(value)
+ * .with(P.number.negative, () => 'number < 0')
+ */
+export const negative = =>
+ when((value) => isNumber(value) && value < 0);
-export const string = when(isString);
+type NumberChainable = Chainable<
+ p,
+ omitted
+> &
+ Omit<
+ {
+ /**
+ * `P.number.between(min, max)` matches **number** between `min` and `max`,
+ * equal to min or equal to max.
+ *
+ * [Read the documentation for `P.number.between` on GitHub](https://github.com/gvergnaud/ts-pattern#Pnumberbetween)
+ *
+ * @example
+ * match(value)
+ * .with(P.number.between(0, 10), () => '0 <= numbers <= 10')
+ */
+ between(
+ min: min,
+ max: max
+ ): NumberChainable<
+ MaybeAnd>,
+ omitted
+ >;
+ /**
+ * `P.number.lt(max)` matches **number** smaller than `max`.
+ *
+ * [Read the documentation for `P.number.lt` on GitHub](https://github.com/gvergnaud/ts-pattern#Pnumberlt)
+ *
+ * @example
+ * match(value)
+ * .with(P.number.lt(10), () => 'numbers < 10')
+ */
+ lt(
+ max: max
+ ): NumberChainable<
+ MaybeAnd>,
+ omitted
+ >;
+ /**
+ * `P.number.gt(min)` matches **number** greater than `min`.
+ *
+ * [Read the documentation for `P.number.gt` on GitHub](https://github.com/gvergnaud/ts-pattern#Pnumbergt)
+ *
+ * @example
+ * match(value)
+ * .with(P.number.gt(10), () => 'numbers > 10')
+ */
+ gt(
+ min: min
+ ): NumberChainable<
+ MaybeAnd>,
+ omitted
+ >;
+ /**
+ * `P.number.lte(max)` matches **number** smaller than or equal to `max`.
+ *
+ * [Read the documentation for `P.number.lte` on GitHub](https://github.com/gvergnaud/ts-pattern#Pnumberlte)
+ *
+ * @example
+ * match(value)
+ * .with(P.number.lte(10), () => 'numbers <= 10')
+ */
+ lte(
+ max: max
+ ): NumberChainable<
+ MaybeAnd>,
+ omitted
+ >;
+ /**
+ * `P.number.gte(min)` matches **number** greater than or equal to `min`.
+ *
+ * [Read the documentation for `P.number.gte` on GitHub](https://github.com/gvergnaud/ts-pattern#Pnumbergte)
+ *
+ * @example
+ * match(value)
+ * .with(P.number.gte(10), () => 'numbers >= 10')
+ */
+ gte(
+ min: min
+ ): NumberChainable<
+ MaybeAnd>,
+ omitted
+ >;
+ /**
+ * `P.number.int` matches **integer** numbers.
+ *
+ * [Read the documentation for `P.number.int` on GitHub](https://github.com/gvergnaud/ts-pattern#Pnumberint)
+ *
+ * @example
+ * match(value)
+ * .with(P.number.int, () => 'an integer')
+ */
+ int>,
+ omitted | 'int'
+ >;
+ /**
+ * `P.number.finite` matches **finite numbers**.
+ *
+ * [Read the documentation for `P.number.finite` on GitHub](https://github.com/gvergnaud/ts-pattern#Pnumberfinite)
+ *
+ * @example
+ * match(value)
+ * .with(P.number.finite, () => 'not Infinity')
+ */
+ finite>,
+ omitted | 'finite'
+ >;
+ /**
+ * `P.number.positive` matches **positive** numbers.
+ *
+ * [Read the documentation for `P.number.positive` on GitHub](https://github.com/gvergnaud/ts-pattern#Pnumberpositive)
+ *
+ * @example
+ * match(value)
+ * .with(P.number.positive, () => 'number > 0')
+ */
+ positive>,
+ omitted | 'positive' | 'negative'
+ >;
+ /**
+ * `P.number.negative` matches **negative** numbers.
+ *
+ * [Read the documentation for `P.number.negative` on GitHub](https://github.com/gvergnaud/ts-pattern#Pnumbernegative)
+ *
+ * @example
+ * match(value)
+ * .with(P.number.negative, () => 'number < 0')
+ */
+ negative>,
+ omitted | 'positive' | 'negative' | 'negative'
+ >;
+ },
+ omitted
+ >;
+
+const numberChainable = >(
+ pattern: p
+): NumberChainable
=>
+ Object.assign(chainable(pattern), {
+ between: (min: number, max: number) =>
+ numberChainable(intersection(pattern, between(min, max))),
+ lt: (max: number) => numberChainable(intersection(pattern, lt(max))),
+ gt: (min: number) => numberChainable(intersection(pattern, gt(min))),
+ lte: (max: number) => numberChainable(intersection(pattern, lte(max))),
+ gte: (min: number) => numberChainable(intersection(pattern, gte(min))),
+ int: () => numberChainable(intersection(pattern, int())),
+ finite: () => numberChainable(intersection(pattern, finite())),
+ positive: () => numberChainable(intersection(pattern, positive())),
+ negative: () => numberChainable(intersection(pattern, negative())),
+ }) as any;
/**
- * `P.number` is a wildcard pattern matching any **number**.
+ * `P.number` is a wildcard pattern, matching any **number**.
*
- * [Read documentation for `P.number` on GitHub](https://github.com/gvergnaud/ts-pattern#Pnumber-wildcard)
+ * [Read the documentation for `P.number` on GitHub](https://github.com/gvergnaud/ts-pattern#Pnumber-wildcard)
*
* @example
* match(value)
* .with(P.number, () => 'will match on numbers')
*/
-export const number = when(isNumber);
+export const number: NumberPattern = numberChainable(when(isNumber));
/**
- * `P.boolean` is a wildcard pattern matching any **boolean**.
+ * `P.bigint.between(min, max)` matches **bigint** between `min` and `max`,
+ * equal to min or equal to max.
*
- * [Read documentation for `P.boolean` on GitHub](https://github.com/gvergnaud/ts-pattern#boolean-wildcard)
+ * [Read the documentation for `P.bigint.between` on GitHub](https://github.com/gvergnaud/ts-pattern#Pnumberbetween)
*
* @example
- * .with(P.boolean, () => 'will match on booleans')
+ * match(value)
+ * .with(P.bigint.between(0, 10), () => '0 <= numbers <= 10')
+ */
+export const betweenBigInt = <
+ input,
+ const min extends bigint,
+ const max extends bigint
+>(
+ min: min,
+ max: max
+): GuardExcludeP =>
+ when((value) => isBigInt(value) && min <= value && max >= value);
+
+/**
+ * `P.bigint.lt(max)` matches **bigint** smaller than `max`.
+ *
+ * [Read the documentation for `P.bigint.lt` on GitHub](https://github.com/gvergnaud/ts-pattern#bigintlt)
+ *
+ * @example
+ * match(value)
+ * .with(P.bigint.lt(10), () => 'numbers < 10')
*/
-export const boolean = when(isBoolean);
+export const ltBigInt = (
+ max: max
+): GuardExcludeP =>
+ when((value) => isBigInt(value) && value < max);
/**
- * `P.bigint` is a wildcard pattern matching any **bigint**.
+ * `P.bigint.gt(min)` matches **bigint** greater than `min`.
*
- * [Read documentation for `P.bigint` on GitHub](https://github.com/gvergnaud/ts-pattern#bigint-wildcard)
+ * [Read the documentation for `P.bigint.gt` on GitHub](https://github.com/gvergnaud/ts-pattern#bigintgt)
+ *
+ * @example
+ * match(value)
+ * .with(P.bigint.gt(10), () => 'numbers > 10')
+ */
+export const gtBigInt = (
+ min: min
+): GuardExcludeP =>
+ when((value) => isBigInt(value) && value > min);
+
+/**
+ * `P.bigint.lte(max)` matches **bigint** smaller than or equal to `max`.
+ *
+ * [Read the documentation for `P.bigint.lte` on GitHub](https://github.com/gvergnaud/ts-pattern#bigintlte)
+ *
+ * @example
+ * match(value)
+ * .with(P.bigint.lte(10), () => 'bigints <= 10')
+ */
+export const lteBigInt = (
+ max: max
+): GuardExcludeP =>
+ when((value) => isBigInt(value) && value <= max);
+
+/**
+ * `P.bigint.gte(min)` matches **bigint** greater than or equal to `min`.
+ *
+ * [Read the documentation for `P.bigint.gte` on GitHub](https://github.com/gvergnaud/ts-pattern#Pbigintgte)
+ *
+ * @example
+ * match(value)
+ * .with(P.bigint.gte(10), () => 'bigints >= 10')
+ */
+export const gteBigInt = (
+ min: min
+): GuardExcludeP =>
+ when((value) => isBigInt(value) && value >= min);
+
+/**
+ * `P.bigint.positive` matches **positive** bigints.
+ *
+ * [Read the documentation for `P.bigint.positive` on GitHub](https://github.com/gvergnaud/ts-pattern#Pbigintpositive)
+ *
+ * @example
+ * match(value)
+ * .with(P.bigint.positive, () => 'bigint > 0')
+ */
+export const positiveBigInt = =>
+ when((value) => isBigInt(value) && value > 0);
+
+/**
+ * `P.bigint.negative` matches **negative** bigints.
+ *
+ * [Read the documentation for `P.bigint.negative` on GitHub](https://github.com/gvergnaud/ts-pattern#Pbigintnegative)
+ *
+ * @example
+ * match(value)
+ * .with(P.bigint.negative, () => 'bigint < 0')
+ */
+export const negativeBigInt = =>
+ when((value) => isBigInt(value) && value < 0);
+
+type BigIntChainable = Chainable<
+ p,
+ omitted
+> &
+ Omit<
+ {
+ /**
+ * `P.bigint.between(min, max)` matches **bigint** between `min` and `max`,
+ * equal to min or equal to max.
+ *
+ * [Read the documentation for `P.bigint.between` on GitHub](https://github.com/gvergnaud/ts-pattern#Pnumberbetween)
+ *
+ * @example
+ * match(value)
+ * .with(P.bigint.between(0, 10), () => '0 <= numbers <= 10')
+ */
+ between(
+ min: min,
+ max: max
+ ): BigIntChainable<
+ MaybeAnd>,
+ omitted
+ >;
+ /**
+ * `P.bigint.lt(max)` matches **bigint** smaller than `max`.
+ *
+ * [Read the documentation for `P.bigint.lt` on GitHub](https://github.com/gvergnaud/ts-pattern#bigintlt)
+ *
+ * @example
+ * match(value)
+ * .with(P.bigint.lt(10), () => 'numbers < 10')
+ */
+ lt(
+ max: max
+ ): BigIntChainable<
+ MaybeAnd>,
+ omitted
+ >;
+ /**
+ * `P.bigint.gt(min)` matches **bigint** greater than `min`.
+ *
+ * [Read the documentation for `P.bigint.gt` on GitHub](https://github.com/gvergnaud/ts-pattern#bigintgt)
+ *
+ * @example
+ * match(value)
+ * .with(P.bigint.gt(10), () => 'numbers > 10')
+ */
+ gt(
+ min: min
+ ): BigIntChainable<
+ MaybeAnd>,
+ omitted
+ >;
+ /**
+ * `P.bigint.lte(max)` matches **bigint** smaller than or equal to `max`.
+ *
+ * [Read the documentation for `P.bigint.lte` on GitHub](https://github.com/gvergnaud/ts-pattern#bigintlte)
+ *
+ * @example
+ * match(value)
+ * .with(P.bigint.lte(10), () => 'bigints <= 10')
+ */
+ lte(
+ max: max
+ ): BigIntChainable<
+ MaybeAnd>,
+ omitted
+ >;
+ /**
+ * `P.bigint.gte(min)` matches **bigint** greater than or equal to `min`.
+ *
+ * [Read the documentation for `P.bigint.gte` on GitHub](https://github.com/gvergnaud/ts-pattern#Pnumbergte)
+ *
+ * @example
+ * match(value)
+ * .with(P.bigint.gte(10), () => 'bigints >= 10')
+ */
+ gte(
+ min: min
+ ): BigIntChainable<
+ MaybeAnd>,
+ omitted
+ >;
+ /**
+ * `P.bigint.positive` matches **positive** bigints.
+ *
+ * [Read the documentation for `P.bigint.positive` on GitHub](https://github.com/gvergnaud/ts-pattern#Pnumberpositive)
+ *
+ * @example
+ * match(value)
+ * .with(P.bigint.positive, () => 'bigint > 0')
+ */
+ positive>,
+ omitted | 'positive' | 'negative'
+ >;
+ /**
+ * `P.bigint.negative` matches **negative** bigints.
+ *
+ * [Read the documentation for `P.bigint.negative` on GitHub](https://github.com/gvergnaud/ts-pattern#Pnumbernegative)
+ *
+ * @example
+ * match(value)
+ * .with(P.bigint.negative, () => 'bigint < 0')
+ */
+ negative>,
+ omitted | 'positive' | 'negative' | 'negative'
+ >;
+ },
+ omitted
+ >;
+
+const bigintChainable = >(
+ pattern: p
+): BigIntChainable
=>
+ Object.assign(chainable(pattern), {
+ between: (min: bigint, max: bigint) =>
+ bigintChainable(intersection(pattern, betweenBigInt(min, max))),
+ lt: (max: bigint) => bigintChainable(intersection(pattern, ltBigInt(max))),
+ gt: (min: bigint) => bigintChainable(intersection(pattern, gtBigInt(min))),
+ lte: (max: bigint) =>
+ bigintChainable(intersection(pattern, lteBigInt(max))),
+ gte: (min: bigint) =>
+ bigintChainable(intersection(pattern, gteBigInt(min))),
+ positive: () => bigintChainable(intersection(pattern, positiveBigInt())),
+ negative: () => bigintChainable(intersection(pattern, negativeBigInt())),
+ }) as any;
+
+/**
+ * `P.bigint` is a wildcard pattern, matching any **bigint**.
+ *
+ * [Read the documentation for `P.bigint` on GitHub](https://github.com/gvergnaud/ts-pattern#bigint-wildcard)
*
* @example
* .with(P.bigint, () => 'will match on bigints')
*/
-export const bigint = when(isBigInt);
+export const bigint: BigIntPattern = bigintChainable(when(isBigInt));
+
+/**
+ * `P.boolean` is a wildcard pattern, matching any **boolean**.
+ *
+ * [Read the documentation for `P.boolean` on GitHub](https://github.com/gvergnaud/ts-pattern#boolean-wildcard)
+ *
+ * @example
+ * .with(P.boolean, () => 'will match on booleans')
+ */
+export const boolean: BooleanPattern = chainable(when(isBoolean));
/**
- * `P.symbol` is a wildcard pattern matching any **symbol**.
+ * `P.symbol` is a wildcard pattern, matching any **symbol**.
*
- * [Read documentation for `P.symbol` on GitHub](https://github.com/gvergnaud/ts-pattern#symbol-wildcard)
+ * [Read the documentation for `P.symbol` on GitHub](https://github.com/gvergnaud/ts-pattern#symbol-wildcard)
*
* @example
* .with(P.symbol, () => 'will match on symbols')
*/
-export const symbol = when(isSymbol);
+export const symbol: SymbolPattern = chainable(when(isSymbol));
/**
- * `P.nullish` is a wildcard pattern matching **null** or **undefined**.
+ * `P.nullish` is a wildcard pattern, matching **null** or **undefined**.
*
- * [Read documentation for `P.nullish` on GitHub](https://github.com/gvergnaud/ts-pattern#nullish-wildcard)
+ * [Read the documentation for `P.nullish` on GitHub](https://github.com/gvergnaud/ts-pattern#nullish-wildcard)
*
* @example
* .with(P.nullish, () => 'will match on null or undefined')
*/
-export const nullish = when(isNullish);
+export const nullish: NullishPattern = chainable(when(isNullish));
/**
* `P.instanceOf(SomeClass)` is a pattern matching instances of a given class.
*
- * [Read documentation for `P.instanceOf` on GitHub](https://github.com/gvergnaud/ts-pattern#Pinstanceof-patterns)
+ * [Read the documentation for `P.instanceOf` on GitHub](https://github.com/gvergnaud/ts-pattern#Pinstanceof-patterns)
*
* @example
* .with(P.instanceOf(SomeClass), () => 'will match on SomeClass instances')
*/
export function instanceOf(
classConstructor: T
-): GuardP> {
- return when(isInstanceOf(classConstructor));
+): Chainable>> {
+ return chainable(when(isInstanceOf(classConstructor)));
}
/**
- * `P.typed()` is a way to set the input type this
- * pattern should match on.
+ * `P.shape(somePattern)` lets you call methods like `.optional()`, `.and`, `.or` and `.select()`
+ * On structural patterns, like objects and arrays.
*
- * It returns all utility functions to create patterns,
- * Like `array`, `union`, `intersection`, etc.
+ * [Read the documentation for `P.shape` on GitHub](https://github.com/gvergnaud/ts-pattern#Pshape-patterns)
*
- * [Read documentation for `P.typed` on GitHub](https://github.com/gvergnaud/ts-pattern#Ptyped)
- *
- * @example
- * .with(
- * P.typed().array(P.string),
- * (arrayOfString) => arrayOfString.join(', ')
- * )
+ * @example
+ * .with(
+ * {
+ * state: P.shape({ status: "success" }).optional().select()
+ * },
+ * (state) => 'match the success state, or undefined.'
+ * )
*/
-export function typed>>(pattern: p): ArrayP;
-
- optional>(pattern: p): OptionalP;
-
- intersection, ...Pattern;
-
- union, ...Pattern;
-
- not>(pattern: p): NotP