retuple 1.0.0-next.24 → 1.0.0-next.25

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.
Files changed (5) hide show
  1. package/dist/index.cjs +87 -9
  2. package/dist/index.d.cts +112 -34
  3. package/dist/index.d.ts +112 -34
  4. package/dist/index.js +87 -9
  5. package/package.json +1 -1
package/dist/index.cjs CHANGED
@@ -123,6 +123,8 @@ Result.$any = $any;
123
123
  Result.$anyPromised = $anyPromised;
124
124
  Result.$collect = $collect;
125
125
  Result.$collectPromised = $collectPromised;
126
+ Result.$pipe = $pipe;
127
+ Result.$pipeAsync = $pipeAsync;
126
128
  Object.freeze(Result);
127
129
  function Ok(val) {
128
130
  return new ResultOk(val);
@@ -489,6 +491,38 @@ function $collectPromised(results) {
489
491
  }))).then((values) => resolve(Ok(Object.fromEntries(values))), (err) => resolve(Err(err)));
490
492
  }));
491
493
  }
494
+ function $pipe(f0, ...fnx) {
495
+ const first = asResult(f0());
496
+ if (first instanceof ResultErr) {
497
+ return first;
498
+ }
499
+ let current = first[1];
500
+ for (const fn of fnx) {
501
+ const result = asResult(fn(current));
502
+ if (result instanceof ResultErr) {
503
+ return result;
504
+ }
505
+ current = result[1];
506
+ }
507
+ return Ok(current);
508
+ }
509
+ function $pipeAsync(f0, ...fnx) {
510
+ return new ResultAsync((async () => {
511
+ const first = asResult(await f0());
512
+ if (first instanceof ResultErr) {
513
+ return first;
514
+ }
515
+ let current = first[1];
516
+ for (const fn of fnx) {
517
+ const result = asResult(await fn(current));
518
+ if (result instanceof ResultErr) {
519
+ return result;
520
+ }
521
+ current = result[1];
522
+ }
523
+ return Ok(current);
524
+ })());
525
+ }
492
526
  /**
493
527
  * ## ResultOk
494
528
  *
@@ -545,13 +579,17 @@ class ResultOk extends Array {
545
579
  $mapOrElse(_def, f) {
546
580
  return Ok(f(this[1]));
547
581
  }
548
- $andAssert(mapError = mapCheckError) {
582
+ $assert(mapError = mapCheckError) {
549
583
  return this[1] ? this : Err(mapError(this[1]));
550
584
  }
551
- $andCheck(check, mapError = mapCheckError) {
585
+ $check(check, mapError = mapCheckError) {
552
586
  return check(this[1]) ? this : Err(mapError(this[1]));
553
587
  }
554
- $andFirst(mapError = mapCheckError) {
588
+ $atIndex(index, mapError = mapCheckError) {
589
+ const element = this[1][index];
590
+ return element ? Ok(element) : Err(mapError(this[1]));
591
+ }
592
+ $firstIndex(mapError = mapCheckError) {
555
593
  const first = this[1][0];
556
594
  return first ? Ok(first) : Err(mapError(this[1]));
557
595
  }
@@ -609,6 +647,12 @@ class ResultOk extends Array {
609
647
  $andSafePromise(promise, mapError = ensureError) {
610
648
  return this.$async().$andSafePromise(promise, mapError);
611
649
  }
650
+ $andPipe(f0, ...fx) {
651
+ return Result.$pipe(() => f0(this[1]), ...fx);
652
+ }
653
+ $andPipeAsync(f0, ...fx) {
654
+ return Result.$pipeAsync(() => f0(this[1]), ...fx);
655
+ }
612
656
  $peek(f) {
613
657
  f(this);
614
658
  return this;
@@ -692,13 +736,16 @@ class ResultErr extends Array {
692
736
  $mapOrElse(def) {
693
737
  return Ok(def(this[0]));
694
738
  }
695
- $andAssert() {
739
+ $assert() {
740
+ return this;
741
+ }
742
+ $check() {
696
743
  return this;
697
744
  }
698
- $andCheck() {
745
+ $atIndex() {
699
746
  return this;
700
747
  }
701
- $andFirst() {
748
+ $firstIndex() {
702
749
  return this;
703
750
  }
704
751
  $or(or) {
@@ -754,6 +801,12 @@ class ResultErr extends Array {
754
801
  $andSafePromise() {
755
802
  return this.$async();
756
803
  }
804
+ $andPipe() {
805
+ return this;
806
+ }
807
+ $andPipeAsync() {
808
+ return this.$async();
809
+ }
757
810
  $peek(f) {
758
811
  f(this);
759
812
  return this;
@@ -869,7 +922,7 @@ class ResultAsync {
869
922
  : new ResultOk(def(res[0]));
870
923
  }));
871
924
  }
872
- $andAssert(mapError = mapCheckError) {
925
+ $assert(mapError = mapCheckError) {
873
926
  return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
874
927
  if (res instanceof ResultErr) {
875
928
  return res;
@@ -879,7 +932,7 @@ class ResultAsync {
879
932
  : Err(mapError(res[1]));
880
933
  }));
881
934
  }
882
- $andCheck(check, mapError = mapCheckError) {
935
+ $check(check, mapError = mapCheckError) {
883
936
  return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
884
937
  if (res instanceof ResultErr) {
885
938
  return res;
@@ -887,7 +940,16 @@ class ResultAsync {
887
940
  return check(res[1]) ? res : Err(mapError(res[1]));
888
941
  }));
889
942
  }
890
- $andFirst(mapError = mapCheckError) {
943
+ $atIndex(index, mapError = mapCheckError) {
944
+ return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then((res) => {
945
+ if (res instanceof ResultErr) {
946
+ return res;
947
+ }
948
+ const element = res[1][index];
949
+ return element ? Ok(element) : Err(mapError(res[1]));
950
+ }));
951
+ }
952
+ $firstIndex(mapError = mapCheckError) {
891
953
  return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then((res) => {
892
954
  if (res instanceof ResultErr) {
893
955
  return res;
@@ -987,6 +1049,22 @@ class ResultAsync {
987
1049
  }
988
1050
  }));
989
1051
  }
1052
+ $andPipe(...fx) {
1053
+ return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
1054
+ if (res instanceof ResultErr) {
1055
+ return res;
1056
+ }
1057
+ let current = res[1];
1058
+ for (const f of fx) {
1059
+ const result = asResult(await f(current));
1060
+ if (result instanceof ResultErr) {
1061
+ return result;
1062
+ }
1063
+ current = result[1];
1064
+ }
1065
+ return Ok(current);
1066
+ }));
1067
+ }
990
1068
  /**
991
1069
  * The same as {@link Retuple.$peek|$peek}, except it:
992
1070
  *
package/dist/index.d.cts CHANGED
@@ -112,6 +112,24 @@ export declare namespace Result {
112
112
  var $anyPromised: <const TResults extends ResultLikeAwaitable<any, any>[]>(results: TResults) => ResultAsync<AnyOk<TResults>, AnyErr<TResults>>;
113
113
  var $collect: <TResults extends Record<string, ResultLike<any, any>>>(results: TResults) => Result<CollectOk<TResults>, CollectErr<TResults>>;
114
114
  var $collectPromised: <TResults extends Record<string, ResultLikeAwaitable<any, any>>>(results: TResults) => ResultAsync<CollectOk<TResults>, CollectErr<TResults>>;
115
+ var $pipe: {
116
+ <T0, E0, T1, E1>(f0: () => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>): Result<T1, E0 | E1>;
117
+ <T0, E0, T1, E1, T2, E2>(f0: () => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>): Result<T2, E0 | E1 | E2>;
118
+ <T0, E0, T1, E1, T2, E2, T3, E3>(f0: () => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>, f3: (val2: T2) => ResultLike<T3, E3>): Result<T3, E0 | E1 | E2 | E3>;
119
+ <T0, E0, T1, E1, T2, E2, T3, E3, T4, E4>(f0: () => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>, f3: (val2: T2) => ResultLike<T3, E3>, f4: (val3: T3) => ResultLike<T4, E4>): Result<T4, E0 | E1 | E2 | E3 | E4>;
120
+ <T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5>(f0: () => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>, f3: (val2: T2) => ResultLike<T3, E3>, f4: (val3: T3) => ResultLike<T4, E4>, f5: (val4: T4) => ResultLike<T5, E5>): Result<T5, E0 | E1 | E2 | E3 | E4 | E5>;
121
+ <T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5, T6, E6>(f0: () => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>, f3: (val2: T2) => ResultLike<T3, E3>, f4: (val3: T3) => ResultLike<T4, E4>, f5: (val4: T4) => ResultLike<T5, E5>, f6: (val5: T5) => ResultLike<T6, E6>): Result<T6, E0 | E1 | E2 | E3 | E4 | E5 | E6>;
122
+ <T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5, T6, E6, T7, E7>(f0: () => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>, f3: (val2: T2) => ResultLike<T3, E3>, f4: (val3: T3) => ResultLike<T4, E4>, f5: (val4: T4) => ResultLike<T5, E5>, f6: (val5: T5) => ResultLike<T6, E6>, f7: (val6: T6) => ResultLike<T7, E7>): Result<T7, E0 | E1 | E2 | E3 | E4 | E5 | E6 | E7>;
123
+ };
124
+ var $pipeAsync: {
125
+ <T0, E0, T1, E1>(f0: () => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>): ResultAsync<T1, E0 | E1>;
126
+ <T0, E0, T1, E1, T2, E2>(f0: () => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>): ResultAsync<T2, E0 | E1 | E2>;
127
+ <T0, E0, T1, E1, T2, E2, T3, E3>(f0: () => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>): ResultAsync<T3, E0 | E1 | E2 | E3>;
128
+ <T0, E0, T1, E1, T2, E2, T3, E3, T4, E4>(f0: () => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>): ResultAsync<T4, E0 | E1 | E2 | E3 | E4>;
129
+ <T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5>(f0: () => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>, f5: (val4: T4) => ResultLikeAwaitable<T5, E5>): ResultAsync<T5, E0 | E1 | E2 | E3 | E4 | E5>;
130
+ <T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5, T6, E6>(f0: () => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>, f5: (val4: T4) => ResultLikeAwaitable<T5, E5>, f6: (val5: T5) => ResultLikeAwaitable<T6, E6>): ResultAsync<T6, E0 | E1 | E2 | E3 | E4 | E5 | E6>;
131
+ <T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5, T6, E6, T7, E7>(f0: () => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>, f5: (val4: T4) => ResultLikeAwaitable<T5, E5>, f6: (val5: T5) => ResultLikeAwaitable<T6, E6>, f7: (val6: T6) => ResultLikeAwaitable<T7, E7>): ResultAsync<T7, E0 | E1 | E2 | E3 | E4 | E5 | E6 | E7>;
132
+ };
115
133
  }
116
134
  /**
117
135
  * Create a new {@link Result} with the `Ok` variant. When called without
@@ -208,33 +226,31 @@ declare class ResultAsync<T, E> {
208
226
  */
209
227
  $mapOrElse<U, V = U>(this: ResultAsync<T, E>, def: (err: E) => U, f: (val: T) => V): ResultAsync<U | V, never>;
210
228
  /**
211
- * The same as {@link Retuple.$andCheck|$andAssert}, except it:
212
- *
213
- * - can also accept a `PromiseLike` default value;
214
- * - returns {@link ResultAsync}.
229
+ * The same as {@link Retuple.$check|$andAssert}, except it returns
230
+ * {@link ResultAsync}.
215
231
  */
216
- $andAssert(this: ResultAsync<T, E>): ResultAsync<Truthy<T>, E | RetupleCheckFailedError<T>>;
217
- $andAssert<F = E>(this: ResultAsync<T, E>, mapError: (val: T) => F): ResultAsync<Truthy<T>, E | F>;
232
+ $assert(this: ResultAsync<T, E>): ResultAsync<Truthy<T>, E | RetupleCheckFailedError<T>>;
233
+ $assert<F = E>(this: ResultAsync<T, E>, mapError: (val: T) => F): ResultAsync<Truthy<T>, E | F>;
218
234
  /**
219
- * The same as {@link Retuple.$andCheck|$andCheck}, except it:
220
- *
221
- * - can also accept an `async` default function;
222
- * - returns {@link ResultAsync}.
235
+ * The same as {@link Retuple.$check|$andCheck}, except it returns
236
+ * {@link ResultAsync}.
223
237
  */
224
- $andCheck<U extends T = T>(this: ResultAsync<T, E>, predicate: (val: T) => val is U): ResultAsync<U, E | RetupleCheckFailedError<T>>;
225
- $andCheck(this: ResultAsync<T, E>, check: (val: T) => unknown): ResultAsync<T, E | RetupleCheckFailedError<T>>;
226
- $andCheck<U extends T = T, F = E>(this: ResultAsync<T, E>, predicate: (val: T) => val is U, mapError: (val: T) => F): ResultAsync<U, E | F>;
227
- $andCheck<F = E>(this: ResultAsync<T, E>, check: (val: T) => unknown, mapError: (val: T) => F): ResultAsync<T, E | F>;
238
+ $check<U extends T = T>(this: ResultAsync<T, E>, predicate: (val: T) => val is U): ResultAsync<U, E | RetupleCheckFailedError<T>>;
239
+ $check(this: ResultAsync<T, E>, check: (val: T) => unknown): ResultAsync<T, E | RetupleCheckFailedError<T>>;
240
+ $check<U extends T = T, F = E>(this: ResultAsync<T, E>, predicate: (val: T) => val is U, mapError: (val: T) => F): ResultAsync<U, E | F>;
241
+ $check<F = E>(this: ResultAsync<T, E>, check: (val: T) => unknown, mapError: (val: T) => F): ResultAsync<T, E | F>;
228
242
  /**
229
- * The same as {@link Retuple.$andCheck|$andCheck}, except it:
230
- *
231
- * - can also accept an `async` default function;
232
- * - returns {@link ResultAsync}.
243
+ * The same as {@link Retuple.$atIndex|$atIndex}, except it returns
244
+ * {@link ResultAsync}.
245
+ */
246
+ $atIndex<U>(this: ResultAsync<readonly U[], E>, index: number): ResultAsync<U, E | RetupleCheckFailedError<T>>;
247
+ $atIndex<U, F = E>(this: ResultAsync<readonly U[], E>, index: number, mapError: (val: T) => F): ResultAsync<U, E | F>;
248
+ /**
249
+ * The same as {@link Retuple.$firstIndex|$firstIndex}, except it returns
250
+ * {@link ResultAsync}.
233
251
  */
234
- $andFirst<U>(this: ResultAsync<readonly [U?, ...any[]], E>): ResultAsync<U, E | RetupleCheckFailedError<T>>;
235
- $andFirst(this: ResultAsync<readonly [], E>): ResultAsync<never, E | RetupleCheckFailedError<T>>;
236
- $andFirst<U, F = E>(this: ResultAsync<readonly [U?, ...any[]], E>, mapError: (val: T) => F): ResultAsync<U, E | F>;
237
- $andFirst<F = E>(this: ResultAsync<readonly [], E>, mapError: (val: T) => F): ResultAsync<T, E | F>;
252
+ $firstIndex<U>(this: ResultAsync<readonly U[], E>): ResultAsync<U, E | RetupleCheckFailedError<T>>;
253
+ $firstIndex<U, F = E>(this: ResultAsync<readonly U[], E>, mapError: (val: T) => F): ResultAsync<U, E | F>;
238
254
  /**
239
255
  * The same as {@link Retuple.$or|$or}, except it:
240
256
  *
@@ -316,6 +332,30 @@ declare class ResultAsync<T, E> {
316
332
  */
317
333
  $andSafePromise<U = T>(this: ResultAsync<T, E>, promise: PromiseLike<U>): ResultAsync<U, E | Error>;
318
334
  $andSafePromise<U = T, F = E>(this: ResultAsync<T, E>, promise: PromiseLike<U>, mapError: (err: unknown) => F): ResultAsync<U, E | F>;
335
+ /**
336
+ * Execute a pipeline starting with the resolved `Ok` value of this result,
337
+ * resolving to the `Ok` of the final function in the pipe or the first
338
+ * `Err` encountered. If you only need to execute a single function, use
339
+ * `$andThen`.
340
+ *
341
+ * Uses the same strategy as {@link Result.$pipeAsync}, equivalent to calling:
342
+ *
343
+ * ```ts
344
+ * resultAsync.$andThen(
345
+ * (val) => Result.$pipeAsync(
346
+ * () => fn1(val),
347
+ * async (val2) => fn2(val2),
348
+ * ),
349
+ * );
350
+ * ```
351
+ */
352
+ $andPipe<T0, E0, T1, E1>(this: ResultAsync<T, E>, f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>): ResultAsync<T1, E0 | E1>;
353
+ $andPipe<T0, E0, T1, E1, T2, E2>(this: ResultAsync<T, E>, f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>): ResultAsync<T2, E0 | E1 | E2>;
354
+ $andPipe<T0, E0, T1, E1, T2, E2, T3, E3>(this: ResultAsync<T, E>, f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>): ResultAsync<T3, E0 | E1 | E2 | E3>;
355
+ $andPipe<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4>(this: ResultAsync<T, E>, f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>): ResultAsync<T4, E0 | E1 | E2 | E3 | E4>;
356
+ $andPipe<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5>(this: ResultAsync<T, E>, f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>, f5: (val4: T4) => ResultLikeAwaitable<T5, E5>): ResultAsync<T5, E0 | E1 | E2 | E3 | E4 | E5>;
357
+ $andPipe<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5, T6, E6>(this: ResultAsync<T, E>, f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>, f5: (val4: T4) => ResultLikeAwaitable<T5, E5>, f6: (val5: T5) => ResultLikeAwaitable<T6, E6>): ResultAsync<T6, E0 | E1 | E2 | E3 | E4 | E5 | E6>;
358
+ $andPipe<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5, T6, E6, T7, E7>(this: ResultAsync<T, E>, f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>, f5: (val4: T4) => ResultLikeAwaitable<T5, E5>, f6: (val5: T5) => ResultLikeAwaitable<T6, E6>, f7: (val6: T6) => ResultLikeAwaitable<T7, E7>): ResultAsync<T7, E | E0 | E1 | E2 | E3 | E4 | E5 | E6 | E7>;
319
359
  /**
320
360
  * The same as {@link Retuple.$peek|$peek}, except it:
321
361
  *
@@ -778,8 +818,8 @@ interface Retuple<T, E> extends ResultLike<T, E> {
778
818
  * assert.equal(asserted.$unwrapErr(), "value was null");
779
819
  * ```
780
820
  */
781
- $andAssert(this: Result<T, E>): Result<Truthy<T>, E | RetupleCheckFailedError<T>>;
782
- $andAssert<F = E>(this: Result<T, E>, mapError: (val: T) => F): Result<Truthy<T>, E | F>;
821
+ $assert(this: Result<T, E>): Result<Truthy<T>, E | RetupleCheckFailedError<T>>;
822
+ $assert<F = E>(this: Result<T, E>, mapError: (val: T) => F): Result<Truthy<T>, E | F>;
783
823
  /**
784
824
  * Performs a check when this result is `Ok`:
785
825
  *
@@ -815,15 +855,15 @@ interface Retuple<T, E> extends ResultLike<T, E> {
815
855
  * assert.equal(checked.$unwrapErr(), "value was test");
816
856
  * ```
817
857
  */
818
- $andCheck<U extends T = T>(this: Result<T, E>, predicate: (val: T) => val is U): Result<U, E | RetupleCheckFailedError<T>>;
819
- $andCheck(this: Result<T, E>, check: (val: T) => unknown): Result<T, E | RetupleCheckFailedError<T>>;
820
- $andCheck<U extends T = T, F = E>(this: Result<T, E>, predicate: (val: T) => val is U, mapError: (val: T) => F): Result<U, E | F>;
821
- $andCheck<F = E>(this: Result<T, E>, check: (val: T) => unknown, mapError: (val: T) => F): Result<T, E | F>;
858
+ $check<U extends T = T>(this: Result<T, E>, predicate: (val: T) => val is U): Result<U, E | RetupleCheckFailedError<T>>;
859
+ $check(this: Result<T, E>, check: (val: T) => unknown): Result<T, E | RetupleCheckFailedError<T>>;
860
+ $check<U extends T = T, F = E>(this: Result<T, E>, predicate: (val: T) => val is U, mapError: (val: T) => F): Result<U, E | F>;
861
+ $check<F = E>(this: Result<T, E>, check: (val: T) => unknown, mapError: (val: T) => F): Result<T, E | F>;
822
862
  /**
823
- * Checks the first element of the contained array when when this result
863
+ * Checks the specified element of the contained array when when this result
824
864
  * is `Ok`:
825
865
  *
826
- * - returning `Ok` containing the first array element when it is truthy.
866
+ * - returning `Ok` containing the specified element when it is truthy.
827
867
  * Narrows the type to include only truthy values;
828
868
  * - returning `Err` containing the return value of the map error function
829
869
  * when the first array element fails the check;
@@ -855,10 +895,13 @@ interface Retuple<T, E> extends ResultLike<T, E> {
855
895
  * assert.equal(first.$unwrapErr(), "value was null");
856
896
  * ```
857
897
  */
858
- $andFirst(this: Result<readonly [], E>): Result<never, E | RetupleCheckFailedError<[]>>;
859
- $andFirst<U>(this: Result<readonly [U?, ...any[]], E>): Result<Truthy<U>, E | RetupleCheckFailedError<T>>;
860
- $andFirst<F = E>(this: Result<readonly [], E>, mapError: (val: readonly []) => F): Result<never, E | F>;
861
- $andFirst<U, F = E>(this: Result<readonly [U?, ...any[]], E>, mapError: (val: T) => F): Result<Truthy<U>, E | F>;
898
+ $atIndex<U>(this: Result<readonly U[], E>, index: number): Result<Truthy<U>, E | RetupleCheckFailedError<T>>;
899
+ $atIndex<U, F = E>(this: Result<readonly U[], E>, index: number, mapError: (val: T) => F): Result<Truthy<U>, E | F>;
900
+ /**
901
+ * Equivalent to calling `result.$atIndex(0)`.
902
+ */
903
+ $firstIndex<U>(this: Result<readonly U[], E>): Result<Truthy<U>, E | RetupleCheckFailedError<T>>;
904
+ $firstIndex<U, F = E>(this: Result<readonly U[], E>, mapError: (val: T) => F): Result<Truthy<U>, E | F>;
862
905
  /**
863
906
  * Returns `Ok` containing the return value of the map function when this
864
907
  * result is `Ok`.
@@ -1223,6 +1266,41 @@ interface Retuple<T, E> extends ResultLike<T, E> {
1223
1266
  */
1224
1267
  $andSafePromise<U = T>(this: Result<T, E>, promise: PromiseLike<U>): ResultAsync<U, E | Error>;
1225
1268
  $andSafePromise<U = T, F = E>(this: Result<T, E>, promise: PromiseLike<U>, mapError: (err: unknown) => F): ResultAsync<U, E | F>;
1269
+ /**
1270
+ * Execute a pipeline starting with the `Ok` value of this result, returning
1271
+ * the `Ok` of the final function in the pipe or the first `Err` encountered.
1272
+ * If you only need to execute a single function, use `$andThen`
1273
+ *
1274
+ * Uses the same strategy as {@link Result.$pipe}, equivalent to calling:
1275
+ *
1276
+ * ```ts
1277
+ * result.$andThen(
1278
+ * (val) => Result.$pipe(
1279
+ * () => fn1(val),
1280
+ * (val2) => fn2(val2),
1281
+ * ),
1282
+ * );
1283
+ * ```
1284
+ */
1285
+ $andPipe<T0, E0, T1, E1>(this: ResultLike<T, E>, f0: (val: T) => ResultLike<T0, E0>, f1: (val: T0) => ResultLike<T1, E1>): Result<T1, E | E0 | E1>;
1286
+ $andPipe<T0, E0, T1, E1, T2, E2>(f0: (val: T) => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>): Result<T2, E | E0 | E1 | E2>;
1287
+ $andPipe<T0, E0, T1, E1, T2, E2, T3, E3>(f0: (val: T) => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>, f3: (val2: T2) => ResultLike<T3, E3>): Result<T3, E | E0 | E1 | E2 | E3>;
1288
+ $andPipe<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4>(f0: (val: T) => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>, f3: (val2: T2) => ResultLike<T3, E3>, f4: (val3: T3) => ResultLike<T4, E4>): Result<T4, E | E0 | E1 | E2 | E3 | E4>;
1289
+ $andPipe<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5>(f0: (val: T) => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>, f3: (val2: T2) => ResultLike<T3, E3>, f4: (val3: T3) => ResultLike<T4, E4>, f5: (val4: T4) => ResultLike<T5, E5>): Result<T5, E | E0 | E1 | E2 | E3 | E4 | E5>;
1290
+ $andPipe<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5, T6, E6>(f0: (val: T) => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>, f3: (val2: T2) => ResultLike<T3, E3>, f4: (val3: T3) => ResultLike<T4, E4>, f5: (val4: T4) => ResultLike<T5, E5>, f6: (val5: T5) => ResultLike<T6, E6>): Result<T6, E | E0 | E1 | E2 | E3 | E4 | E5 | E6>;
1291
+ $andPipe<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5, T6, E6, T7, E7>(f0: (val: T) => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>, f3: (val2: T2) => ResultLike<T3, E3>, f4: (val3: T3) => ResultLike<T4, E4>, f5: (val4: T4) => ResultLike<T5, E5>, f6: (val5: T5) => ResultLike<T6, E6>, f7: (val6: T6) => ResultLike<T7, E7>): Result<T7, E | E0 | E1 | E2 | E3 | E4 | E5 | E6 | E7>;
1292
+ /**
1293
+ * Shorthand for `result.$async().$andPipe(...)`
1294
+ *
1295
+ * If you only need to execute a single function, use `$andThenAsync`
1296
+ */
1297
+ $andPipeAsync<T0, E0, T1, E1>(f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>): ResultAsync<T1, E0 | E1>;
1298
+ $andPipeAsync<T0, E0, T1, E1, T2, E2>(f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>): ResultAsync<T2, E0 | E1 | E2>;
1299
+ $andPipeAsync<T0, E0, T1, E1, T2, E2, T3, E3>(f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>): ResultAsync<T3, E0 | E1 | E2 | E3>;
1300
+ $andPipeAsync<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4>(f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>): ResultAsync<T4, E0 | E1 | E2 | E3 | E4>;
1301
+ $andPipeAsync<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5>(f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>, f5: (val4: T4) => ResultLikeAwaitable<T5, E5>): ResultAsync<T5, E0 | E1 | E2 | E3 | E4 | E5>;
1302
+ $andPipeAsync<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5, T6, E6>(f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>, f5: (val4: T4) => ResultLikeAwaitable<T5, E5>, f6: (val5: T5) => ResultLikeAwaitable<T6, E6>): ResultAsync<T6, E0 | E1 | E2 | E3 | E4 | E5 | E6>;
1303
+ $andPipeAsync<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5, T6, E6, T7, E7>(f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>, f5: (val4: T4) => ResultLikeAwaitable<T5, E5>, f6: (val5: T5) => ResultLikeAwaitable<T6, E6>, f7: (val6: T6) => ResultLikeAwaitable<T7, E7>): ResultAsync<T7, E | E0 | E1 | E2 | E3 | E4 | E5 | E6 | E7>;
1226
1304
  /**
1227
1305
  * Calls the peek function and returns {@link Result} equivalent to this
1228
1306
  * result.
package/dist/index.d.ts CHANGED
@@ -112,6 +112,24 @@ export declare namespace Result {
112
112
  var $anyPromised: <const TResults extends ResultLikeAwaitable<any, any>[]>(results: TResults) => ResultAsync<AnyOk<TResults>, AnyErr<TResults>>;
113
113
  var $collect: <TResults extends Record<string, ResultLike<any, any>>>(results: TResults) => Result<CollectOk<TResults>, CollectErr<TResults>>;
114
114
  var $collectPromised: <TResults extends Record<string, ResultLikeAwaitable<any, any>>>(results: TResults) => ResultAsync<CollectOk<TResults>, CollectErr<TResults>>;
115
+ var $pipe: {
116
+ <T0, E0, T1, E1>(f0: () => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>): Result<T1, E0 | E1>;
117
+ <T0, E0, T1, E1, T2, E2>(f0: () => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>): Result<T2, E0 | E1 | E2>;
118
+ <T0, E0, T1, E1, T2, E2, T3, E3>(f0: () => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>, f3: (val2: T2) => ResultLike<T3, E3>): Result<T3, E0 | E1 | E2 | E3>;
119
+ <T0, E0, T1, E1, T2, E2, T3, E3, T4, E4>(f0: () => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>, f3: (val2: T2) => ResultLike<T3, E3>, f4: (val3: T3) => ResultLike<T4, E4>): Result<T4, E0 | E1 | E2 | E3 | E4>;
120
+ <T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5>(f0: () => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>, f3: (val2: T2) => ResultLike<T3, E3>, f4: (val3: T3) => ResultLike<T4, E4>, f5: (val4: T4) => ResultLike<T5, E5>): Result<T5, E0 | E1 | E2 | E3 | E4 | E5>;
121
+ <T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5, T6, E6>(f0: () => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>, f3: (val2: T2) => ResultLike<T3, E3>, f4: (val3: T3) => ResultLike<T4, E4>, f5: (val4: T4) => ResultLike<T5, E5>, f6: (val5: T5) => ResultLike<T6, E6>): Result<T6, E0 | E1 | E2 | E3 | E4 | E5 | E6>;
122
+ <T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5, T6, E6, T7, E7>(f0: () => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>, f3: (val2: T2) => ResultLike<T3, E3>, f4: (val3: T3) => ResultLike<T4, E4>, f5: (val4: T4) => ResultLike<T5, E5>, f6: (val5: T5) => ResultLike<T6, E6>, f7: (val6: T6) => ResultLike<T7, E7>): Result<T7, E0 | E1 | E2 | E3 | E4 | E5 | E6 | E7>;
123
+ };
124
+ var $pipeAsync: {
125
+ <T0, E0, T1, E1>(f0: () => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>): ResultAsync<T1, E0 | E1>;
126
+ <T0, E0, T1, E1, T2, E2>(f0: () => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>): ResultAsync<T2, E0 | E1 | E2>;
127
+ <T0, E0, T1, E1, T2, E2, T3, E3>(f0: () => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>): ResultAsync<T3, E0 | E1 | E2 | E3>;
128
+ <T0, E0, T1, E1, T2, E2, T3, E3, T4, E4>(f0: () => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>): ResultAsync<T4, E0 | E1 | E2 | E3 | E4>;
129
+ <T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5>(f0: () => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>, f5: (val4: T4) => ResultLikeAwaitable<T5, E5>): ResultAsync<T5, E0 | E1 | E2 | E3 | E4 | E5>;
130
+ <T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5, T6, E6>(f0: () => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>, f5: (val4: T4) => ResultLikeAwaitable<T5, E5>, f6: (val5: T5) => ResultLikeAwaitable<T6, E6>): ResultAsync<T6, E0 | E1 | E2 | E3 | E4 | E5 | E6>;
131
+ <T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5, T6, E6, T7, E7>(f0: () => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>, f5: (val4: T4) => ResultLikeAwaitable<T5, E5>, f6: (val5: T5) => ResultLikeAwaitable<T6, E6>, f7: (val6: T6) => ResultLikeAwaitable<T7, E7>): ResultAsync<T7, E0 | E1 | E2 | E3 | E4 | E5 | E6 | E7>;
132
+ };
115
133
  }
116
134
  /**
117
135
  * Create a new {@link Result} with the `Ok` variant. When called without
@@ -208,33 +226,31 @@ declare class ResultAsync<T, E> {
208
226
  */
209
227
  $mapOrElse<U, V = U>(this: ResultAsync<T, E>, def: (err: E) => U, f: (val: T) => V): ResultAsync<U | V, never>;
210
228
  /**
211
- * The same as {@link Retuple.$andCheck|$andAssert}, except it:
212
- *
213
- * - can also accept a `PromiseLike` default value;
214
- * - returns {@link ResultAsync}.
229
+ * The same as {@link Retuple.$check|$andAssert}, except it returns
230
+ * {@link ResultAsync}.
215
231
  */
216
- $andAssert(this: ResultAsync<T, E>): ResultAsync<Truthy<T>, E | RetupleCheckFailedError<T>>;
217
- $andAssert<F = E>(this: ResultAsync<T, E>, mapError: (val: T) => F): ResultAsync<Truthy<T>, E | F>;
232
+ $assert(this: ResultAsync<T, E>): ResultAsync<Truthy<T>, E | RetupleCheckFailedError<T>>;
233
+ $assert<F = E>(this: ResultAsync<T, E>, mapError: (val: T) => F): ResultAsync<Truthy<T>, E | F>;
218
234
  /**
219
- * The same as {@link Retuple.$andCheck|$andCheck}, except it:
220
- *
221
- * - can also accept an `async` default function;
222
- * - returns {@link ResultAsync}.
235
+ * The same as {@link Retuple.$check|$andCheck}, except it returns
236
+ * {@link ResultAsync}.
223
237
  */
224
- $andCheck<U extends T = T>(this: ResultAsync<T, E>, predicate: (val: T) => val is U): ResultAsync<U, E | RetupleCheckFailedError<T>>;
225
- $andCheck(this: ResultAsync<T, E>, check: (val: T) => unknown): ResultAsync<T, E | RetupleCheckFailedError<T>>;
226
- $andCheck<U extends T = T, F = E>(this: ResultAsync<T, E>, predicate: (val: T) => val is U, mapError: (val: T) => F): ResultAsync<U, E | F>;
227
- $andCheck<F = E>(this: ResultAsync<T, E>, check: (val: T) => unknown, mapError: (val: T) => F): ResultAsync<T, E | F>;
238
+ $check<U extends T = T>(this: ResultAsync<T, E>, predicate: (val: T) => val is U): ResultAsync<U, E | RetupleCheckFailedError<T>>;
239
+ $check(this: ResultAsync<T, E>, check: (val: T) => unknown): ResultAsync<T, E | RetupleCheckFailedError<T>>;
240
+ $check<U extends T = T, F = E>(this: ResultAsync<T, E>, predicate: (val: T) => val is U, mapError: (val: T) => F): ResultAsync<U, E | F>;
241
+ $check<F = E>(this: ResultAsync<T, E>, check: (val: T) => unknown, mapError: (val: T) => F): ResultAsync<T, E | F>;
228
242
  /**
229
- * The same as {@link Retuple.$andCheck|$andCheck}, except it:
230
- *
231
- * - can also accept an `async` default function;
232
- * - returns {@link ResultAsync}.
243
+ * The same as {@link Retuple.$atIndex|$atIndex}, except it returns
244
+ * {@link ResultAsync}.
245
+ */
246
+ $atIndex<U>(this: ResultAsync<readonly U[], E>, index: number): ResultAsync<U, E | RetupleCheckFailedError<T>>;
247
+ $atIndex<U, F = E>(this: ResultAsync<readonly U[], E>, index: number, mapError: (val: T) => F): ResultAsync<U, E | F>;
248
+ /**
249
+ * The same as {@link Retuple.$firstIndex|$firstIndex}, except it returns
250
+ * {@link ResultAsync}.
233
251
  */
234
- $andFirst<U>(this: ResultAsync<readonly [U?, ...any[]], E>): ResultAsync<U, E | RetupleCheckFailedError<T>>;
235
- $andFirst(this: ResultAsync<readonly [], E>): ResultAsync<never, E | RetupleCheckFailedError<T>>;
236
- $andFirst<U, F = E>(this: ResultAsync<readonly [U?, ...any[]], E>, mapError: (val: T) => F): ResultAsync<U, E | F>;
237
- $andFirst<F = E>(this: ResultAsync<readonly [], E>, mapError: (val: T) => F): ResultAsync<T, E | F>;
252
+ $firstIndex<U>(this: ResultAsync<readonly U[], E>): ResultAsync<U, E | RetupleCheckFailedError<T>>;
253
+ $firstIndex<U, F = E>(this: ResultAsync<readonly U[], E>, mapError: (val: T) => F): ResultAsync<U, E | F>;
238
254
  /**
239
255
  * The same as {@link Retuple.$or|$or}, except it:
240
256
  *
@@ -316,6 +332,30 @@ declare class ResultAsync<T, E> {
316
332
  */
317
333
  $andSafePromise<U = T>(this: ResultAsync<T, E>, promise: PromiseLike<U>): ResultAsync<U, E | Error>;
318
334
  $andSafePromise<U = T, F = E>(this: ResultAsync<T, E>, promise: PromiseLike<U>, mapError: (err: unknown) => F): ResultAsync<U, E | F>;
335
+ /**
336
+ * Execute a pipeline starting with the resolved `Ok` value of this result,
337
+ * resolving to the `Ok` of the final function in the pipe or the first
338
+ * `Err` encountered. If you only need to execute a single function, use
339
+ * `$andThen`.
340
+ *
341
+ * Uses the same strategy as {@link Result.$pipeAsync}, equivalent to calling:
342
+ *
343
+ * ```ts
344
+ * resultAsync.$andThen(
345
+ * (val) => Result.$pipeAsync(
346
+ * () => fn1(val),
347
+ * async (val2) => fn2(val2),
348
+ * ),
349
+ * );
350
+ * ```
351
+ */
352
+ $andPipe<T0, E0, T1, E1>(this: ResultAsync<T, E>, f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>): ResultAsync<T1, E0 | E1>;
353
+ $andPipe<T0, E0, T1, E1, T2, E2>(this: ResultAsync<T, E>, f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>): ResultAsync<T2, E0 | E1 | E2>;
354
+ $andPipe<T0, E0, T1, E1, T2, E2, T3, E3>(this: ResultAsync<T, E>, f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>): ResultAsync<T3, E0 | E1 | E2 | E3>;
355
+ $andPipe<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4>(this: ResultAsync<T, E>, f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>): ResultAsync<T4, E0 | E1 | E2 | E3 | E4>;
356
+ $andPipe<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5>(this: ResultAsync<T, E>, f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>, f5: (val4: T4) => ResultLikeAwaitable<T5, E5>): ResultAsync<T5, E0 | E1 | E2 | E3 | E4 | E5>;
357
+ $andPipe<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5, T6, E6>(this: ResultAsync<T, E>, f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>, f5: (val4: T4) => ResultLikeAwaitable<T5, E5>, f6: (val5: T5) => ResultLikeAwaitable<T6, E6>): ResultAsync<T6, E0 | E1 | E2 | E3 | E4 | E5 | E6>;
358
+ $andPipe<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5, T6, E6, T7, E7>(this: ResultAsync<T, E>, f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>, f5: (val4: T4) => ResultLikeAwaitable<T5, E5>, f6: (val5: T5) => ResultLikeAwaitable<T6, E6>, f7: (val6: T6) => ResultLikeAwaitable<T7, E7>): ResultAsync<T7, E | E0 | E1 | E2 | E3 | E4 | E5 | E6 | E7>;
319
359
  /**
320
360
  * The same as {@link Retuple.$peek|$peek}, except it:
321
361
  *
@@ -778,8 +818,8 @@ interface Retuple<T, E> extends ResultLike<T, E> {
778
818
  * assert.equal(asserted.$unwrapErr(), "value was null");
779
819
  * ```
780
820
  */
781
- $andAssert(this: Result<T, E>): Result<Truthy<T>, E | RetupleCheckFailedError<T>>;
782
- $andAssert<F = E>(this: Result<T, E>, mapError: (val: T) => F): Result<Truthy<T>, E | F>;
821
+ $assert(this: Result<T, E>): Result<Truthy<T>, E | RetupleCheckFailedError<T>>;
822
+ $assert<F = E>(this: Result<T, E>, mapError: (val: T) => F): Result<Truthy<T>, E | F>;
783
823
  /**
784
824
  * Performs a check when this result is `Ok`:
785
825
  *
@@ -815,15 +855,15 @@ interface Retuple<T, E> extends ResultLike<T, E> {
815
855
  * assert.equal(checked.$unwrapErr(), "value was test");
816
856
  * ```
817
857
  */
818
- $andCheck<U extends T = T>(this: Result<T, E>, predicate: (val: T) => val is U): Result<U, E | RetupleCheckFailedError<T>>;
819
- $andCheck(this: Result<T, E>, check: (val: T) => unknown): Result<T, E | RetupleCheckFailedError<T>>;
820
- $andCheck<U extends T = T, F = E>(this: Result<T, E>, predicate: (val: T) => val is U, mapError: (val: T) => F): Result<U, E | F>;
821
- $andCheck<F = E>(this: Result<T, E>, check: (val: T) => unknown, mapError: (val: T) => F): Result<T, E | F>;
858
+ $check<U extends T = T>(this: Result<T, E>, predicate: (val: T) => val is U): Result<U, E | RetupleCheckFailedError<T>>;
859
+ $check(this: Result<T, E>, check: (val: T) => unknown): Result<T, E | RetupleCheckFailedError<T>>;
860
+ $check<U extends T = T, F = E>(this: Result<T, E>, predicate: (val: T) => val is U, mapError: (val: T) => F): Result<U, E | F>;
861
+ $check<F = E>(this: Result<T, E>, check: (val: T) => unknown, mapError: (val: T) => F): Result<T, E | F>;
822
862
  /**
823
- * Checks the first element of the contained array when when this result
863
+ * Checks the specified element of the contained array when when this result
824
864
  * is `Ok`:
825
865
  *
826
- * - returning `Ok` containing the first array element when it is truthy.
866
+ * - returning `Ok` containing the specified element when it is truthy.
827
867
  * Narrows the type to include only truthy values;
828
868
  * - returning `Err` containing the return value of the map error function
829
869
  * when the first array element fails the check;
@@ -855,10 +895,13 @@ interface Retuple<T, E> extends ResultLike<T, E> {
855
895
  * assert.equal(first.$unwrapErr(), "value was null");
856
896
  * ```
857
897
  */
858
- $andFirst(this: Result<readonly [], E>): Result<never, E | RetupleCheckFailedError<[]>>;
859
- $andFirst<U>(this: Result<readonly [U?, ...any[]], E>): Result<Truthy<U>, E | RetupleCheckFailedError<T>>;
860
- $andFirst<F = E>(this: Result<readonly [], E>, mapError: (val: readonly []) => F): Result<never, E | F>;
861
- $andFirst<U, F = E>(this: Result<readonly [U?, ...any[]], E>, mapError: (val: T) => F): Result<Truthy<U>, E | F>;
898
+ $atIndex<U>(this: Result<readonly U[], E>, index: number): Result<Truthy<U>, E | RetupleCheckFailedError<T>>;
899
+ $atIndex<U, F = E>(this: Result<readonly U[], E>, index: number, mapError: (val: T) => F): Result<Truthy<U>, E | F>;
900
+ /**
901
+ * Equivalent to calling `result.$atIndex(0)`.
902
+ */
903
+ $firstIndex<U>(this: Result<readonly U[], E>): Result<Truthy<U>, E | RetupleCheckFailedError<T>>;
904
+ $firstIndex<U, F = E>(this: Result<readonly U[], E>, mapError: (val: T) => F): Result<Truthy<U>, E | F>;
862
905
  /**
863
906
  * Returns `Ok` containing the return value of the map function when this
864
907
  * result is `Ok`.
@@ -1223,6 +1266,41 @@ interface Retuple<T, E> extends ResultLike<T, E> {
1223
1266
  */
1224
1267
  $andSafePromise<U = T>(this: Result<T, E>, promise: PromiseLike<U>): ResultAsync<U, E | Error>;
1225
1268
  $andSafePromise<U = T, F = E>(this: Result<T, E>, promise: PromiseLike<U>, mapError: (err: unknown) => F): ResultAsync<U, E | F>;
1269
+ /**
1270
+ * Execute a pipeline starting with the `Ok` value of this result, returning
1271
+ * the `Ok` of the final function in the pipe or the first `Err` encountered.
1272
+ * If you only need to execute a single function, use `$andThen`
1273
+ *
1274
+ * Uses the same strategy as {@link Result.$pipe}, equivalent to calling:
1275
+ *
1276
+ * ```ts
1277
+ * result.$andThen(
1278
+ * (val) => Result.$pipe(
1279
+ * () => fn1(val),
1280
+ * (val2) => fn2(val2),
1281
+ * ),
1282
+ * );
1283
+ * ```
1284
+ */
1285
+ $andPipe<T0, E0, T1, E1>(this: ResultLike<T, E>, f0: (val: T) => ResultLike<T0, E0>, f1: (val: T0) => ResultLike<T1, E1>): Result<T1, E | E0 | E1>;
1286
+ $andPipe<T0, E0, T1, E1, T2, E2>(f0: (val: T) => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>): Result<T2, E | E0 | E1 | E2>;
1287
+ $andPipe<T0, E0, T1, E1, T2, E2, T3, E3>(f0: (val: T) => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>, f3: (val2: T2) => ResultLike<T3, E3>): Result<T3, E | E0 | E1 | E2 | E3>;
1288
+ $andPipe<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4>(f0: (val: T) => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>, f3: (val2: T2) => ResultLike<T3, E3>, f4: (val3: T3) => ResultLike<T4, E4>): Result<T4, E | E0 | E1 | E2 | E3 | E4>;
1289
+ $andPipe<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5>(f0: (val: T) => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>, f3: (val2: T2) => ResultLike<T3, E3>, f4: (val3: T3) => ResultLike<T4, E4>, f5: (val4: T4) => ResultLike<T5, E5>): Result<T5, E | E0 | E1 | E2 | E3 | E4 | E5>;
1290
+ $andPipe<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5, T6, E6>(f0: (val: T) => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>, f3: (val2: T2) => ResultLike<T3, E3>, f4: (val3: T3) => ResultLike<T4, E4>, f5: (val4: T4) => ResultLike<T5, E5>, f6: (val5: T5) => ResultLike<T6, E6>): Result<T6, E | E0 | E1 | E2 | E3 | E4 | E5 | E6>;
1291
+ $andPipe<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5, T6, E6, T7, E7>(f0: (val: T) => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>, f3: (val2: T2) => ResultLike<T3, E3>, f4: (val3: T3) => ResultLike<T4, E4>, f5: (val4: T4) => ResultLike<T5, E5>, f6: (val5: T5) => ResultLike<T6, E6>, f7: (val6: T6) => ResultLike<T7, E7>): Result<T7, E | E0 | E1 | E2 | E3 | E4 | E5 | E6 | E7>;
1292
+ /**
1293
+ * Shorthand for `result.$async().$andPipe(...)`
1294
+ *
1295
+ * If you only need to execute a single function, use `$andThenAsync`
1296
+ */
1297
+ $andPipeAsync<T0, E0, T1, E1>(f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>): ResultAsync<T1, E0 | E1>;
1298
+ $andPipeAsync<T0, E0, T1, E1, T2, E2>(f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>): ResultAsync<T2, E0 | E1 | E2>;
1299
+ $andPipeAsync<T0, E0, T1, E1, T2, E2, T3, E3>(f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>): ResultAsync<T3, E0 | E1 | E2 | E3>;
1300
+ $andPipeAsync<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4>(f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>): ResultAsync<T4, E0 | E1 | E2 | E3 | E4>;
1301
+ $andPipeAsync<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5>(f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>, f5: (val4: T4) => ResultLikeAwaitable<T5, E5>): ResultAsync<T5, E0 | E1 | E2 | E3 | E4 | E5>;
1302
+ $andPipeAsync<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5, T6, E6>(f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>, f5: (val4: T4) => ResultLikeAwaitable<T5, E5>, f6: (val5: T5) => ResultLikeAwaitable<T6, E6>): ResultAsync<T6, E0 | E1 | E2 | E3 | E4 | E5 | E6>;
1303
+ $andPipeAsync<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5, T6, E6, T7, E7>(f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>, f5: (val4: T4) => ResultLikeAwaitable<T5, E5>, f6: (val5: T5) => ResultLikeAwaitable<T6, E6>, f7: (val6: T6) => ResultLikeAwaitable<T7, E7>): ResultAsync<T7, E | E0 | E1 | E2 | E3 | E4 | E5 | E6 | E7>;
1226
1304
  /**
1227
1305
  * Calls the peek function and returns {@link Result} equivalent to this
1228
1306
  * result.
package/dist/index.js CHANGED
@@ -111,6 +111,8 @@ Result.$any = $any;
111
111
  Result.$anyPromised = $anyPromised;
112
112
  Result.$collect = $collect;
113
113
  Result.$collectPromised = $collectPromised;
114
+ Result.$pipe = $pipe;
115
+ Result.$pipeAsync = $pipeAsync;
114
116
  Object.freeze(Result);
115
117
  export function Ok(val) {
116
118
  return new ResultOk(val);
@@ -477,6 +479,38 @@ function $collectPromised(results) {
477
479
  }))).then((values) => resolve(Ok(Object.fromEntries(values))), (err) => resolve(Err(err)));
478
480
  }));
479
481
  }
482
+ function $pipe(f0, ...fnx) {
483
+ const first = asResult(f0());
484
+ if (first instanceof ResultErr) {
485
+ return first;
486
+ }
487
+ let current = first[1];
488
+ for (const fn of fnx) {
489
+ const result = asResult(fn(current));
490
+ if (result instanceof ResultErr) {
491
+ return result;
492
+ }
493
+ current = result[1];
494
+ }
495
+ return Ok(current);
496
+ }
497
+ function $pipeAsync(f0, ...fnx) {
498
+ return new ResultAsync((async () => {
499
+ const first = asResult(await f0());
500
+ if (first instanceof ResultErr) {
501
+ return first;
502
+ }
503
+ let current = first[1];
504
+ for (const fn of fnx) {
505
+ const result = asResult(await fn(current));
506
+ if (result instanceof ResultErr) {
507
+ return result;
508
+ }
509
+ current = result[1];
510
+ }
511
+ return Ok(current);
512
+ })());
513
+ }
480
514
  /**
481
515
  * ## ResultOk
482
516
  *
@@ -533,13 +567,17 @@ class ResultOk extends Array {
533
567
  $mapOrElse(_def, f) {
534
568
  return Ok(f(this[1]));
535
569
  }
536
- $andAssert(mapError = mapCheckError) {
570
+ $assert(mapError = mapCheckError) {
537
571
  return this[1] ? this : Err(mapError(this[1]));
538
572
  }
539
- $andCheck(check, mapError = mapCheckError) {
573
+ $check(check, mapError = mapCheckError) {
540
574
  return check(this[1]) ? this : Err(mapError(this[1]));
541
575
  }
542
- $andFirst(mapError = mapCheckError) {
576
+ $atIndex(index, mapError = mapCheckError) {
577
+ const element = this[1][index];
578
+ return element ? Ok(element) : Err(mapError(this[1]));
579
+ }
580
+ $firstIndex(mapError = mapCheckError) {
543
581
  const first = this[1][0];
544
582
  return first ? Ok(first) : Err(mapError(this[1]));
545
583
  }
@@ -597,6 +635,12 @@ class ResultOk extends Array {
597
635
  $andSafePromise(promise, mapError = ensureError) {
598
636
  return this.$async().$andSafePromise(promise, mapError);
599
637
  }
638
+ $andPipe(f0, ...fx) {
639
+ return Result.$pipe(() => f0(this[1]), ...fx);
640
+ }
641
+ $andPipeAsync(f0, ...fx) {
642
+ return Result.$pipeAsync(() => f0(this[1]), ...fx);
643
+ }
600
644
  $peek(f) {
601
645
  f(this);
602
646
  return this;
@@ -680,13 +724,16 @@ class ResultErr extends Array {
680
724
  $mapOrElse(def) {
681
725
  return Ok(def(this[0]));
682
726
  }
683
- $andAssert() {
727
+ $assert() {
728
+ return this;
729
+ }
730
+ $check() {
684
731
  return this;
685
732
  }
686
- $andCheck() {
733
+ $atIndex() {
687
734
  return this;
688
735
  }
689
- $andFirst() {
736
+ $firstIndex() {
690
737
  return this;
691
738
  }
692
739
  $or(or) {
@@ -742,6 +789,12 @@ class ResultErr extends Array {
742
789
  $andSafePromise() {
743
790
  return this.$async();
744
791
  }
792
+ $andPipe() {
793
+ return this;
794
+ }
795
+ $andPipeAsync() {
796
+ return this.$async();
797
+ }
745
798
  $peek(f) {
746
799
  f(this);
747
800
  return this;
@@ -857,7 +910,7 @@ class ResultAsync {
857
910
  : new ResultOk(def(res[0]));
858
911
  }));
859
912
  }
860
- $andAssert(mapError = mapCheckError) {
913
+ $assert(mapError = mapCheckError) {
861
914
  return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
862
915
  if (res instanceof ResultErr) {
863
916
  return res;
@@ -867,7 +920,7 @@ class ResultAsync {
867
920
  : Err(mapError(res[1]));
868
921
  }));
869
922
  }
870
- $andCheck(check, mapError = mapCheckError) {
923
+ $check(check, mapError = mapCheckError) {
871
924
  return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
872
925
  if (res instanceof ResultErr) {
873
926
  return res;
@@ -875,7 +928,16 @@ class ResultAsync {
875
928
  return check(res[1]) ? res : Err(mapError(res[1]));
876
929
  }));
877
930
  }
878
- $andFirst(mapError = mapCheckError) {
931
+ $atIndex(index, mapError = mapCheckError) {
932
+ return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then((res) => {
933
+ if (res instanceof ResultErr) {
934
+ return res;
935
+ }
936
+ const element = res[1][index];
937
+ return element ? Ok(element) : Err(mapError(res[1]));
938
+ }));
939
+ }
940
+ $firstIndex(mapError = mapCheckError) {
879
941
  return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then((res) => {
880
942
  if (res instanceof ResultErr) {
881
943
  return res;
@@ -975,6 +1037,22 @@ class ResultAsync {
975
1037
  }
976
1038
  }));
977
1039
  }
1040
+ $andPipe(...fx) {
1041
+ return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
1042
+ if (res instanceof ResultErr) {
1043
+ return res;
1044
+ }
1045
+ let current = res[1];
1046
+ for (const f of fx) {
1047
+ const result = asResult(await f(current));
1048
+ if (result instanceof ResultErr) {
1049
+ return result;
1050
+ }
1051
+ current = result[1];
1052
+ }
1053
+ return Ok(current);
1054
+ }));
1055
+ }
978
1056
  /**
979
1057
  * The same as {@link Retuple.$peek|$peek}, except it:
980
1058
  *
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "retuple",
3
- "version": "1.0.0-next.24",
3
+ "version": "1.0.0-next.25",
4
4
  "scripts": {
5
5
  "test": "vitest",
6
6
  "lint": "eslint . --ext .ts -c eslint.config.mjs --fix",