unthrown 5.0.0-beta.5 → 5.0.0-beta.6
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +5 -7
- package/dist/index.cjs +155 -16
- package/dist/index.d.cts +162 -12
- package/dist/index.d.cts.map +1 -1
- package/dist/index.d.mts +162 -12
- package/dist/index.d.mts.map +1 -1
- package/dist/index.mjs +153 -5
- package/dist/index.mjs.map +1 -1
- package/package.json +1 -5
package/README.md
CHANGED
|
@@ -7,13 +7,11 @@
|
|
|
7
7
|
[API Reference](https://btravstack.github.io/unthrown/api/core/)
|
|
8
8
|
|
|
9
9
|
```sh
|
|
10
|
-
pnpm add unthrown
|
|
10
|
+
pnpm add unthrown
|
|
11
11
|
```
|
|
12
12
|
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
the single copy, so `import { P } from "ts-pattern"` composes with unthrown's
|
|
16
|
-
matchers.
|
|
13
|
+
No peer dependencies — the exhaustive error matcher is built-in and exported as
|
|
14
|
+
`match` / `P` / `tag`.
|
|
17
15
|
|
|
18
16
|
```ts
|
|
19
17
|
import { fromPromise, P, TaggedError } from "unthrown";
|
|
@@ -38,8 +36,8 @@ const status = await user.match({
|
|
|
38
36
|
- **Qualification at every boundary** — `fromPromise` / `fromThrowable` force you
|
|
39
37
|
to triage each failure into a modeled error or a defect.
|
|
40
38
|
- **Tagged errors** — `TaggedError(tag)` + `tag(t)`, folded exhaustively through
|
|
41
|
-
`match`'s
|
|
42
|
-
-
|
|
39
|
+
`match`'s built-in error matcher.
|
|
40
|
+
- **Zero runtime dependencies** (the matcher is built-in), ESM-first, dual
|
|
43
41
|
CJS/ESM.
|
|
44
42
|
|
|
45
43
|
See the [full documentation](https://btravstack.github.io/unthrown/) for the guide
|
package/dist/index.cjs
CHANGED
|
@@ -1,5 +1,153 @@
|
|
|
1
1
|
Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
|
|
2
|
-
|
|
2
|
+
//#region src/matcher.ts
|
|
3
|
+
/**
|
|
4
|
+
* Cross-copy brand for `P.*` pattern objects: `Symbol.for` yields the same
|
|
5
|
+
* symbol in every copy of the library (dual CJS/ESM, duplicated install,
|
|
6
|
+
* another realm), so a pattern built by one copy is recognised by another —
|
|
7
|
+
* the same rationale as `isResult`'s prototype brand.
|
|
8
|
+
*
|
|
9
|
+
* @internal
|
|
10
|
+
*/
|
|
11
|
+
const PATTERN_BRAND = Symbol.for("unthrown.matcher.pattern");
|
|
12
|
+
/**
|
|
13
|
+
* Thrown by `.run()` / `.exhaustive()` when no arm matched the value. For
|
|
14
|
+
* well-typed callers the match is exhaustive by construction, so this is only
|
|
15
|
+
* reachable by a value that slipped past the types (a widened cast, a raw-JS
|
|
16
|
+
* caller); inside the error combinators the throw-to-defect net converts it to
|
|
17
|
+
* a `Defect`, and at the `match` edge it surfaces (a genuinely unmodeled value
|
|
18
|
+
* is a bug).
|
|
19
|
+
*
|
|
20
|
+
* @category Errors
|
|
21
|
+
*/
|
|
22
|
+
var NonExhaustiveError = class extends Error {
|
|
23
|
+
/** The value no arm matched. */
|
|
24
|
+
input;
|
|
25
|
+
constructor(input) {
|
|
26
|
+
let printed;
|
|
27
|
+
try {
|
|
28
|
+
printed = JSON.stringify(input);
|
|
29
|
+
} catch {
|
|
30
|
+
printed = String(input);
|
|
31
|
+
}
|
|
32
|
+
super(`unthrown: no pattern matched the value ${printed}`);
|
|
33
|
+
this.name = "NonExhaustiveError";
|
|
34
|
+
this.input = input;
|
|
35
|
+
Object.setPrototypeOf(this, new.target.prototype);
|
|
36
|
+
}
|
|
37
|
+
};
|
|
38
|
+
/**
|
|
39
|
+
* Is `x` a *plain* object (prototype `Object.prototype` or `null`) — an object
|
|
40
|
+
* literal, the only object shape that acts as a structural pattern?
|
|
41
|
+
*
|
|
42
|
+
* @internal
|
|
43
|
+
*/
|
|
44
|
+
function isPlainObject(x) {
|
|
45
|
+
const proto = Object.getPrototypeOf(x);
|
|
46
|
+
return proto === Object.prototype || proto === null;
|
|
47
|
+
}
|
|
48
|
+
/**
|
|
49
|
+
* Runtime test: does `pattern` match `value`? A branded `P.*` pattern applies
|
|
50
|
+
* its predicate; a **plain-object** pattern (an object literal, e.g. the
|
|
51
|
+
* `{ _tag }` produced by `tag()`) matches when every key matches recursively
|
|
52
|
+
* (extra keys on the value are ignored — matching is structural); anything
|
|
53
|
+
* else — primitives, but also class instances, arrays, and foreign pattern
|
|
54
|
+
* objects (e.g. a real ts-pattern matcher, whose keys are symbols) — is
|
|
55
|
+
* compared with `Object.is`. Restricting structural matching to plain objects
|
|
56
|
+
* is load-bearing: a keyless non-plain object (`new Date()`, `new Error()`, a
|
|
57
|
+
* symbol-keyed foreign pattern) would otherwise vacuously match *every* object
|
|
58
|
+
* via an empty `Object.entries`.
|
|
59
|
+
*
|
|
60
|
+
* @internal
|
|
61
|
+
*/
|
|
62
|
+
function matches(pattern, value) {
|
|
63
|
+
if (typeof pattern === "object" && pattern !== null) {
|
|
64
|
+
const predicate = pattern[PATTERN_BRAND];
|
|
65
|
+
if (typeof predicate === "function") return predicate(value);
|
|
66
|
+
if (!isPlainObject(pattern) || Object.getOwnPropertySymbols(pattern).length > 0) return Object.is(pattern, value);
|
|
67
|
+
if (typeof value !== "object" || value === null) return false;
|
|
68
|
+
return Object.entries(pattern).every(([key, sub]) => matches(sub, value[key]));
|
|
69
|
+
}
|
|
70
|
+
return Object.is(pattern, value);
|
|
71
|
+
}
|
|
72
|
+
/**
|
|
73
|
+
* The runtime builder: first matching arm wins; later arms are skipped once a
|
|
74
|
+
* result is captured. `exhaustive` is a *method* at runtime (the conditional
|
|
75
|
+
* type gates its callability per instantiation).
|
|
76
|
+
*
|
|
77
|
+
* @internal
|
|
78
|
+
*/
|
|
79
|
+
var MatcherImpl = class {
|
|
80
|
+
#value;
|
|
81
|
+
#matched = false;
|
|
82
|
+
#result;
|
|
83
|
+
constructor(value) {
|
|
84
|
+
this.#value = value;
|
|
85
|
+
}
|
|
86
|
+
with(...args) {
|
|
87
|
+
if (this.#matched) return this;
|
|
88
|
+
const handler = args[args.length - 1];
|
|
89
|
+
for (let i = 0; i < args.length - 1; i++) if (matches(args[i], this.#value)) {
|
|
90
|
+
this.#matched = true;
|
|
91
|
+
this.#result = handler(this.#value);
|
|
92
|
+
return this;
|
|
93
|
+
}
|
|
94
|
+
return this;
|
|
95
|
+
}
|
|
96
|
+
exhaustive() {
|
|
97
|
+
if (this.#matched) return this.#result;
|
|
98
|
+
throw new NonExhaustiveError(this.#value);
|
|
99
|
+
}
|
|
100
|
+
run() {
|
|
101
|
+
return this.exhaustive();
|
|
102
|
+
}
|
|
103
|
+
};
|
|
104
|
+
Object.freeze(MatcherImpl.prototype);
|
|
105
|
+
/**
|
|
106
|
+
* Begin a match over `value`. Chain `.with(pattern, …patterns, handler)` arms;
|
|
107
|
+
* terminate with `.exhaustive()` — or return the un-terminated builder to an
|
|
108
|
+
* unthrown error combinator / `match({ errCases })`, which runs it for you.
|
|
109
|
+
*
|
|
110
|
+
* @remarks
|
|
111
|
+
* This is unthrown's own matcher (the former ts-pattern re-export): the same
|
|
112
|
+
* call-site shape, with exhaustiveness computed by plain `Exclude` over the
|
|
113
|
+
* builder's `Remaining` parameter. A `P._` catch-all is provably exhaustive
|
|
114
|
+
* even over an unresolved generic input.
|
|
115
|
+
*
|
|
116
|
+
* @category Constructors
|
|
117
|
+
*/
|
|
118
|
+
function match(value) {
|
|
119
|
+
return new MatcherImpl(value);
|
|
120
|
+
}
|
|
121
|
+
/** @internal */
|
|
122
|
+
function pattern(predicate) {
|
|
123
|
+
return Object.freeze({ [PATTERN_BRAND]: predicate });
|
|
124
|
+
}
|
|
125
|
+
const universal = pattern(() => true);
|
|
126
|
+
/**
|
|
127
|
+
* The pattern namespace (unthrown's own; the former ts-pattern `P`):
|
|
128
|
+
*
|
|
129
|
+
* - `P._` / `P.any` — the universal catch-all. Matches anything, and (because
|
|
130
|
+
* its phantom type is `unknown`) makes the builder provably exhaustive even
|
|
131
|
+
* when the matched input is an unresolved type parameter.
|
|
132
|
+
* - `P.instanceOf(Cls)` — an `instanceof` check, narrowing to the class
|
|
133
|
+
* instance type (for union members that are not tagged, e.g. a third-party
|
|
134
|
+
* error class).
|
|
135
|
+
* - `P.when(guard)` — an arbitrary type-guard predicate.
|
|
136
|
+
* - `P.union(…patterns)` — matches when any sub-pattern matches.
|
|
137
|
+
* - `P.string` / `P.number` — primitive-type wildcards.
|
|
138
|
+
*
|
|
139
|
+
* @category Constructors
|
|
140
|
+
*/
|
|
141
|
+
const P = Object.freeze({
|
|
142
|
+
_: universal,
|
|
143
|
+
any: universal,
|
|
144
|
+
instanceOf: (cls) => pattern((value) => value instanceof cls),
|
|
145
|
+
when: (guard) => pattern(guard),
|
|
146
|
+
union: (...patterns) => pattern((value) => patterns.some((sub) => matches(sub, value))),
|
|
147
|
+
string: pattern((value) => typeof value === "string"),
|
|
148
|
+
number: pattern((value) => typeof value === "number")
|
|
149
|
+
});
|
|
150
|
+
//#endregion
|
|
3
151
|
//#region src/defect.ts
|
|
4
152
|
const DEFECT = Symbol("unthrown/Defect");
|
|
5
153
|
/**
|
|
@@ -232,7 +380,7 @@ var Res = class {
|
|
|
232
380
|
match(cases) {
|
|
233
381
|
switch (this.tag) {
|
|
234
382
|
case "Ok": return cases.ok(this.value);
|
|
235
|
-
case "Err": return cases.errCases(
|
|
383
|
+
case "Err": return cases.errCases(match(this.error)).run();
|
|
236
384
|
case "Defect": return cases.defect(this.cause);
|
|
237
385
|
}
|
|
238
386
|
}
|
|
@@ -408,7 +556,7 @@ function nonResultCallbackDefect() {
|
|
|
408
556
|
* @internal
|
|
409
557
|
*/
|
|
410
558
|
function runMatch(f, error) {
|
|
411
|
-
return f(
|
|
559
|
+
return f(match(error), defect).run();
|
|
412
560
|
}
|
|
413
561
|
/**
|
|
414
562
|
* A throw inside a *failure observer* (`tapErrCases` / `tapDefect` / `flatTapErrCases`)
|
|
@@ -1405,7 +1553,7 @@ function TaggedError(tag, options) {
|
|
|
1405
1553
|
return TaggedErrorBase;
|
|
1406
1554
|
}
|
|
1407
1555
|
/**
|
|
1408
|
-
* A
|
|
1556
|
+
* A matcher pattern matching any value whose `_tag` equals `value` — a
|
|
1409
1557
|
* {@link TaggedError}, or any discriminated member. Equivalent to the object
|
|
1410
1558
|
* pattern `{ _tag: value }`, but reads better inside an error-matching
|
|
1411
1559
|
* combinator and narrows to the matching variant, payload included.
|
|
@@ -1434,14 +1582,10 @@ exports.DoAsync = DoAsync;
|
|
|
1434
1582
|
exports.Err = Err;
|
|
1435
1583
|
exports.ErrAsync = ErrAsync;
|
|
1436
1584
|
exports.GetError = GetError;
|
|
1585
|
+
exports.NonExhaustiveError = NonExhaustiveError;
|
|
1437
1586
|
exports.Ok = Ok;
|
|
1438
1587
|
exports.OkAsync = OkAsync;
|
|
1439
|
-
|
|
1440
|
-
enumerable: true,
|
|
1441
|
-
get: function() {
|
|
1442
|
-
return ts_pattern.P;
|
|
1443
|
-
}
|
|
1444
|
-
});
|
|
1588
|
+
exports.P = P;
|
|
1445
1589
|
exports.Result = Result;
|
|
1446
1590
|
exports.TaggedError = TaggedError;
|
|
1447
1591
|
exports.all = all;
|
|
@@ -1457,10 +1601,5 @@ exports.isDefect = isDefect;
|
|
|
1457
1601
|
exports.isErr = isErr;
|
|
1458
1602
|
exports.isOk = isOk;
|
|
1459
1603
|
exports.isResult = isResult;
|
|
1460
|
-
|
|
1461
|
-
enumerable: true,
|
|
1462
|
-
get: function() {
|
|
1463
|
-
return ts_pattern.match;
|
|
1464
|
-
}
|
|
1465
|
-
});
|
|
1604
|
+
exports.match = match;
|
|
1466
1605
|
exports.tag = tag;
|
package/dist/index.d.cts
CHANGED
|
@@ -1,4 +1,154 @@
|
|
|
1
|
-
|
|
1
|
+
//#region src/matcher.d.ts
|
|
2
|
+
/**
|
|
3
|
+
* Cross-copy brand for `P.*` pattern objects: `Symbol.for` yields the same
|
|
4
|
+
* symbol in every copy of the library (dual CJS/ESM, duplicated install,
|
|
5
|
+
* another realm), so a pattern built by one copy is recognised by another —
|
|
6
|
+
* the same rationale as `isResult`'s prototype brand.
|
|
7
|
+
*
|
|
8
|
+
* @internal
|
|
9
|
+
*/
|
|
10
|
+
declare const PATTERN_BRAND: unique symbol;
|
|
11
|
+
declare const MATCHES: unique symbol;
|
|
12
|
+
declare const UNIVERSAL: unique symbol;
|
|
13
|
+
/**
|
|
14
|
+
* A `P.*` pattern: a runtime predicate plus the phantom type `M` it matches.
|
|
15
|
+
* The phantom is declaration-only (never present at runtime); it drives the
|
|
16
|
+
* type-level narrowing (`Extract`) and exhaustiveness (`Exclude`).
|
|
17
|
+
*
|
|
18
|
+
* @typeParam M - the type this pattern matches.
|
|
19
|
+
* @category Types
|
|
20
|
+
*/
|
|
21
|
+
type PatternMatcher<M> = {
|
|
22
|
+
readonly [PATTERN_BRAND]: (value: unknown) => boolean;
|
|
23
|
+
readonly [MATCHES]?: M;
|
|
24
|
+
};
|
|
25
|
+
/**
|
|
26
|
+
* The statically-known universal pattern — the type of `P._` / `P.any` only.
|
|
27
|
+
* The phantom `UNIVERSAL` marker is *required*, so no other
|
|
28
|
+
* `PatternMatcher<unknown>` (e.g. a `P.when` guard that happens to be
|
|
29
|
+
* universal) is assignable: the catch-all `.with` overload must only fire for
|
|
30
|
+
* a pattern the type system KNOWS covers everything.
|
|
31
|
+
*
|
|
32
|
+
* @category Types
|
|
33
|
+
*/
|
|
34
|
+
type UniversalPattern = PatternMatcher<unknown> & {
|
|
35
|
+
readonly [UNIVERSAL]: true;
|
|
36
|
+
};
|
|
37
|
+
/**
|
|
38
|
+
* The type a single pattern matches: a `P.*` matcher's phantom, an object
|
|
39
|
+
* literal mapped key-by-key (so `{ _tag: "A" }` matches the `"A"`-tagged
|
|
40
|
+
* variant), or the primitive literal itself.
|
|
41
|
+
*
|
|
42
|
+
* @internal
|
|
43
|
+
*/
|
|
44
|
+
type MatchedOf<Pt> = Pt extends PatternMatcher<infer M> ? M : Pt extends object ? { [K in keyof Pt]: MatchedOf<Pt[K]>; } : Pt;
|
|
45
|
+
/**
|
|
46
|
+
* The diagnostic type of `.exhaustive` on a builder that has NOT covered every
|
|
47
|
+
* case: not callable (so it fails the `ExhaustiveMatch` constraint at the call
|
|
48
|
+
* site), and it names the remaining cases so the error reads as a to-do list.
|
|
49
|
+
*
|
|
50
|
+
* @internal
|
|
51
|
+
*/
|
|
52
|
+
type NonExhaustive<Remaining> = {
|
|
53
|
+
readonly "unthrown: this match is not exhaustive — add a `.with(…)` for the remaining cases": Remaining;
|
|
54
|
+
};
|
|
55
|
+
/**
|
|
56
|
+
* The match builder over an input union `E`. `Remaining` tracks the cases not
|
|
57
|
+
* yet covered by a `.with(…)` arm; `O` accumulates the branch output union.
|
|
58
|
+
* `.exhaustive` is callable only once `Remaining` is `never` — which is what
|
|
59
|
+
* the `ExhaustiveMatch` constraint requires — and `.run()` executes it.
|
|
60
|
+
*
|
|
61
|
+
* @typeParam E - the full input union being matched.
|
|
62
|
+
* @typeParam Remaining - the cases not yet covered.
|
|
63
|
+
* @typeParam O - the union of branch return types so far.
|
|
64
|
+
* @category Types
|
|
65
|
+
*/
|
|
66
|
+
type Matcher<E, Remaining, O> = {
|
|
67
|
+
/**
|
|
68
|
+
* The catch-all arm: `.with(P._, handler)` / `.with(P.any, handler)`. A
|
|
69
|
+
* **state transition**, not a computation — it returns `Matcher<E, never, …>`
|
|
70
|
+
* with the remaining cases literally `never`, so the builder is provably
|
|
71
|
+
* exhaustive even when `E` is an unresolved type parameter (a lazily-deferred
|
|
72
|
+
* `Exclude<E, unknown>` would not resolve there). This is what lets a
|
|
73
|
+
* boundary helper generic in `E` terminate with the catch-all (issue #145).
|
|
74
|
+
*/
|
|
75
|
+
with<O2>(pattern: UniversalPattern, handler: (value: Remaining) => O2): Matcher<E, never, O | O2>;
|
|
76
|
+
/**
|
|
77
|
+
* Add an arm: one or more patterns sharing a single handler (grouped
|
|
78
|
+
* patterns — `matcher.with(tag("A"), tag("B"), handler)`). The handler
|
|
79
|
+
* receives the input narrowed to what the patterns match (computed against
|
|
80
|
+
* `Remaining`, so cases already handled by earlier arms are excluded); the
|
|
81
|
+
* matched cases are subtracted from `Remaining`.
|
|
82
|
+
*/
|
|
83
|
+
with<const Pts extends readonly [unknown, ...unknown[]], O2>(...args: [...patterns: Pts, handler: (value: Extract<Remaining, MatchedOf<Pts[number]>>) => O2]): Matcher<E, Exclude<Remaining, MatchedOf<Pts[number]>>, O | O2>;
|
|
84
|
+
/**
|
|
85
|
+
* Terminate the match. Typed callable only when every case is covered
|
|
86
|
+
* (`Remaining` is `never`); otherwise it is a branded diagnostic object
|
|
87
|
+
* naming the remaining cases, and the builder fails the `ExhaustiveMatch`
|
|
88
|
+
* constraint at the combinator call site.
|
|
89
|
+
*/
|
|
90
|
+
exhaustive: [Remaining] extends [never] ? () => O : NonExhaustive<Remaining>;
|
|
91
|
+
/**
|
|
92
|
+
* Execute the match (the combinators call this; it runs `.exhaustive()`).
|
|
93
|
+
* A value with no matching arm throws {@link NonExhaustiveError} —
|
|
94
|
+
* unreachable for well-typed callers.
|
|
95
|
+
*/
|
|
96
|
+
run(): O;
|
|
97
|
+
};
|
|
98
|
+
/**
|
|
99
|
+
* Thrown by `.run()` / `.exhaustive()` when no arm matched the value. For
|
|
100
|
+
* well-typed callers the match is exhaustive by construction, so this is only
|
|
101
|
+
* reachable by a value that slipped past the types (a widened cast, a raw-JS
|
|
102
|
+
* caller); inside the error combinators the throw-to-defect net converts it to
|
|
103
|
+
* a `Defect`, and at the `match` edge it surfaces (a genuinely unmodeled value
|
|
104
|
+
* is a bug).
|
|
105
|
+
*
|
|
106
|
+
* @category Errors
|
|
107
|
+
*/
|
|
108
|
+
declare class NonExhaustiveError extends Error {
|
|
109
|
+
/** The value no arm matched. */
|
|
110
|
+
readonly input: unknown;
|
|
111
|
+
constructor(input: unknown);
|
|
112
|
+
}
|
|
113
|
+
/**
|
|
114
|
+
* Begin a match over `value`. Chain `.with(pattern, …patterns, handler)` arms;
|
|
115
|
+
* terminate with `.exhaustive()` — or return the un-terminated builder to an
|
|
116
|
+
* unthrown error combinator / `match({ errCases })`, which runs it for you.
|
|
117
|
+
*
|
|
118
|
+
* @remarks
|
|
119
|
+
* This is unthrown's own matcher (the former ts-pattern re-export): the same
|
|
120
|
+
* call-site shape, with exhaustiveness computed by plain `Exclude` over the
|
|
121
|
+
* builder's `Remaining` parameter. A `P._` catch-all is provably exhaustive
|
|
122
|
+
* even over an unresolved generic input.
|
|
123
|
+
*
|
|
124
|
+
* @category Constructors
|
|
125
|
+
*/
|
|
126
|
+
declare function match<const E>(value: E): Matcher<E, E, never>;
|
|
127
|
+
/**
|
|
128
|
+
* The pattern namespace (unthrown's own; the former ts-pattern `P`):
|
|
129
|
+
*
|
|
130
|
+
* - `P._` / `P.any` — the universal catch-all. Matches anything, and (because
|
|
131
|
+
* its phantom type is `unknown`) makes the builder provably exhaustive even
|
|
132
|
+
* when the matched input is an unresolved type parameter.
|
|
133
|
+
* - `P.instanceOf(Cls)` — an `instanceof` check, narrowing to the class
|
|
134
|
+
* instance type (for union members that are not tagged, e.g. a third-party
|
|
135
|
+
* error class).
|
|
136
|
+
* - `P.when(guard)` — an arbitrary type-guard predicate.
|
|
137
|
+
* - `P.union(…patterns)` — matches when any sub-pattern matches.
|
|
138
|
+
* - `P.string` / `P.number` — primitive-type wildcards.
|
|
139
|
+
*
|
|
140
|
+
* @category Constructors
|
|
141
|
+
*/
|
|
142
|
+
declare const P: Readonly<{
|
|
143
|
+
_: UniversalPattern;
|
|
144
|
+
any: UniversalPattern;
|
|
145
|
+
instanceOf: <C extends abstract new (...args: never[]) => unknown>(cls: C) => PatternMatcher<InstanceType<C>>;
|
|
146
|
+
when: <G>(guard: (value: unknown) => value is G) => PatternMatcher<G>;
|
|
147
|
+
union: <const Pts extends readonly [unknown, ...unknown[]]>(...patterns: Pts) => PatternMatcher<MatchedOf<Pts[number]>>;
|
|
148
|
+
string: PatternMatcher<string>;
|
|
149
|
+
number: PatternMatcher<number>;
|
|
150
|
+
}>;
|
|
151
|
+
//#endregion
|
|
2
152
|
//#region src/defect.d.ts
|
|
3
153
|
declare const DEFECT: unique symbol;
|
|
4
154
|
/**
|
|
@@ -55,23 +205,23 @@ type Bound<T, K extends string, U> = Prettify<Omit<T, K> & { readonly [P in K]:
|
|
|
55
205
|
*/
|
|
56
206
|
type NotThenable<R> = [R] extends [PromiseLike<unknown>] ? "unthrown: combinator callbacks are synchronous — lift async work with fromPromise and compose with flatMap" : unknown;
|
|
57
207
|
/**
|
|
58
|
-
* The
|
|
208
|
+
* The built-in match builder over an error union `E`, as produced by
|
|
59
209
|
* `match(error)`. This is what an error combinator's callback receives — chain
|
|
60
210
|
* `.with(pattern, handler)` on it; the combinator itself calls `.exhaustive()`,
|
|
61
211
|
* so the callback returns the **un-terminated** builder.
|
|
62
212
|
*
|
|
63
213
|
* @remarks
|
|
64
|
-
* Named via `ReturnType<typeof match<E>>`
|
|
65
|
-
*
|
|
214
|
+
* Named via `ReturnType<typeof match<E>>` (i.e. `Matcher<E, E, never>`),
|
|
215
|
+
* keeping this alias stable however the builder evolves.
|
|
66
216
|
*
|
|
67
217
|
* @typeParam E - the error union being matched.
|
|
68
218
|
* @category Types
|
|
69
219
|
*/
|
|
70
|
-
type ErrMatcher<E> = ReturnType<typeof match
|
|
220
|
+
type ErrMatcher<E> = ReturnType<typeof match<E>>;
|
|
71
221
|
/**
|
|
72
222
|
* The shape an error-combinator callback must return: an **exhaustive**
|
|
73
|
-
*
|
|
74
|
-
* that hasn't covered every case
|
|
223
|
+
* match builder. `exhaustive` is required to be *callable* — on a builder
|
|
224
|
+
* that hasn't covered every case the matcher types it as a branded diagnostic
|
|
75
225
|
* (not a function), so a non-exhaustive chain fails to satisfy this and errors
|
|
76
226
|
* at the call site. `run` carries the output type.
|
|
77
227
|
*
|
|
@@ -267,7 +417,7 @@ type ResultMethods<out T, out E> = {
|
|
|
267
417
|
*/
|
|
268
418
|
ensure<E2>(predicate: (value: T) => boolean, onFail: (value: T) => E2 & NotThenable<E2>): Result$1<T, E | E2>;
|
|
269
419
|
/**
|
|
270
|
-
* Transform the modeled error by **matching it exhaustively
|
|
420
|
+
* Transform the modeled error by **matching it exhaustively**.
|
|
271
421
|
*
|
|
272
422
|
* @remarks
|
|
273
423
|
* The callback receives `match(error)` (an {@link ErrMatcher}) and the
|
|
@@ -281,7 +431,7 @@ type ResultMethods<out T, out E> = {
|
|
|
281
431
|
* pass through. A branch that throws also becomes a `Defect`.
|
|
282
432
|
*
|
|
283
433
|
* `.with(P._, …)` is the deliberate uniform/catch-all (it makes the match
|
|
284
|
-
* exhaustive). Match on anything
|
|
434
|
+
* exhaustive). Match on anything the matcher supports — `_tag`, `code`,
|
|
285
435
|
* structural shape, guards, or grouped patterns `.with(a, b, handler)`.
|
|
286
436
|
*
|
|
287
437
|
* @typeParam M - the exhaustive builder the callback returns.
|
|
@@ -620,7 +770,7 @@ type FailureView<E, T = never> = ErrView<E, T> | DefectView<T, E>;
|
|
|
620
770
|
* never appears in `E`; it is the library's third, out-of-band channel.
|
|
621
771
|
*
|
|
622
772
|
* Because it is a real union, you can match it natively (a `switch` on `tag`, or
|
|
623
|
-
*
|
|
773
|
+
* the built-in `match(...).with({ tag: "Ok" }, …).exhaustive()`), *and* it
|
|
624
774
|
* carries the full method surface ({@link ResultMethods}) for fluent chaining.
|
|
625
775
|
* Either way, the payload (`value`/`error`/`cause`) is only reachable after you
|
|
626
776
|
* narrow — so "check before you access" still holds.
|
|
@@ -1746,7 +1896,7 @@ declare function TaggedError<Tag extends string>(tag: Tag, options?: {
|
|
|
1746
1896
|
readonly name?: string;
|
|
1747
1897
|
}): TaggedErrorConstructor<Tag>;
|
|
1748
1898
|
/**
|
|
1749
|
-
* A
|
|
1899
|
+
* A matcher pattern matching any value whose `_tag` equals `value` — a
|
|
1750
1900
|
* {@link TaggedError}, or any discriminated member. Equivalent to the object
|
|
1751
1901
|
* pattern `{ _tag: value }`, but reads better inside an error-matching
|
|
1752
1902
|
* combinator and narrows to the matching variant, payload included.
|
|
@@ -1769,5 +1919,5 @@ declare function tag<const Tag extends string>(value: Tag): {
|
|
|
1769
1919
|
_tag: Tag;
|
|
1770
1920
|
};
|
|
1771
1921
|
//#endregion
|
|
1772
|
-
export { type AsyncErrOf, type AsyncOkOf, AsyncResult, type AsyncResultMethods, type Awaitable, type DefectView, Do, DoAsync, Err, ErrAsync, type ErrMatcher, type ErrOf, type ErrView, type FailureView, GetError, type NotThenable, Ok, OkAsync, type OkOf, type OkView, P, Result, type ResultMethods, TaggedError, type TaggedErrorConstructor, type TaggedErrorInstance, all, allAsync, allFromDict, allFromDictAsync, fromNullable, fromPromise, fromSafePromise, fromSafeThrowable, fromThrowable, isDefect, isErr, isOk, isResult, match, tag };
|
|
1922
|
+
export { type AsyncErrOf, type AsyncOkOf, AsyncResult, type AsyncResultMethods, type Awaitable, type DefectView, Do, DoAsync, Err, ErrAsync, type ErrMatcher, type ErrOf, type ErrView, type FailureView, GetError, type Matcher, NonExhaustiveError, type NotThenable, Ok, OkAsync, type OkOf, type OkView, P, type PatternMatcher, Result, type ResultMethods, TaggedError, type TaggedErrorConstructor, type TaggedErrorInstance, type UniversalPattern, all, allAsync, allFromDict, allFromDictAsync, fromNullable, fromPromise, fromSafePromise, fromSafeThrowable, fromThrowable, isDefect, isErr, isOk, isResult, match, tag };
|
|
1773
1923
|
//# sourceMappingURL=index.d.cts.map
|
package/dist/index.d.cts.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"index.d.cts","names":[],"sources":["../src/defect.ts","../src/types.ts","../src/constructors.ts","../src/core.ts","../src/do.ts","../src/interop.ts","../src/facade.ts","../src/tagged.ts"],"mappings":";;
|
|
1
|
+
{"version":3,"file":"index.d.cts","names":[],"sources":["../src/matcher.ts","../src/defect.ts","../src/types.ts","../src/constructors.ts","../src/core.ts","../src/do.ts","../src/interop.ts","../src/facade.ts","../src/tagged.ts"],"mappings":"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"}
|