101 lines
2.9 KiB
TypeScript
101 lines
2.9 KiB
TypeScript
/**
|
|
* Pattern matching primitives. Each constructor returns a lightweight
|
|
* matcher object whose `matches` method returns a type guard.
|
|
*/
|
|
|
|
export interface Matcher<T> {
|
|
readonly matches: (value: unknown) => value is T;
|
|
}
|
|
|
|
const literalMatcher = <
|
|
const L extends string | number | boolean | null | undefined,
|
|
>(
|
|
value: L,
|
|
): Matcher<L> => ({
|
|
matches: (candidate): candidate is L => candidate === value,
|
|
});
|
|
const typeMatcher = <T>(
|
|
type:
|
|
| "string"
|
|
| "number"
|
|
| "boolean"
|
|
| "bigint"
|
|
| "symbol"
|
|
| "undefined"
|
|
| "object"
|
|
| "function",
|
|
): Matcher<T> => {
|
|
const matches = (value: unknown): value is T => {
|
|
if (type === "undefined") {
|
|
return value === undefined;
|
|
}
|
|
if (type === "object") {
|
|
return (
|
|
(typeof value === "object" && value !== null) ||
|
|
typeof value === "function"
|
|
);
|
|
}
|
|
return typeof value === type;
|
|
};
|
|
return { matches };
|
|
},
|
|
whenMatcher = <T>(
|
|
predicate: (value: unknown) => value is T,
|
|
): Matcher<T> => ({
|
|
matches: predicate,
|
|
}),
|
|
whenMatcherAny = <T>(
|
|
predicate: (value: unknown) => boolean,
|
|
): Matcher<T> => ({
|
|
matches: (value: unknown): value is T => predicate(value),
|
|
}),
|
|
isNestedMatcher = (expected: unknown): expected is Matcher<unknown> =>
|
|
typeof expected === "object" &&
|
|
expected !== null &&
|
|
"matches" in expected,
|
|
keysMatch = <S extends object>(shape: S, candidate: object): boolean => {
|
|
for (const key of Object.keys(shape) as (keyof S)[]) {
|
|
if (!(key in candidate)) {
|
|
return false;
|
|
}
|
|
const expected = shape[key],
|
|
actual = candidate[key as keyof object];
|
|
if (isNestedMatcher(expected)) {
|
|
if (!expected.matches(actual)) {
|
|
return false;
|
|
}
|
|
} else if (actual !== expected) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
},
|
|
structuralMatcher = <S extends object, T extends S>(
|
|
shape: S,
|
|
refine?: (value: S) => value is T,
|
|
): Matcher<T> => ({
|
|
matches: (value: unknown): value is T => {
|
|
if (typeof value !== "object" || value === null) {
|
|
return false;
|
|
}
|
|
const candidate = value as S;
|
|
if (!keysMatch(shape, candidate)) {
|
|
return false;
|
|
}
|
|
if (refine && !refine(candidate)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
},
|
|
});
|
|
|
|
export const P = {
|
|
literal: literalMatcher,
|
|
type: typeMatcher,
|
|
when: whenMatcher,
|
|
any: whenMatcherAny,
|
|
shape: structuralMatcher,
|
|
} as const;
|
|
|
|
export type Pattern<T> = Matcher<T>;
|