@fncts/base 0.0.27 → 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/Either/constructors.ts

@@ -6,16 +6,16 @@ import { Either, Left, Right } from "./definition.js";
  * @tsplus static fncts.EitherOps left
  * @tsplus static fncts.Either.LeftOps __call
  */
-export function left<E = never, A = never>(e: E): Either<E, A> {
-  return new Left(e);
+export function left<E = never, A = never>(e: E, __tsplusTrace?: string): Either<E, A> {
+  return new Left(e, __tsplusTrace);
 }
 
 /**
  * @tsplus static fncts.EitherOps right
  * @tsplus static fncts.Either.RightOps __call
  */
-export function right<E = never, A = never>(a: A): Either<E, A> {
-  return new Right(a);
+export function right<E = never, A = never>(a: A, __tsplusTrace?: string): Either<E, A> {
+  return new Right(a, __tsplusTrace);
 }
 
 /**

package/_src/data/Either/definition.ts

@@ -1,3 +1,5 @@
+import type { EqualsContext } from "@fncts/base/data/Equatable";
+
 export const enum EitherTag {
   Left = "Left",
   Right = "Right",
@@ -17,12 +19,17 @@ export interface EitherF extends HKT {
   };
 }
 
+const IOTypeId = Symbol.for("fncts.io.IO");
+type IOTypeId = typeof IOTypeId;
+
 /**
  * @tsplus type fncts.Either
  * @tsplus companion fncts.EitherOps
  */
 export class Either<E, A> {
   readonly [EitherTypeId]: EitherTypeId = EitherTypeId;
+  readonly [IOTypeId]: IOTypeId         = IOTypeId;
+  readonly trace?: string | undefined   = undefined;
   declare [EitherVariance]: {
     readonly _E: (_: never) => E;
     readonly _A: (_: never) => A;
@@ -37,7 +44,7 @@ const leftHash = Hashable.string(EitherTag.Left);
  */
 export class Left<E> extends Either<E, never> {
   readonly _tag = EitherTag.Left;
-  constructor(readonly left: E) {
+  constructor(readonly left: E, readonly trace?: string) {
     super();
   }
 
@@ -45,8 +52,8 @@ export class Left<E> extends Either<E, never> {
     return Hashable.combine(leftHash, Hashable.unknown(this.left));
   }
 
-  [Symbol.equals](that: unknown): boolean {
-    return Either.isEither(that) && that.isLeft() && Equatable.strictEquals(this.left, that.left);
+  [Symbol.equals](that: unknown, context: EqualsContext): boolean {
+    return Either.isEither(that) && that.isLeft() && context.comparator(this.left, that.left);
   }
 }
 
@@ -58,7 +65,7 @@ const rightHash = Hashable.string(EitherTag.Right);
  */
 export class Right<A> extends Either<never, A> {
   readonly _tag = EitherTag.Right;
-  constructor(readonly right: A) {
+  constructor(readonly right: A, readonly trace?: string) {
     super();
   }
 
@@ -66,8 +73,8 @@ export class Right<A> extends Either<never, A> {
     return Hashable.combine(rightHash, Hashable.unknown(this.left));
   }
 
-  [Symbol.equals](that: unknown): boolean {
-    return Either.isEither(that) && that.isRight() && Equatable.strictEquals(this.right, that.right);
+  [Symbol.equals](that: unknown, context: EqualsContext): boolean {
+    return Either.isEither(that) && that.isRight() && context.comparator(this.right, that.right);
   }
 }
 

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/Eq/api.ts

@@ -0,0 +1,8 @@
+/**
+ * @tsplus pipeable fncts.Eq contramap
+ */
+export function contramap<A, B>(f: (b: B) => A) {
+  return (self: Eq<A>): Eq<B> => {
+    return Eq({ equals: (b2) => (b1) => self.equals(f(b2))(f(b1)) });
+  };
+}

package/_src/data/Eq.ts

@@ -1,2 +1,3 @@
+export * from "./Eq/api.js";
 export * from "./Eq/definition.js";
 export {} from "./Eq/derivations.js";

package/_src/data/Equatable/api.ts

@@ -1,3 +1,5 @@
+import type { EqualsContext } from "@fncts/base/data/Equatable/definition";
+
 import { isEquatable } from "@fncts/base/data/Equatable/definition";
 import {
   createCircularEqualCreator,
@@ -5,30 +7,45 @@ import {
   sameValueZeroEqual,
 } from "@fncts/base/data/Equatable/fast-equals";
 
-/**
- * @tsplus static fncts.EquatableOps deepEquals
- */
-export const deepEquals = createComparator(
+const deepEqualsComparator = createComparator(
   createCircularEqualCreator((eq) => (a, b, meta) => {
+    const equalsContext: EqualsContext = { comparator: deepEquals };
     if (isEquatable(a)) {
-      return a[Symbol.equals](b);
+      return a[Symbol.equals](b, equalsContext);
     } else if (isEquatable(b)) {
-      return b[Symbol.equals](a);
+      return b[Symbol.equals](a, equalsContext);
     } else {
       return eq(a, b, meta);
     }
   }),
 );
 
+/**
+ * @tsplus static fncts.EquatableOps deepEquals
+ */
+export function deepEquals<A>(a: A, b: unknown): boolean {
+  const context: EqualsContext = { comparator: deepEquals };
+  if (isEquatable(a)) {
+    return a[Symbol.equals](b, context);
+  } else if (isEquatable(b)) {
+    return b[Symbol.equals](a, context);
+  } else {
+    return deepEqualsComparator(a, b);
+  }
+}
+
 /**
  * @tsplus static fncts.EquatableOps strictEquals
  * @tsplus operator fncts.Equatable ==
  */
 export function strictEquals<A>(a: A, b: unknown): boolean {
+  const context: EqualsContext = {
+    comparator: strictEquals,
+  };
   if (isEquatable(a)) {
-    return a[Symbol.equals](b);
+    return a[Symbol.equals](b, context);
   } else if (isEquatable(b)) {
-    return b[Symbol.equals](a);
+    return b[Symbol.equals](a, context);
   }
   return sameValueZeroEqual(a, b);
 }
@@ -38,5 +55,5 @@ export function strictEquals<A>(a: A, b: unknown): boolean {
  * @tsplus operator fncts.Equatable !=
  */
 export function strictNotEquals<A>(a: A, b: unknown): boolean {
-  return !strictEquals(a, b)
-}
+  return !strictEquals(a, b);
+}

package/_src/data/Equatable/definition.ts

@@ -3,15 +3,19 @@
  */
 export const equalsSymbol: unique symbol = Symbol.for("fncts.Equatable");
 
+export interface EqualsContext {
+  comparator: (a: unknown, b: unknown) => boolean;
+}
+
 /**
  * @tsplus type fncts.Equatable
  */
 export interface Equatable {
-  [equalsSymbol](that: unknown): boolean;
+  [equalsSymbol](that: unknown, context: EqualsContext): boolean;
 }
 
 export function isEquatable(u: unknown): u is Equatable {
-  return isObject(u) && Symbol.equals in u;
+  return isObject(u) && typeof u[Symbol.equals] === "function";
 }
 
 /**

package/_src/data/Exit/api.ts

@@ -1,3 +1,5 @@
+import { IOError } from "@fncts/base/data/exceptions";
+
 import { identity, tuple } from "../function.js";
 import { ExitTag } from "./definition.js";
 
@@ -15,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);
   };
 }
 
@@ -24,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);
   };
 }
 
@@ -33,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);
   };
 }
 
@@ -42,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);
   };
 }
 
@@ -69,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)),
   );
 }
 
@@ -78,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)),
   );
 }
 
@@ -137,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);
   };
 }
 
@@ -155,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);
   };
 }
 
@@ -201,3 +207,27 @@ export function zipWithCause<E, A, G, B, C>(
     }
   };
 }
+
+/**
+ * Returns the Exit's Success value if it exists
+ *
+ * @tsplus getter fncts.Exit value
+ */
+export function value<E, A>(self: Exit<E, A>): A | undefined {
+  if (self.isFailure()) {
+    return undefined;
+  }
+  return self.value;
+}
+
+/**
+ * Returns the Exit's Success value if it exists, or throws the pretty-printed Cause if it doesn't
+ *
+ * @tsplus getter fncts.Exit valueOrThrow
+ */
+export function valueOrThrow<E, A>(self: Exit<E, A>): A {
+  if (self.isFailure()) {
+    throw new IOError(self.cause);
+  }
+  return self.value;
+}

package/_src/data/Exit/constructors.ts

@@ -3,14 +3,14 @@ import { Failure, Success } from "./definition.js";
 /**
  * @tsplus static fncts.ExitOps halt
  */
-export function halt(defect: unknown): Exit<never, never> {
+export function halt(defect: unknown, __tsplusTrace?: string): Exit<never, never> {
   return failCause(Cause.halt(defect));
 }
 
 /**
  * @tsplus static fncts.ExitOps fail
  */
-export function fail<E = never, A = never>(e: E): Exit<E, A> {
+export function fail<E = never, A = never>(e: E, __tsplusTrace?: string): Exit<E, A> {
   return failCause(Cause.fail(e));
 }
 
@@ -31,22 +31,22 @@ export function fromMaybe<E, A>(fa: Maybe<A>, onNothing: () => E): Exit<E, A> {
 /**
  * @tsplus static fncts.ExitOps failCause
  */
-export function failCause<E = never, A = never>(cause: Cause<E>): Exit<E, A> {
-  return new Failure(cause);
+export function failCause<E = never, A = never>(cause: Cause<E>, __tsplusTrace?: string): Exit<E, A> {
+  return new Failure(cause, __tsplusTrace);
 }
 
 /**
  * @tsplus static fncts.ExitOps interrupt
  */
-export function interrupt(id: FiberId): Exit<never, never> {
+export function interrupt(id: FiberId, __tsplusTrace?: string): Exit<never, never> {
   return failCause(Cause.interrupt(id));
 }
 
 /**
  * @tsplus static fncts.ExitOps succeed
  */
-export function succeed<E = never, A = never>(value: A): Exit<E, A> {
-  return new Success(value);
+export function succeed<E = never, A = never>(value: A, __tsplusTrace?: string): Exit<E, A> {
+  return new Success(value, __tsplusTrace);
 }
 
 /**