@fncts/base 0.0.28 → 0.0.29

package/_src/data/Cause/definition.ts

@@ -12,7 +12,7 @@ export type CauseTypeId = typeof CauseTypeId;
 /**
  * @tsplus type fncts.Cause
  */
-export type Cause<E> = Empty | Halt | Interrupt | Fail<E> | Then<E> | Both<E> | Stackless<E>;
+export type Cause<E> = Empty | Halt | Interrupt | Fail<E> | Sequential<E> | Parallel<E> | Stackless<E>;
 
 /**
  * @tsplus type fncts.CauseOps
@@ -30,8 +30,8 @@ export const enum CauseTag {
   Fail = "Fail",
   Halt = "Halt",
   Interrupt = "Interrupt",
-  Then = "Then",
-  Both = "Both",
+  Sequential = "Sequential",
+  Parallel = "Parallel",
   Stackless = "Stackless",
 }
 
@@ -40,7 +40,7 @@ const _emptyHash = Hashable.string("fncts.Cause");
 /**
  * @tsplus companion fncts.Cause.EmptyOps
  */
-export class Empty {
+export class Empty implements Equatable {
   readonly [CauseTypeId]: CauseTypeId = CauseTypeId;
   declare [CauseVariance]: {
     readonly _E: (_: never) => never;
@@ -58,8 +58,8 @@ export class Empty {
     switch (that._tag) {
       case CauseTag.Empty:
         return Eval.now(true);
-      case CauseTag.Then:
-      case CauseTag.Both:
+      case CauseTag.Sequential:
+      case CauseTag.Parallel:
         return this.equalsEval(that.left).zipWith(this.equalsEval(that.right), (x, y) => x && y);
       case CauseTag.Stackless:
         return this.equalsEval(that.cause);
@@ -74,7 +74,7 @@ export const _Empty = new Empty();
 /**
  * @tsplus companion fncts.Cause.FailOps
  */
-export class Fail<E> {
+export class Fail<E> implements Equatable {
   readonly [CauseTypeId]: CauseTypeId = CauseTypeId;
   declare [CauseVariance]: {
     readonly _E: (_: never) => E;
@@ -97,8 +97,8 @@ export class Fail<E> {
       switch (that._tag) {
         case CauseTag.Fail:
           return P.Equatable.strictEquals(self.value, that.value);
-        case CauseTag.Both:
-        case CauseTag.Then:
+        case CauseTag.Parallel:
+        case CauseTag.Sequential:
           return yield* _(structuralSymmetric(structuralEqualEmpty)(self, that));
         case CauseTag.Stackless:
           return yield* _(self.equalsEval(that.cause));
@@ -112,7 +112,7 @@ export class Fail<E> {
 /**
  * @tsplus companion fncts.Cause.HaltOps
  */
-export class Halt {
+export class Halt implements Equatable {
   readonly [CauseTypeId]: CauseTypeId = CauseTypeId;
   declare [CauseVariance]: {
     readonly _E: (_: never) => never;
@@ -135,8 +135,8 @@ export class Halt {
       switch (that._tag) {
         case CauseTag.Halt:
           return P.Equatable.strictEquals(self.value, that.value);
-        case CauseTag.Then:
-        case CauseTag.Both:
+        case CauseTag.Sequential:
+        case CauseTag.Parallel:
           return yield* _(structuralSymmetric(structuralEqualEmpty)(self, that));
         case CauseTag.Stackless:
           return yield* _(self.equalsEval(that.cause));
@@ -150,7 +150,7 @@ export class Halt {
 /**
  * @tsplus companion fncts.Cause.InterruptOps
  */
-export class Interrupt {
+export class Interrupt implements Equatable {
   readonly [CauseTypeId]: CauseTypeId = CauseTypeId;
   declare [CauseVariance]: {
     readonly _E: (_: never) => never;
@@ -174,8 +174,8 @@ export class Interrupt {
       switch (that._tag) {
         case CauseTag.Interrupt:
           return P.Equatable.strictEquals(self.id, that.id);
-        case CauseTag.Then:
-        case CauseTag.Both:
+        case CauseTag.Sequential:
+        case CauseTag.Parallel:
           return yield* _(structuralSymmetric(structuralEqualEmpty)(self, that));
         case CauseTag.Stackless:
           return yield* _(self.equalsEval(that.cause));
@@ -187,14 +187,14 @@ export class Interrupt {
 }
 
 /**
- * @tsplus companion fncts.Cause.ThenOps
+ * @tsplus companion fncts.Cause.SequentialOps
  */
-export class Then<E> {
+export class Sequential<E> implements Equatable {
   readonly [CauseTypeId]: CauseTypeId = CauseTypeId;
   declare [CauseVariance]: {
     readonly _E: (_: never) => E;
   };
-  readonly _tag = CauseTag.Then;
+  readonly _tag = CauseTag.Sequential;
 
   constructor(readonly left: Cause<E>, readonly right: Cause<E>) {}
 
@@ -221,14 +221,14 @@ export class Then<E> {
 }
 
 /**
- * @tsplus companion fncts.Cause.BothOps
+ * @tsplus companion fncts.Cause.ParallelOps
  */
-export class Both<E> {
+export class Parallel<E> implements Equatable {
   readonly [CauseTypeId]: CauseTypeId = CauseTypeId;
   declare [CauseVariance]: {
     readonly _E: (_: never) => E;
   };
-  readonly _tag = CauseTag.Both;
+  readonly _tag = CauseTag.Parallel;
 
   constructor(readonly left: Cause<E>, readonly right: Cause<E>) {}
 
@@ -257,7 +257,7 @@ export class Both<E> {
 /**
  * @tsplus companion fncts.Cause.StacklessOps
  */
-export class Stackless<E> {
+export class Stackless<E> implements Equatable {
   readonly [CauseTypeId]: CauseTypeId = CauseTypeId;
   declare [CauseVariance]: {
     readonly _E: (_: never) => E;
@@ -296,7 +296,7 @@ function structuralSymmetric<A>(
 }
 
 function structuralEqualEmpty<A>(l: Cause<A>, r: Cause<A>): Eval<boolean> {
-  if (l._tag === CauseTag.Then || l._tag === CauseTag.Both) {
+  if (l._tag === CauseTag.Sequential || l._tag === CauseTag.Parallel) {
     if (l.left._tag === CauseTag.Empty) {
       return l.right.equalsEval(r);
     } else if (l.right._tag === CauseTag.Empty) {
@@ -311,10 +311,10 @@ function structuralEqualEmpty<A>(l: Cause<A>, r: Cause<A>): Eval<boolean> {
 
 function structuralThenAssociate<A>(l: Cause<A>, r: Cause<A>): Eval<boolean> {
   if (
-    l._tag === CauseTag.Then &&
-    l.left._tag === CauseTag.Then &&
-    r._tag === CauseTag.Then &&
-    r.right._tag === CauseTag.Then
+    l._tag === CauseTag.Sequential &&
+    l.left._tag === CauseTag.Sequential &&
+    r._tag === CauseTag.Sequential &&
+    r.right._tag === CauseTag.Sequential
   ) {
     return l.left.left
       .equalsEval(r.left)
@@ -327,11 +327,11 @@ function structuralThenAssociate<A>(l: Cause<A>, r: Cause<A>): Eval<boolean> {
 
 function strcturalThenDistribute<A>(l: Cause<A>, r: Cause<A>): Eval<boolean> {
   if (
-    l._tag === CauseTag.Then &&
-    l.right._tag === CauseTag.Both &&
-    r._tag === CauseTag.Both &&
-    r.right._tag === CauseTag.Then &&
-    r.left._tag === CauseTag.Then
+    l._tag === CauseTag.Sequential &&
+    l.right._tag === CauseTag.Parallel &&
+    r._tag === CauseTag.Parallel &&
+    r.right._tag === CauseTag.Sequential &&
+    r.left._tag === CauseTag.Sequential
   ) {
     return r.left.left
       .equalsEval(r.right.left)
@@ -339,11 +339,11 @@ function strcturalThenDistribute<A>(l: Cause<A>, r: Cause<A>): Eval<boolean> {
       .and(l.right.left.equalsEval(r.left.right))
       .and(l.right.right.equalsEval(r.right.right));
   } else if (
-    l._tag === CauseTag.Then &&
-    l.left._tag === CauseTag.Both &&
-    r._tag === CauseTag.Both &&
-    r.left._tag === CauseTag.Then &&
-    r.right._tag === CauseTag.Then
+    l._tag === CauseTag.Sequential &&
+    l.left._tag === CauseTag.Parallel &&
+    r._tag === CauseTag.Parallel &&
+    r.left._tag === CauseTag.Sequential &&
+    r.right._tag === CauseTag.Sequential
   ) {
     return r.left.right
       .equalsEval(r.right.right)
@@ -356,7 +356,7 @@ function strcturalThenDistribute<A>(l: Cause<A>, r: Cause<A>): Eval<boolean> {
 }
 
 function structuralEqualThen<A>(l: Cause<A>, r: Cause<A>): Eval<boolean> {
-  if (l._tag === CauseTag.Then && r._tag === CauseTag.Then) {
+  if (l._tag === CauseTag.Sequential && r._tag === CauseTag.Sequential) {
     return l.left.equalsEval(r.left).zipWith(l.right.equalsEval(r.right), (a, b) => a && b);
   } else {
     return Eval.now(false);
@@ -365,10 +365,10 @@ function structuralEqualThen<A>(l: Cause<A>, r: Cause<A>): Eval<boolean> {
 
 function structuralBothAssociate<A>(l: Cause<A>, r: Cause<A>): Eval<boolean> {
   if (
-    l._tag === CauseTag.Both &&
-    l.left._tag === CauseTag.Both &&
-    r._tag === CauseTag.Both &&
-    r.right._tag === CauseTag.Both
+    l._tag === CauseTag.Parallel &&
+    l.left._tag === CauseTag.Parallel &&
+    r._tag === CauseTag.Parallel &&
+    r.right._tag === CauseTag.Parallel
   ) {
     return l.left.left
       .equalsEval(r.left)
@@ -381,11 +381,11 @@ function structuralBothAssociate<A>(l: Cause<A>, r: Cause<A>): Eval<boolean> {
 
 function structuralBothDistribute<A>(l: Cause<A>, r: Cause<A>): Eval<boolean> {
   if (
-    l._tag === CauseTag.Both &&
-    l.left._tag === CauseTag.Then &&
-    l.right._tag === CauseTag.Then &&
-    r._tag === CauseTag.Then &&
-    r.right._tag === CauseTag.Both
+    l._tag === CauseTag.Parallel &&
+    l.left._tag === CauseTag.Sequential &&
+    l.right._tag === CauseTag.Sequential &&
+    r._tag === CauseTag.Sequential &&
+    r.right._tag === CauseTag.Parallel
   ) {
     return l.left.left
       .equalsEval(l.right.left)
@@ -393,11 +393,11 @@ function structuralBothDistribute<A>(l: Cause<A>, r: Cause<A>): Eval<boolean> {
       .and(l.left.right.equalsEval(r.right.left))
       .and(l.right.right.equalsEval(r.right.right));
   } else if (
-    l._tag === CauseTag.Both &&
-    l.left._tag === CauseTag.Then &&
-    l.right._tag === CauseTag.Then &&
-    r._tag === CauseTag.Then &&
-    r.left._tag === CauseTag.Both
+    l._tag === CauseTag.Parallel &&
+    l.left._tag === CauseTag.Sequential &&
+    l.right._tag === CauseTag.Sequential &&
+    r._tag === CauseTag.Sequential &&
+    r.left._tag === CauseTag.Parallel
   ) {
     return l.left.right
       .equalsEval(l.right.right)
@@ -410,7 +410,7 @@ function structuralBothDistribute<A>(l: Cause<A>, r: Cause<A>): Eval<boolean> {
 }
 
 function structuralEqualBoth<A>(l: Cause<A>, r: Cause<A>): Eval<boolean> {
-  if (l._tag === CauseTag.Both && r._tag === CauseTag.Both) {
+  if (l._tag === CauseTag.Parallel && r._tag === CauseTag.Parallel) {
     return l.left.equalsEval(r.left).zipWith(l.right.equalsEval(r.right), (a, b) => a && b);
   } else {
     return Eval.now(false);
@@ -442,7 +442,7 @@ function stepLoop<A>(
         }
         break;
       }
-      case CauseTag.Then: {
+      case CauseTag.Sequential: {
         const left  = cause.left;
         const right = cause.right;
         switch (left._tag) {
@@ -450,12 +450,12 @@ function stepLoop<A>(
             cause = right;
             break;
           }
-          case CauseTag.Then: {
-            cause = new Then(left.left, new Then(left.right, right));
+          case CauseTag.Sequential: {
+            cause = new Sequential(left.left, new Sequential(left.right, right));
             break;
           }
-          case CauseTag.Both: {
-            cause = new Both(new Then(left.left, right), new Then(left.right, right));
+          case CauseTag.Parallel: {
+            cause = new Parallel(new Sequential(left.left, right), new Sequential(left.right, right));
             break;
           }
           default: {
@@ -465,7 +465,7 @@ function stepLoop<A>(
         }
         break;
       }
-      case CauseTag.Both: {
+      case CauseTag.Parallel: {
         stack = stack.prepend(cause.right);
         cause = cause.left;
         break;

package/_src/data/Decoder/api.ts

@@ -682,5 +682,5 @@ export function deriveTuple<A extends ReadonlyArray<unknown>>(
  * @tsplus static fncts.DecoderOps tuple
  */
 export function tuple<A extends ReadonlyArray<unknown>>(...components: { [K in keyof A]: Decoder<A[K]> }): Decoder<A> {
-  return deriveTuple(components.unsafeCoerce()).unsafeCoerce();
+  return deriveTuple(components as [never]).unsafeCoerce()
 }

package/_src/data/Duration/api.ts

@@ -83,3 +83,13 @@ export function fromInterval(start: number, end: number): Duration {
  * @tsplus static fncts.DurationOps zero
  */
 export const zero: Duration = (0).milliseconds;
+
+/**
+ * @tsplus fluent fncts.Duration lessThanOrEqualTo
+ * @tsplus pipeable-operator fncts.Duration <=
+ */
+export function lessThanOrEqualTo(that: Duration) {
+  return (self: Duration): boolean => {
+    return self.milliseconds <= that.milliseconds;
+  };
+}

package/_src/data/Encoder/api.ts

@@ -371,5 +371,5 @@ export function deriveTuple<A extends ReadonlyArray<unknown>>(
  * @tsplus static fncts.EncoderOps tuple
  */
 export function tuple<A extends ReadonlyArray<unknown>>(...components: { [K in keyof A]: Encoder<A[K]> }): Encoder<A> {
-  return deriveTuple(components.unsafeCoerce()).unsafeCoerce();
+  return deriveTuple(components as [never]).unsafeCoerce()
 }

package/_src/data/Exit/api.ts

@@ -17,7 +17,7 @@ export function ap<E, A>(that: Exit<E, A>) {
  */
 export function zipLeft<G, B>(that: Exit<G, B>) {
   return <E, A>(self: Exit<E, A>): Exit<E | G, A> => {
-    return self.zipWithCause(that, (a, _) => a, Cause.then);
+    return self.zipWithCause(that, (a, _) => a, Cause.sequential);
   };
 }
 
@@ -26,7 +26,7 @@ export function zipLeft<G, B>(that: Exit<G, B>) {
  */
 export function zipRight<G, B>(that: Exit<G, B>) {
   return <E, A>(self: Exit<E, A>): Exit<E | G, B> => {
-    return self.zipWithCause(that, (_, b) => b, Cause.then);
+    return self.zipWithCause(that, (_, b) => b, Cause.sequential);
   };
 }
 
@@ -35,7 +35,7 @@ export function zipRight<G, B>(that: Exit<G, B>) {
  */
 export function zipLeftConcurrent<G, B>(that: Exit<G, B>) {
   return <E, A>(self: Exit<E, A>): Exit<E | G, A> => {
-    return self.zipWithCause(that, (a, _) => a, Cause.both);
+    return self.zipWithCause(that, (a, _) => a, Cause.parallel);
   };
 }
 
@@ -44,7 +44,7 @@ export function zipLeftConcurrent<G, B>(that: Exit<G, B>) {
  */
 export function zipRightConcurrent<G, B>(that: Exit<G, B>) {
   return <E, A>(self: Exit<E, A>): Exit<E | G, B> => {
-    return self.zipWithCause(that, (_, b) => b, Cause.both);
+    return self.zipWithCause(that, (_, b) => b, Cause.parallel);
   };
 }
 
@@ -71,7 +71,9 @@ export function bimap<E1, A, E2, B>(f: (e: E1) => E2, g: (a: A) => B) {
  */
 export function collectAll<E, A>(exits: Conc<Exit<E, A>>): Maybe<Exit<E, Conc<A>>> {
   return exits.head.map((head) =>
-    exits.drop(1).foldLeft(head.map(Conc.single), (acc, el) => acc.zipWithCause(el, (c, a) => c.append(a), Cause.then)),
+    exits
+      .drop(1)
+      .foldLeft(head.map(Conc.single), (acc, el) => acc.zipWithCause(el, (c, a) => c.append(a), Cause.sequential)),
   );
 }
 
@@ -80,7 +82,9 @@ export function collectAll<E, A>(exits: Conc<Exit<E, A>>): Maybe<Exit<E, Conc<A>
  */
 export function collectAllConcurrent<E, A>(exits: Conc<Exit<E, A>>): Maybe<Exit<E, Conc<A>>> {
   return exits.head.map((head) =>
-    exits.drop(1).foldLeft(head.map(Conc.single), (acc, el) => acc.zipWithCause(el, (c, a) => c.append(a), Cause.both)),
+    exits
+      .drop(1)
+      .foldLeft(head.map(Conc.single), (acc, el) => acc.zipWithCause(el, (c, a) => c.append(a), Cause.parallel)),
   );
 }
 
@@ -139,7 +143,7 @@ export function match<E, A, B, C>(onFailure: (e: Cause<E>) => B, onSuccess: (a:
  */
 export function zipWith<A, EB, B, C>(fb: Exit<EB, B>, f: (a: A, b: B) => C) {
   return <EA>(fa: Exit<EA, A>): Exit<EA | EB, C> => {
-    return fa.zipWithCause(fb, f, Cause.then);
+    return fa.zipWithCause(fb, f, Cause.sequential);
   };
 }
 
@@ -157,7 +161,7 @@ export function zip<EB, B>(that: Exit<EB, B>) {
  */
 export function zipWithConcurrent<A, EB, B, C>(fb: Exit<EB, B>, f: (a: A, b: B) => C) {
   return <EA>(fa: Exit<EA, A>): Exit<EA | EB, C> => {
-    return fa.zipWithCause(fb, f, Cause.both);
+    return fa.zipWithCause(fb, f, Cause.parallel);
   };
 }
 

package/_src/data/Guard/api.ts

@@ -453,5 +453,5 @@ export function deriveTuple<A extends ReadonlyArray<unknown>>(
  * @tsplus static fncts.GuardOps tuple
  */
 export function tuple<A extends ReadonlyArray<unknown>>(...components: { [K in keyof A]: Guard<A[K]> }): Guard<A> {
-  return deriveTuple(components.unsafeCoerce()).unsafeCoerce();
+  return deriveTuple(components as [never]).unsafeCoerce();
 }

package/data/Cause/api.d.ts

@@ -7,7 +7,7 @@ import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
 import { FiberId } from "@fncts/base/data/FiberId/definition";
 import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
-import { Both, Cause, Fail, Halt, Interrupt, Then } from "./definition.js";
+import { Cause, Fail, Halt, Interrupt, Parallel, Sequential } from "./definition.js";
 /**
  * @tsplus pipeable fncts.Cause as
  * @tsplus location "@fncts/base/data/Cause/api"
@@ -16,11 +16,11 @@ export declare function as<B>(b: Lazy<B>): <A>(self: Cause<A>) => Cause<B>;
 /**
  * Constructs a `Cause` from two `Cause`s, representing parallel failures.
  * @note If one of the `Cause`s is `Empty`, the non-empty `Cause` is returned
- * @tsplus static fncts.CauseOps both
- * @tsplus static fncts.Cause.BothOps __call
+ * @tsplus static fncts.CauseOps parallel
+ * @tsplus static fncts.Cause.ParallelOps __call
  * @tsplus location "@fncts/base/data/Cause/api"
  */
-export declare function both<E, E1>(left: Cause<E>, right: Cause<E1>): Cause<E | E1>;
+export declare function parallel<E, E1>(left: Cause<E>, right: Cause<E1>): Cause<E | E1>;
 /**
  * Composes computations in sequence, using the return value of one computation as input for the next
  * @tsplus pipeable fncts.Cause flatMap
@@ -164,7 +164,7 @@ export declare function interrupt(id: FiberId, trace?: Trace): Cause<never>;
  * @tsplus fluent fncts.Cause isBoth
  * @tsplus location "@fncts/base/data/Cause/api"
  */
-export declare function isBoth<E>(self: Cause<E>): self is Both<E>;
+export declare function isBoth<E>(self: Cause<E>): self is Parallel<E>;
 /**
  * A type-guard matching `Fail`
  * @tsplus fluent fncts.Cause isFail
@@ -181,7 +181,7 @@ export declare function isHalt<E>(self: Cause<E>): self is Halt;
  * @tsplus fluent fncts.Cause isThen
  * @tsplus location "@fncts/base/data/Cause/api"
  */
-export declare function isThen<E>(self: Cause<E>): self is Then<E>;
+export declare function isThen<E>(self: Cause<E>): self is Sequential<E>;
 /**
  * A type-guard matching `Interrupt`
  * @tsplus fluent fncts.Cause isInterrupt
@@ -297,11 +297,11 @@ export declare function squashWith<E>(f: (e: E) => unknown): (self: Cause<E>) =>
 /**
  * Constructs a `Cause` from two `Cause`s, representing sequential failures.
  * @note If one of the `Cause`s is `Empty`, the non-empty `Cause` is returned
- * @tsplus static fncts.CauseOps then
- * @tsplus static fncts.Cause.ThenOps __call
+ * @tsplus static fncts.CauseOps sequential
+ * @tsplus static fncts.Cause.SequentialOps __call
  * @tsplus location "@fncts/base/data/Cause/api"
  */
-export declare function then<E, E1>(left: Cause<E>, right: Cause<E1>): Cause<E | E1>;
+export declare function sequential<E, E1>(left: Cause<E>, right: Cause<E1>): Cause<E | E1>;
 /**
  * Constructs a `Cause` from a `Cause` and a stack trace.
  * @note If the stack trace is empty, the original `Cause` is returned.

package/data/Cause/definition.d.ts

@@ -1,3 +1,4 @@
+import { Equatable } from "@fncts/base/data/Equatable";
 import { Eval } from "@fncts/base/control/Eval/definition";
 import { Trace } from "@fncts/base/data/Trace/definition";
 import { FiberId } from "@fncts/base/data/FiberId/definition";
@@ -11,7 +12,7 @@ export type CauseTypeId = typeof CauseTypeId;
 /**
  * @tsplus type fncts.Cause
  */
-export type Cause<E> = Empty | Halt | Interrupt | Fail<E> | Then<E> | Both<E> | Stackless<E>;
+export type Cause<E> = Empty | Halt | Interrupt | Fail<E> | Sequential<E> | Parallel<E> | Stackless<E>;
 /**
  * @tsplus type fncts.CauseOps
  */
@@ -24,14 +25,14 @@ export declare const enum CauseTag {
     Fail = "Fail",
     Halt = "Halt",
     Interrupt = "Interrupt",
-    Then = "Then",
-    Both = "Both",
+    Sequential = "Sequential",
+    Parallel = "Parallel",
     Stackless = "Stackless"
 }
 /**
  * @tsplus companion fncts.Cause.EmptyOps
  */
-export declare class Empty {
+export declare class Empty implements Equatable {
     readonly [CauseTypeId]: CauseTypeId;
     [CauseVariance]: {
         readonly _E: (_: never) => never;
@@ -45,7 +46,7 @@ export declare const _Empty: Empty;
 /**
  * @tsplus companion fncts.Cause.FailOps
  */
-export declare class Fail<E> {
+export declare class Fail<E> implements Equatable {
     readonly value: E;
     readonly trace: Trace;
     readonly [CauseTypeId]: CauseTypeId;
@@ -61,7 +62,7 @@ export declare class Fail<E> {
 /**
  * @tsplus companion fncts.Cause.HaltOps
  */
-export declare class Halt {
+export declare class Halt implements Equatable {
     readonly value: unknown;
     readonly trace: Trace;
     readonly [CauseTypeId]: CauseTypeId;
@@ -77,7 +78,7 @@ export declare class Halt {
 /**
  * @tsplus companion fncts.Cause.InterruptOps
  */
-export declare class Interrupt {
+export declare class Interrupt implements Equatable {
     readonly id: FiberId;
     readonly trace: Trace;
     readonly [CauseTypeId]: CauseTypeId;
@@ -91,32 +92,32 @@ export declare class Interrupt {
     equalsEval(that: Cause<unknown>): Eval<boolean>;
 }
 /**
- * @tsplus companion fncts.Cause.ThenOps
+ * @tsplus companion fncts.Cause.SequentialOps
  */
-export declare class Then<E> {
+export declare class Sequential<E> implements Equatable {
     readonly left: Cause<E>;
     readonly right: Cause<E>;
     readonly [CauseTypeId]: CauseTypeId;
     [CauseVariance]: {
         readonly _E: (_: never) => E;
     };
-    readonly _tag = CauseTag.Then;
+    readonly _tag = CauseTag.Sequential;
     constructor(left: Cause<E>, right: Cause<E>);
     get [Symbol.hash](): number;
     [Symbol.equals](that: unknown): boolean;
     equalsEval(that: Cause<unknown>): Eval<boolean>;
 }
 /**
- * @tsplus companion fncts.Cause.BothOps
+ * @tsplus companion fncts.Cause.ParallelOps
  */
-export declare class Both<E> {
+export declare class Parallel<E> implements Equatable {
     readonly left: Cause<E>;
     readonly right: Cause<E>;
     readonly [CauseTypeId]: CauseTypeId;
     [CauseVariance]: {
         readonly _E: (_: never) => E;
     };
-    readonly _tag = CauseTag.Both;
+    readonly _tag = CauseTag.Parallel;
     constructor(left: Cause<E>, right: Cause<E>);
     get [Symbol.hash](): number;
     [Symbol.equals](that: unknown): boolean;
@@ -125,7 +126,7 @@ export declare class Both<E> {
 /**
  * @tsplus companion fncts.Cause.StacklessOps
  */
-export declare class Stackless<E> {
+export declare class Stackless<E> implements Equatable {
     readonly cause: Cause<E>;
     readonly stackless: boolean;
     readonly [CauseTypeId]: CauseTypeId;

package/data/Duration/api.d.ts

@@ -59,3 +59,9 @@ export declare function fromInterval(start: number, end: number): Duration;
  * @tsplus location "@fncts/base/data/Duration/api"
  */
 export declare const zero: Duration;
+/**
+ * @tsplus fluent fncts.Duration lessThanOrEqualTo
+ * @tsplus pipeable-operator fncts.Duration <=
+ * @tsplus location "@fncts/base/data/Duration/api"
+ */
+export declare function lessThanOrEqualTo(that: Duration): (self: Duration) => boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fncts/base",
-  "version": "0.0.28",
+  "version": "0.0.29",
   "dependencies": {
     "@fncts/typelevel": "0.0.15",
     "uuid": "^9.0.0"