@fncts/base 0.0.19 → 0.0.21

package/_src/data/DatumEither/api.ts

@@ -54,295 +54,310 @@ export function repleteRight<E = never, A = never>(a: A): DatumEither<E, A> {
 }
 
 /**
- * @tsplus fluent fncts.DatumEither bimap
+ * @tsplus pipeable fncts.DatumEither bimap
  */
-export const bimap: <E, A, E1, B>(self: DatumEither<E, A>, f: (e: E) => E1, g: (a: A) => B) => DatumEither<E1, B> =
+export const bimap: <E, A, E1, B>(f: (e: E) => E1, g: (a: A) => B) => (self: DatumEither<E, A>) => DatumEither<E1, B> =
   EitherT.bimap(Datum.Functor);
 
 /**
- * @tsplus fluent fncts.DatumEither exists
+ * @tsplus pipeable fncts.DatumEither exists
  */
-export function exists<E, A, B extends A>(self: DatumEither<E, A>, p: Refinement<A, B>): self is DatumEither<E, B>;
-export function exists<E, A>(self: DatumEither<E, A>, p: Predicate<A>): boolean;
-export function exists<E, A>(self: DatumEither<E, A>, p: Predicate<A>): boolean {
-  return self.match3(
-    () => false,
-    () => false,
-    p,
-  );
+export function exists<A, B extends A>(p: Refinement<A, B>): <E>(self: DatumEither<E, A>) => self is DatumEither<E, B>;
+export function exists<A>(p: Predicate<A>): <E>(self: DatumEither<E, A>) => boolean;
+export function exists<A>(p: Predicate<A>) {
+  return <E>(self: DatumEither<E, A>): boolean => {
+    return self.match3(
+      () => false,
+      () => false,
+      p,
+    );
+  };
 }
 
 /**
- * @tsplus fluent fncts.DatumEither filter
+ * @tsplus pipeable fncts.DatumEither filter
  */
-export function filter<E, A, B extends A>(self: DatumEither<E, A>, p: Refinement<A, B>): DatumEither<E, B>;
-export function filter<E, A>(self: DatumEither<E, A>, p: Predicate<A>): DatumEither<E, A>;
-export function filter<E, A>(self: DatumEither<E, A>, p: Predicate<A>): DatumEither<E, A> {
-  return self.matchAll({
-    Initial: () => self,
-    Pending: () => self,
-    RefreshLeft: () => self,
-    RefreshRight: (a) => (p(a) ? self : DatumEither.initial()),
-    RepleteLeft: () => self,
-    RepleteRight: (a) => (p(a) ? self : DatumEither.initial()),
-  });
+export function filter<A, B extends A>(p: Refinement<A, B>): <E>(self: DatumEither<E, A>) => DatumEither<E, B>;
+export function filter<A>(p: Predicate<A>): <E>(self: DatumEither<E, A>) => DatumEither<E, A>;
+export function filter<A>(p: Predicate<A>) {
+  return <E>(self: DatumEither<E, A>): DatumEither<E, A> => {
+    return self.matchAll({
+      Initial: () => self,
+      Pending: () => self,
+      RefreshLeft: () => self,
+      RefreshRight: (a) => (p(a) ? self : DatumEither.initial()),
+      RepleteLeft: () => self,
+      RepleteRight: (a) => (p(a) ? self : DatumEither.initial()),
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.DatumEither filterMap
+ * @tsplus pipeable fncts.DatumEither filterMap
  */
-export function filterMap<E, A, B>(self: DatumEither<E, A>, f: (a: A) => Maybe<B>): DatumEither<E, B> {
-  return self.matchAll({
-    Initial: () => self.unsafeCoerce(),
-    Pending: () => self.unsafeCoerce(),
-    RefreshLeft: () => self.unsafeCoerce(),
-    RefreshRight: (a) =>
-      f(a).match(
-        () => DatumEither.initial(),
-        (b) => DatumEither.refreshRight(b),
-      ),
-    RepleteLeft: () => self.unsafeCoerce(),
-    RepleteRight: (a) =>
-      f(a).match(
-        () => DatumEither.initial(),
-        (b) => DatumEither.repleteRight(b),
-      ),
-  });
+export function filterMap<A, B>(f: (a: A) => Maybe<B>) {
+  return <E>(self: DatumEither<E, A>): DatumEither<E, B> => {
+    return self.matchAll({
+      Initial: () => self.unsafeCoerce(),
+      Pending: () => self.unsafeCoerce(),
+      RefreshLeft: () => self.unsafeCoerce(),
+      RefreshRight: (a) =>
+        f(a).match(
+          () => DatumEither.initial(),
+          (b) => DatumEither.refreshRight(b),
+        ),
+      RepleteLeft: () => self.unsafeCoerce(),
+      RepleteRight: (a) =>
+        f(a).match(
+          () => DatumEither.initial(),
+          (b) => DatumEither.repleteRight(b),
+        ),
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.DatumEither flatMap
+ * @tsplus pipeable fncts.DatumEither flatMap
  */
-export const flatMap: <E, A, E1, B>(
-  self: DatumEither<E, A>,
+export const flatMap: <A, E1, B>(
   f: (a: A) => DatumEither<E1, B>,
-) => DatumEither<E | E1, B> = EitherT.flatMap(Datum.Monad);
+) => <E>(self: DatumEither<E, A>) => DatumEither<E | E1, B> = EitherT.flatMap(Datum.Monad);
 
 /**
- * @tsplus fluent fncts.DatumEither foldLeft
+ * @tsplus pipeable fncts.DatumEither foldLeft
  */
-export function foldLeft<E, A, B>(self: DatumEither<E, A>, b: B, f: (b: B, a: A) => B): B {
-  return self.match3(
-    () => b,
-    () => b,
-    (a) => f(b, a),
-  );
+export function foldLeft<A, B>(b: B, f: (b: B, a: A) => B) {
+  return <E>(self: DatumEither<E, A>): B => {
+    return self.match3(
+      () => b,
+      () => b,
+      (a) => f(b, a),
+    );
+  };
 }
 
 /**
- * @tsplus fluent fncts.DatumEither foldMap
+ * @tsplus pipeable fncts.DatumEither foldMap
  */
-export function foldMap<E, A, M>(self: DatumEither<E, A>, f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): M {
-  return self.match3(
-    () => M.nat,
-    () => M.nat,
-    f,
-  );
+export function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>) {
+  return <E>(self: DatumEither<E, A>): M => {
+    return self.match3(
+      () => M.nat,
+      () => M.nat,
+      f,
+    );
+  };
 }
 
 /**
- * @tsplus fluent fncts.DatumEither foldRight
+ * @tsplus pipeable fncts.DatumEither foldRight
  */
-export function foldRight<E, A, B>(self: DatumEither<E, A>, b: B, f: (a: A, b: B) => B): B {
-  return self.match3(
-    () => b,
-    () => b,
-    (a) => f(a, b),
-  );
+export function foldRight<A, B>(b: B, f: (a: A, b: B) => B) {
+  return <E>(self: DatumEither<E, A>): B => {
+    return self.match3(
+      () => b,
+      () => b,
+      (a) => f(a, b),
+    );
+  };
 }
 
 /**
- * @tsplus fluent fncts.DatumEither getOrElse
+ * @tsplus pipeable fncts.DatumEither getOrElse
  */
-export function getOrElse<E, A, B, C>(self: DatumEither<E, A>, onEmpty: () => B, onLeft: (e: E) => C): A | B | C {
-  return self.match3(onEmpty, onLeft, Function.identity);
+export function getOrElse<E, B, C>(onEmpty: () => B, onLeft: (e: E) => C) {
+  return <A>(self: DatumEither<E, A>): A | B | C => {
+    return self.match3(onEmpty, onLeft, Function.identity);
+  };
 }
 
 /**
- * @tsplus fluent fncts.DatumEither map
+ * @tsplus pipeable fncts.DatumEither map
  */
-export const map: <E, A, B>(self: DatumEither<E, A>, f: (a: A) => B) => DatumEither<E, B> = EitherT.map(Datum.Functor);
+export const map: <E, A, B>(f: (a: A) => B) => (self: DatumEither<E, A>) => DatumEither<E, B> = EitherT.map(
+  Datum.Functor,
+);
 
 /**
- * @tsplus fluent fncts.DatumEither mapLeft
+ * @tsplus pipeable fncts.DatumEither mapLeft
  */
-export const mapLeft: <E, A, E1>(self: DatumEither<E, A>, f: (e: E) => E1) => DatumEither<E1, A> = EitherT.mapLeft(
+export const mapLeft: <E, E1>(f: (e: E) => E1) => <A>(self: DatumEither<E, A>) => DatumEither<E1, A> = EitherT.mapLeft(
   Datum.Functor,
 );
 
 /**
- * @tsplus fluent fncts.DatumEither match
+ * @tsplus pipeable fncts.DatumEither match
  */
 export function match<E, A, B, C, D, F>(
-  self: DatumEither<E, A>,
   onInitial: () => B,
   onPending: () => C,
   onLeft: (e: E, isLoading: boolean) => D,
   onRight: (a: A, isLoading: boolean) => F,
-): B | C | D | F {
-  return self.matchAll({
-    Initial: onInitial,
-    Pending: onPending,
-    RefreshLeft: (e) => onLeft(e, true),
-    RefreshRight: (a) => onRight(a, true),
-    RepleteLeft: (e) => onLeft(e, false),
-    RepleteRight: (a) => onRight(a, false),
-  });
+) {
+  return (self: DatumEither<E, A>): B | C | D | F => {
+    return self.matchAll({
+      Initial: onInitial,
+      Pending: onPending,
+      RefreshLeft: (e) => onLeft(e, true),
+      RefreshRight: (a) => onRight(a, true),
+      RepleteLeft: (e) => onLeft(e, false),
+      RepleteRight: (a) => onRight(a, false),
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.DatumEither match3
+ * @tsplus pipeable fncts.DatumEither match3
  */
 export function match3<E, A, B, C, D>(
-  self: DatumEither<E, A>,
   onEmpty: (loading: boolean) => B,
   onLeft: (e: E, loading: boolean) => C,
   onRight: (a: A, loading: boolean) => D,
-): B | C | D {
-  return self.matchAll({
-    Initial: () => onEmpty(false),
-    Pending: () => onEmpty(true),
-    RefreshLeft: (e) => onLeft(e, true),
-    RefreshRight: (a) => onRight(a, true),
-    RepleteLeft: (e) => onLeft(e, false),
-    RepleteRight: (a) => onRight(a, false),
-  });
+) {
+  return (self: DatumEither<E, A>): B | C | D => {
+    return self.matchAll({
+      Initial: () => onEmpty(false),
+      Pending: () => onEmpty(true),
+      RefreshLeft: (e) => onLeft(e, true),
+      RefreshRight: (a) => onRight(a, true),
+      RepleteLeft: (e) => onLeft(e, false),
+      RepleteRight: (a) => onRight(a, false),
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.DatumEither matchAll
+ * @tsplus pipeable fncts.DatumEither matchAll
  */
-export function matchAll<E, A, B, C, D, F, G, H>(
-  self: DatumEither<E, A>,
-  cases: {
-    Initial: () => B;
-    Pending: () => C;
-    RefreshLeft: (e: E) => D;
-    RefreshRight: (a: A) => F;
-    RepleteLeft: (e: E) => G;
-    RepleteRight: (a: A) => H;
-  },
-): B | C | D | F | G | H {
-  switch (self._tag) {
-    case DatumTag.Initial:
-      return cases.Initial();
-    case DatumTag.Pending:
-      return cases.Pending();
-    case DatumTag.Refresh:
-      Either.concrete(self.value);
-      switch (self.value._tag) {
-        case EitherTag.Left:
-          return cases.RefreshLeft(self.value.left);
-        case EitherTag.Right:
-          return cases.RefreshRight(self.value.right);
-      }
-    case DatumTag.Replete:
-      Either.concrete(self.value);
-      switch (self.value._tag) {
-        case EitherTag.Left:
-          return cases.RepleteLeft(self.value.left);
-        case EitherTag.Right:
-          return cases.RepleteRight(self.value.right);
-      }
-  }
+export function matchAll<E, A, B, C, D, F, G, H>(cases: {
+  Initial: () => B;
+  Pending: () => C;
+  RefreshLeft: (e: E) => D;
+  RefreshRight: (a: A) => F;
+  RepleteLeft: (e: E) => G;
+  RepleteRight: (a: A) => H;
+}) {
+  return (self: DatumEither<E, A>): B | C | D | F | G | H => {
+    switch (self._tag) {
+      case DatumTag.Initial:
+        return cases.Initial();
+      case DatumTag.Pending:
+        return cases.Pending();
+      case DatumTag.Refresh:
+        Either.concrete(self.value);
+        switch (self.value._tag) {
+          case EitherTag.Left:
+            return cases.RefreshLeft(self.value.left);
+          case EitherTag.Right:
+            return cases.RefreshRight(self.value.right);
+        }
+      case DatumTag.Replete:
+        Either.concrete(self.value);
+        switch (self.value._tag) {
+          case EitherTag.Left:
+            return cases.RepleteLeft(self.value.left);
+          case EitherTag.Right:
+            return cases.RepleteRight(self.value.right);
+        }
+    }
+  };
 }
 
 /**
- * @tsplus fluent fncts.DatumEither matchEither
+ * @tsplus pipeable fncts.DatumEither matchEither
  */
-export const matchEither: <E, A, B, C, D, F>(
-  self: DatumEither<E, A>,
-  cases: {
-    Initial: () => B;
-    Pending: () => C;
-    Refresh: (value: Either<E, A>) => D;
-    Replete: (value: Either<E, A>) => F;
-  },
-) => B | C | D | F = _.match;
+export const matchEither: <E, A, B, C, D, F>(cases: {
+  Initial: () => B;
+  Pending: () => C;
+  Refresh: (value: Either<E, A>) => D;
+  Replete: (value: Either<E, A>) => F;
+}) => (self: DatumEither<E, A>) => B | C | D | F = _.match;
 
 /**
- * @tsplus fluent fncts.DatumEither orElse
+ * @tsplus pipeable fncts.DatumEither orElse
  */
-export const orElse: <E, A, E1, B>(
-  self: DatumEither<E, A>,
+export const orElse: <E1, B>(
   that: Lazy<DatumEither<E1, B>>,
-) => DatumEither<E | E1, A | B> = EitherT.orElse(Datum.Monad);
+) => <E, A>(self: DatumEither<E, A>) => DatumEither<E | E1, A | B> = EitherT.orElse(Datum.Monad);
 
 /**
- * @tsplus fluent fncts.DatumEither partition
+ * @tsplus pipeable fncts.DatumEither partition
  */
-export function partition<E, A, B extends A>(
-  self: DatumEither<E, A>,
+export function partition<A, B extends A>(
   p: Refinement<A, B>,
-): [DatumEither<E, A>, DatumEither<E, B>];
-export function partition<E, A>(self: DatumEither<E, A>, p: Predicate<A>): [DatumEither<E, A>, DatumEither<E, A>];
-export function partition<E, A>(self: DatumEither<E, A>, p: Predicate<A>): [DatumEither<E, A>, DatumEither<E, A>] {
-  return [self.filter(p.invert), self.filter(p)];
+): <E>(self: DatumEither<E, A>) => [DatumEither<E, A>, DatumEither<E, B>];
+export function partition<A>(p: Predicate<A>): <E>(self: DatumEither<E, A>) => [DatumEither<E, A>, DatumEither<E, A>];
+export function partition<A>(p: Predicate<A>) {
+  return <E>(self: DatumEither<E, A>): [DatumEither<E, A>, DatumEither<E, A>] => {
+    return [self.filter(p.invert), self.filter(p)];
+  };
 }
 
 /**
- * @tsplus fluent fncts.DatumEither partitionMap
+ * @tsplus pipeable fncts.DatumEither partitionMap
  */
-export function partitionMap<E, A, B, C>(
-  self: DatumEither<E, A>,
-  f: (a: A) => Either<B, C>,
-): [DatumEither<E, B>, DatumEither<E, C>] {
-  return self.matchAll({
-    Initial: () => [self.unsafeCoerce(), self.unsafeCoerce()],
-    Pending: () => [self.unsafeCoerce(), self.unsafeCoerce()],
-    RefreshLeft: () => [self.unsafeCoerce(), self.unsafeCoerce()],
-    RefreshRight: (a) =>
-      f(a).match(
-        (b) => [DatumEither.refreshRight(b), DatumEither.initial()],
-        (c) => [DatumEither.initial(), DatumEither.refreshRight(c)],
-      ),
-    RepleteLeft: () => [self.unsafeCoerce(), self.unsafeCoerce()],
-    RepleteRight: (a) =>
-      f(a).match(
-        (b) => [DatumEither.repleteRight(b), DatumEither.initial()],
-        (c) => [DatumEither.initial(), DatumEither.repleteRight(c)],
-      ),
-  });
+export function partitionMap<A, B, C>(f: (a: A) => Either<B, C>) {
+  return <E>(self: DatumEither<E, A>): [DatumEither<E, B>, DatumEither<E, C>] => {
+    return self.matchAll({
+      Initial: () => [self.unsafeCoerce(), self.unsafeCoerce()],
+      Pending: () => [self.unsafeCoerce(), self.unsafeCoerce()],
+      RefreshLeft: () => [self.unsafeCoerce(), self.unsafeCoerce()],
+      RefreshRight: (a) =>
+        f(a).match(
+          (b) => [DatumEither.refreshRight(b), DatumEither.initial()],
+          (c) => [DatumEither.initial(), DatumEither.refreshRight(c)],
+        ),
+      RepleteLeft: () => [self.unsafeCoerce(), self.unsafeCoerce()],
+      RepleteRight: (a) =>
+        f(a).match(
+          (b) => [DatumEither.repleteRight(b), DatumEither.initial()],
+          (c) => [DatumEither.initial(), DatumEither.repleteRight(c)],
+        ),
+    });
+  };
 }
-
 /**
  * @tsplus getter fncts.DatumEither toPending
  */
 export const toPending: <E, A>(self: DatumEither<E, A>) => DatumEither<E, A> = _.toPending;
-
 /**
  * @tsplus getter fncts.DatumEither toReplete
  */
 export const toReplete: <E, A>(self: DatumEither<E, A>) => DatumEither<E, A> = _.toReplete;
 
 /**
- * @tsplus fluent fncts.DatumEither traverse
+ * @tsplus getter fncts.DatumEither traverse
  */
-export const traverse: P.Traversable<DatumEitherF>["traverse"] = (self) => (G) => (f) =>
-  self.matchAll({
-    Initial: () => G.pure(self.unsafeCoerce()),
-    Pending: () => G.pure(self.unsafeCoerce()),
-    RefreshLeft: () => G.pure(self.unsafeCoerce()),
-    RefreshRight: (a) => G.map(f(a), (b) => DatumEither.refreshRight(b)),
-    RepleteLeft: () => G.pure(self.unsafeCoerce()),
-    RepleteRight: (a) => G.map(f(a), (b) => DatumEither.repleteRight(b)),
-  });
+export function _traverse<E, A>(self: DatumEither<E, A>) {
+  return <G extends HKT, GC = HKT.None>(G: P.Applicative<G, GC>) =>
+    <K, Q, W, X, I, S, R, E1, B>(
+      f: (a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, B>,
+    ): HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, DatumEither<E, B>> =>
+      self.matchAll({
+        Initial: () => G.pure(self.unsafeCoerce()),
+        Pending: () => G.pure(self.unsafeCoerce()),
+        RefreshLeft: () => G.pure(self.unsafeCoerce()),
+        RefreshRight: (a) => f(a).pipe(G.map((b) => DatumEither.refreshRight(b))),
+        RepleteLeft: () => G.pure(self.unsafeCoerce()),
+        RepleteRight: (a) => f(a).pipe(G.map((b) => DatumEither.repleteRight(b))),
+      });
+}
+
+export const traverse: P.Traversable<DatumEitherF>["traverse"] = (G) => (f) => (self) => self.traverse(G)(f);
 
 /**
- * @tsplus fluent fncts.DatumEither zipWith
+ * @tsplus pipeable fncts.DatumEither zipWith
  */
-export const zipWith: <E, A, E1, B, C>(
-  self: DatumEither<E, A>,
+export const zipWith: <A, E1, B, C>(
   that: DatumEither<E1, B>,
   f: (a: A, b: B) => C,
-) => DatumEither<E | E1, C> = EitherT.zipWith(Datum.Apply);
+) => <E>(self: DatumEither<E, A>) => DatumEither<E | E1, C> = EitherT.zipWith(Datum.Apply);
 
 /**
- * @tsplus fluent fncts.DatumEither zip
+ * @tsplus pipeable fncts.DatumEither zip
  */
-export function zip<E, A, E1, B>(
-  self: DatumEither<E, A>,
-  that: DatumEither<E1, B>,
-): DatumEither<E | E1, Zipped.Make<A, B>> {
-  return self.zipWith(that, (a, b) => Zipped(a, b));
+export function zip<E1, B>(that: DatumEither<E1, B>) {
+  return <E, A>(self: DatumEither<E, A>): DatumEither<E | E1, Zipped.Make<A, B>> => {
+    return self.zipWith(that, (a, b) => Zipped(a, b));
+  };
 }

package/_src/data/Decoder/api.ts

@@ -15,10 +15,12 @@ import {
 import { Decoder } from "@fncts/base/data/Decoder/definition";
 
 /**
- * @tsplus fluent fncts.Decoder __call
+ * @tsplus pipeable fncts.Decoder __call
  */
-export function decode<A>(self: Decoder<A>, input: unknown): These<DecodeError, A> {
-  return self.decode(input);
+export function decode(input: unknown) {
+  return <A>(self: Decoder<A>): These<DecodeError, A> => {
+    return self.decode(input);
+  };
 }
 
 export function fromGuard<A>(guard: Guard<A>, onFalse: (i: unknown) => DecodeError, label: string): Decoder<A> {

package/_src/data/Duration/api.ts

@@ -1,5 +1,3 @@
-import type { IsInt } from "@fncts/base/types";
-
 /**
  * @tsplus getter fncts.Number milliseconds
  * @tsplus static fncts.DurationOps milliseconds
@@ -21,7 +19,7 @@ export function seconds(self: number): Duration {
  * @tsplus static fncts.DurationOps minutes
  */
 export function minutes(self: number): Duration {
-  return new Duration(Math.round(self * 60_000));
+  return new Duration(Math.round(self * 60000));
 }
 
 /**
@@ -29,7 +27,7 @@ export function minutes(self: number): Duration {
  * @tsplus static fncts.DurationOps hours
  */
 export function hours(self: number): Duration {
-  return new Duration(Math.round(self * 3_600_000));
+  return new Duration(Math.round(self * 3600000));
 }
 
 /**
@@ -37,35 +35,41 @@ export function hours(self: number): Duration {
  * @tsplus static fncts.DurationOps days
  */
 export function days(self: number): Duration {
-  return new Duration(Math.round(self * 86_400_000));
+  return new Duration(Math.round(self * 86400000));
 }
 
 /**
- * @tsplus operator fncts.Duration *
+ * @tsplus pipeable-operator fncts.Duration *
  */
-export function mult(self: Duration, multiplicand: number) {
-  return new Duration(self.milliseconds * Math.round(multiplicand));
+export function product(multiplicand: number) {
+  return (self: Duration): Duration => {
+    return new Duration(self.milliseconds * Math.round(multiplicand));
+  };
 }
 
 /**
  * @tsplus operator fncts.Duration *
  */
-export function multInverted(multiplicand: number, self: Duration) {
+export function multiplyInverted(multiplicand: number, self: Duration) {
   return new Duration(Math.round(self.milliseconds) * multiplicand);
 }
 
 /**
- * @tsplus operator fncts.Duration +
+ * @tsplus pipeable-operator fncts.Duration +
  */
-export function sum(self: Duration, that: Duration): Duration {
-  return new Duration(self.milliseconds + that.milliseconds);
+export function sum(that: Duration) {
+  return (self: Duration): Duration => {
+    return new Duration(self.milliseconds + that.milliseconds);
+  };
 }
 
 /**
- * @tsplus operator fncts.Duration -
+ * @tsplus pipeable-operator fncts.Duration -
  */
-export function difference(self: Duration, that: Duration): Duration {
-  return new Duration(self.milliseconds - that.milliseconds);
+export function difference(that: Duration) {
+  return (self: Duration): Duration => {
+    return new Duration(self.milliseconds - that.milliseconds);
+  };
 }
 
 /**

package/_src/data/Either/api/align.ts

@@ -3,6 +3,11 @@ import type { Either } from "../definition.js";
 
 import { identity } from "../../function.js";
 
-export function align_<E1, A, E2, B>(self: Either<E1, A>, fb: Either<E2, B>): Either<E1 | E2, These<A, B>> {
-  return self.alignWith(fb, identity);
+/**
+ * @tsplus pipeable fncts.Either align
+ */
+export function align<E2, B>(fb: Either<E2, B>) {
+  return <E1, A>(self: Either<E1, A>): Either<E1 | E2, These<A, B>> => {
+    return self.alignWith(fb, identity);
+  };
 }

package/_src/data/Either/api/alignWith.ts

@@ -4,20 +4,18 @@ import { These } from "../../These.js";
 import { EitherTag, Right } from "../definition.js";
 
 /**
- * @tsplus fluent fncts.Either alignWith
+ * @tsplus pipeable fncts.Either alignWith
  */
-export function alignWith_<E1, A, E2, B, C>(
-  self: Either<E1, A>,
-  fb: Either<E2, B>,
-  f: (_: These<A, B>) => C,
-): Either<E1 | E2, C> {
-  self.concrete();
-  fb.concrete();
-  return self._tag === EitherTag.Left
-    ? fb._tag === EitherTag.Left
-      ? self
-      : Right(f(These.right(fb.right)))
-    : fb._tag === EitherTag.Left
-    ? Right(f(These.left(self.right)))
-    : Right(f(These.both(self.right, fb.right)));
+export function alignWith<A, E2, B, C>(fb: Either<E2, B>, f: (_: These<A, B>) => C) {
+  return <E1>(self: Either<E1, A>): Either<E1 | E2, C> => {
+    self.concrete();
+    fb.concrete();
+    return self._tag === EitherTag.Left
+      ? fb._tag === EitherTag.Left
+        ? self
+        : Right(f(These.right(fb.right)))
+      : fb._tag === EitherTag.Left
+      ? Right(f(These.left(self.right)))
+      : Right(f(These.both(self.right, fb.right)));
+  };
 }