@fncts/base 0.0.1 → 0.0.4

package/_src/collection/immutable/Vector/api.ts

@@ -1,6 +1,6 @@
 /* eslint-disable prefer-const */
-import type { MutableVector } from "@fncts/base/collection/immutable/Vector/definition";
-import type { Eq, Monoid, Ord, Ordering } from "@fncts/base/typeclass";
+import type { MutableVector, VectorF } from "@fncts/base/collection/immutable/Vector/definition";
+import type { Eq, Monoid, Ord, Ordering, Traversable, TraversableWithIndex } from "@fncts/base/typeclass";
 
 import {
   affixPush,
@@ -36,6 +36,7 @@ import {
   nodeNth,
   nodeNthDense,
   prependNodeToTree,
+  push,
   reverseArray,
   setDepth,
   setPrefix,
@@ -54,6 +55,7 @@ import {
  * @complexity O(n)
  *
  * @tsplus fluent fncts.Vector append
+ * @tsplus operator fncts.Vector +
  */
 export function append_<A>(as: Vector<A>, a: A): Vector<A> {
   const suffixSize = getSuffixSize(as);
@@ -111,6 +113,7 @@ export function chunksOf_<A>(as: Vector<A>, size: number): Vector<Vector<A>> {
  *
  * @complexity O(log(n))
  * @tsplus fluent fncts.Vector concat
+ * @tsplus operator fncts.Vector + 1
  */
 export function concat_<A, B>(self: Vector<A>, that: Vector<B>): Vector<A | B>;
 export function concat_<A>(self: Vector<A>, that: Vector<A>): Vector<A> {
@@ -267,7 +270,7 @@ function elemCb(value: any, state: ElemState): boolean {
  */
 export function elem_<A>(self: Vector<A>) {
   return (E: Eq<A>) => {
-    const elemState: ElemState = { equals: E.equals_, element: undefined, result: false };
+    const elemState: ElemState = { equals: E.equals, element: undefined, result: false };
     return (a: A): boolean => {
       elemState.element = a;
       return foldLeftCb(elemCb, elemState, self).result;
@@ -506,21 +509,21 @@ export function foldRightWhile_<A, B>(fa: Vector<A>, b: B, cont: Predicate<B>, f
 }
 
 /**
- * @tsplus getter fncts.Vector foldMap
+ * @tsplus fluent fncts.Vector foldMap
  */
-export function foldMap_<A>(self: Vector<A>) {
-  return <M>(M: Monoid<M>) =>
-    (f: (a: A) => M): M =>
-      self.foldMapWithIndex(M)((_, a) => f(a));
+export function foldMap_<A, M>(self: Vector<A>, f: (a: A) => M, /** @tsplus auto */ M: Monoid<M>): M {
+  return self.foldMapWithIndex((_, a) => f(a), M);
 }
 
 /**
- * @tsplus getter fncts.Vector foldMapWithIndex
+ * @tsplus fluent fncts.Vector foldMapWithIndex
  */
-export function foldMapWithIndex_<A>(self: Vector<A>) {
-  return <M>(M: Monoid<M>) =>
-    (f: (i: number, a: A) => M): M =>
-      self.foldLeftWithIndex(M.nat, (i, b, a) => M.combine_(b, f(i, a)));
+export function foldMapWithIndex_<A, M>(
+  self: Vector<A>,
+  f: (i: number, a: A) => M,
+  /** @tsplus auto */ M: Monoid<M>,
+): M {
+  return self.foldLeftWithIndex(M.nat, (i, b, a) => M.combine(b, f(i, a)));
 }
 
 /**
@@ -857,6 +860,13 @@ export function prepend_<A>(as: Vector<A>, a: A): Vector<A> {
   }
 }
 
+/**
+ * @tsplus operator fncts.Vector +
+ */
+export function prependOperator<A>(a: A, as: Vector<A>): Vector<A> {
+  return as.prepend(a);
+}
+
 /**
  * Returns a Vector of numbers between an inclusive lower bound and an exclusive upper bound.
  *
@@ -900,6 +910,13 @@ export function replicate<A>(n: number, a: A): Vector<A> {
   return l;
 }
 
+/**
+ * @tsplus getter fncts.Vector reverse
+ */
+export function reverse<A>(self: Vector<A>): Vector<A> {
+  return self.foldLeft(Vector.empty(), (vec, elem) => vec.prepend(elem));
+}
+
 /**
  * Folds a function over a Vector from left to right while collecting
  * all the intermediate steps in a resulting Vector.
@@ -1039,10 +1056,10 @@ export function slice_<A>(as: Vector<A>, from: number, to: number): Vector<A> {
 }
 
 /**
- * @tsplus getter fncts.Vector sort
+ * @tsplus fluent fncts.Vector sort
  */
-export function sort_<A>(self: Vector<A>) {
-  return (O: Ord<A>): Vector<A> => self.sortWith(O.compare_);
+export function sort_<A>(self: Vector<A>, /** @tsplus auto */ O: Ord<A>): Vector<A> {
+  return self.sortWith(O.compare);
 }
 
 /**
@@ -1183,6 +1200,29 @@ export function toList<A>(self: Vector<A>): List<A> {
   return buffer.toList;
 }
 
+/**
+ * @tsplus fluent fncts.Vector traverseWithIndex
+ */
+export const traverseWithIndex: TraversableWithIndex<VectorF>["traverseWithIndex"] = (self, f, G) => {
+  return self.foldLeftWithIndex(G.pure(Vector.emptyPushable()), (i, b, a) =>
+    b.zipWith(
+      f(i, a),
+      (v, b) => {
+        push(v, b);
+        return v;
+      },
+      G,
+    ),
+  );
+};
+
+/**
+ * @tsplus fluent fncts.Vector traverse
+ */
+export const traverse: Traversable<VectorF>["traverse"] = (self, f, G) => {
+  return self.traverseWithIndex((_, a) => f(a));
+};
+
 /**
  * Returns a new Vector without repeated elements by using the given
  * Eq instance to determine when elements are equal
@@ -1191,7 +1231,7 @@ export function toList<A>(self: Vector<A>): List<A> {
  * @tsplus getter fncts.Vector uniq
  */
 export function uniq<A>(as: Vector<A>) {
-  return (E: Eq<A>) => as.dropRepeatsWith(E.equals_);
+  return (E: Eq<A>) => as.dropRepeatsWith(E.equals);
 }
 
 /**

package/_src/collection/immutable/Vector/definition.ts

@@ -8,6 +8,8 @@ import { ForwardVectorIterator } from "@fncts/base/collection/immutable/Vector/i
 export const VectorTypeId = Symbol.for("fncts.Vector");
 export type VectorTypeId = typeof VectorTypeId;
 
+export interface VectorF extends Vector<any> {}
+
 /**
  * Represents a Vector of elements.
  *
@@ -16,6 +18,10 @@ export type VectorTypeId = typeof VectorTypeId;
  */
 export class Vector<A> implements Iterable<A> {
   readonly _typeId: VectorTypeId = VectorTypeId;
+  readonly [HKT.F]!: VectorF;
+  readonly [HKT.A]!: () => A;
+  readonly [HKT.T]!: Vector<HKT._A<this>>;
+  readonly [HKT.Ix]!: number
   constructor(
     /** @private */
     readonly bits: number,
@@ -48,6 +54,10 @@ export class Vector<A> implements Iterable<A> {
  */
 export interface MutableVector<A> {
   readonly _typeId: VectorTypeId;
+  readonly [HKT.F]: VectorF;
+  readonly [HKT.A]: () => A;
+  readonly [HKT.T]: Vector<HKT._A<this>>;
+  readonly [HKT.Ix]: number
   bits: number;
   offset: number;
   length: number;

package/_src/collection/mutable/HashMap.ts

@@ -80,7 +80,7 @@ export class HashMap<K, V> implements Iterable<readonly [K, V]> {
       let prev: Node<K, V> | undefined = undefined;
       let nd: Node<K, V> | undefined   = n;
       while (nd) {
-        if (hash === nd.hash && this.config.equals_(key, nd.key)) {
+        if (hash === nd.hash && this.config.equals(key, nd.key)) {
           previousNode = prev;
           foundNode    = nd;
           break;
@@ -158,7 +158,7 @@ export class HashMap<K, V> implements Iterable<readonly [K, V]> {
       const old = n;
       let prev: Node<K, V> | undefined = undefined;
       while (n !== undefined && n.hash <= hash) {
-        if (n.hash === hash && this.config.equals_(key, n.key)) {
+        if (n.hash === hash && this.config.equals(key, n.key)) {
           const old = n.value;
           n.value   = value;
           if (getOld) return Just(old);
@@ -186,7 +186,7 @@ export class HashMap<K, V> implements Iterable<readonly [K, V]> {
     const nd  = this.table[idx];
     if (nd === undefined) {
       return undefined;
-    } else if (nd.hash === hash && this.config.equals_(nd.key, key)) {
+    } else if (nd.hash === hash && this.config.equals(nd.key, key)) {
       this.table[idx]   = nd.next;
       this.contentSize -= 1;
       return nd;
@@ -194,7 +194,7 @@ export class HashMap<K, V> implements Iterable<readonly [K, V]> {
       let prev = nd;
       let next = nd.next;
       while (next && next.hash <= hash) {
-        if (next.hash === hash && this.config.equals_(next.key, key)) {
+        if (next.hash === hash && this.config.equals(next.key, key)) {
           prev.next         = next.next;
           this.contentSize -= 1;
           return next;
@@ -221,7 +221,7 @@ export class HashMap<K, V> implements Iterable<readonly [K, V]> {
   private findNode(key: K): Node<K, V> | undefined {
     const hash = this.computeHash(key);
     const n    = this.table[this.index(hash)];
-    return n === undefined ? n : n.findNode(key, hash, this.config.equals_);
+    return n === undefined ? n : n.findNode(key, hash, this.config.equals);
   }
 
   private growTable(newLen: number) {

package/_src/collection/mutable/HashSet.ts

@@ -81,7 +81,7 @@ export class HashSet<A> implements Iterable<A> {
       const old                     = n;
       let prev: Node<A> | undefined = undefined;
       while (n !== undefined && n.hash <= hash) {
-        if (n.hash === hash && this.config.equals_(elem, n.key)) {
+        if (n.hash === hash && this.config.equals(elem, n.key)) {
           return false;
         }
         prev = n;
@@ -102,7 +102,7 @@ export class HashSet<A> implements Iterable<A> {
     const n   = this.table[idx];
     if (n === undefined) {
       return false;
-    } else if (n.hash === hash && this.config.equals_(n.key, elem)) {
+    } else if (n.hash === hash && this.config.equals(n.key, elem)) {
       this.table[idx]   = n.next;
       this.contentSize -= 1;
       return true;
@@ -110,7 +110,7 @@ export class HashSet<A> implements Iterable<A> {
       let prev = n;
       let next = n.next;
       while (next && next.hash <= hash) {
-        if (next.hash === hash && this.config.equals_(next.key, elem)) {
+        if (next.hash === hash && this.config.equals(next.key, elem)) {
           prev.next         = next.next;
           this.contentSize -= 1;
           return true;
@@ -137,7 +137,7 @@ export class HashSet<A> implements Iterable<A> {
   private findNode(key: A): Node<A> | undefined {
     const hash = this.computeHash(key);
     const n    = this.table[this.index(hash)];
-    return n === undefined ? n : n.findNode(key, hash, this.config.equals_);
+    return n === undefined ? n : n.findNode(key, hash, this.config.equals);
   }
 
   private growTable(newLen: number) {

package/_src/control/Eval/api.ts

@@ -1,7 +1,7 @@
 import type { _A } from "@fncts/base/types";
 
 import { Chain } from "@fncts/base/control/Eval/definition";
-import { identity } from "@fncts/base/data/function";
+import { identity, tuple } from "@fncts/base/data/function";
 
 /**
  * @tsplus fluent fncts.control.Eval and
@@ -38,6 +38,10 @@ export function zipWith_<A, B, C>(self: Eval<A>, fb: Eval<B>, f: (a: A, b: B) =>
   return self.flatMap((a) => fb.map((b) => f(a, b)));
 }
 
+export function zip_<A, B>(self: Eval<A>, fb: Eval<B>): Eval<readonly [A, B]> {
+  return self.zipWith(fb, tuple);
+}
+
 /**
  * @tsplus fluent fncts.control.Eval ap
  */

package/_src/control/Eval/definition.ts

@@ -1,12 +1,16 @@
 export const EvalTypeId = Symbol.for("@fncts.base/control/Eval");
 export type EvalTypeId = typeof EvalTypeId;
 
+export interface EvalF extends Eval<any> {}
+
 /**
  * @tsplus type fncts.control.Eval
  */
 export interface Eval<A> {
   readonly _typeId: EvalTypeId;
-  readonly _A: () => A;
+  [HKT.F]?: EvalF;
+  [HKT.A]?: () => A;
+  [HKT.T]?: Eval<HKT._A<this>>;
 }
 
 /**
@@ -58,10 +62,3 @@ export function concrete(_: Eval<any>): asserts _ is Concrete {
 export function unifyEval<X extends Eval<any>>(self: X): Eval<[X] extends [Eval<infer A>] ? A : never> {
   return self;
 }
-
-export interface EvalF extends HKT {
-  readonly type: Eval<this["A"]>;
-  readonly variance: {
-    readonly A: "-";
-  };
-}

package/_src/control/Eval/instance.ts

@@ -1,31 +1,32 @@
 import type { EvalF } from "@fncts/base/control/Eval/definition";
+import type * as P from "@fncts/base/typeclass";
 
-import { ap_, map_, zipWith_ } from "@fncts/base/control/Eval/api";
+import { ap_, map_, zip_, zipWith_ } from "@fncts/base/control/Eval/api";
 import { now } from "@fncts/base/control/Eval/constructors";
-import * as P from "@fncts/base/typeclass";
 
 /**
  * @tsplus static fncts.control.EvalOps Functor
+ * @tsplus implicit
  */
-export const Functor: P.Functor<EvalF> = P.Functor({
-  map_,
-});
+export const Functor: P.Functor<EvalF> = {
+  map: map_,
+};
 
 /**
  * @tsplus static fncts.control.EvalOps Apply
+ * @tsplus implicit
  */
-export const Apply: P.Apply<EvalF> = P.Apply({
-  map_,
-  ap_,
-  zipWith_,
-});
+export const Apply: P.Apply<EvalF> = {
+  map: map_,
+  zip: zip_,
+  zipWith: zipWith_,
+};
 
 /**
  * @tsplus static fncts.control.EvalOps Applicative
+ * @tsplus implicit
  */
-export const Applicative: P.Applicative<EvalF> = P.Applicative({
-  map_,
-  ap_,
-  zipWith_,
+export const Applicative: P.Applicative<EvalF> = {
+  ...Apply,
   pure: now,
-});
+};

package/_src/control/Z/definition.ts

@@ -1,17 +1,8 @@
-import type { _A, _E, _R, _S1, _S2, _W } from "../../types.js";
-
 import { hasTypeId } from "../../util/predicates.js";
 
-export interface ZF extends HKT {
-  readonly type: Z<this["W"], this["S"], this["S"], this["R"], this["E"], this["A"]>;
-  readonly variance: {
-    readonly W: "_";
-    readonly S: "_";
-    readonly R: "-";
-    readonly E: "+";
-    readonly A: "+";
-  };
-}
+export interface ZF extends Z<any, any, any, any, any, any> {}
+
+export interface ZFixedF extends ZFixed<any, any, any, any, any> {}
 
 export const ZTypeId = Symbol.for("@principia/base/Z");
 export type ZTypeId = typeof ZTypeId;
@@ -31,18 +22,34 @@ export type ZTypeId = typeof ZTypeId;
  */
 export abstract class Z<W, S1, S2, R, E, A> {
   readonly _typeId: ZTypeId = ZTypeId;
-  readonly _W!: () => W;
-  readonly _S1!: (_: S1) => void;
-  readonly _S2!: () => S2;
-  readonly _R!: (_: R) => void;
-  readonly _E!: () => E;
-  readonly _A!: () => A;
+  readonly [HKT.F]!: ZF;
+  readonly [HKT.W]!: () => W;
+  readonly [HKT.Q]!: (_: S1) => void;
+  readonly [HKT.S]!: () => S2;
+  readonly [HKT.R]!: (_: R) => void;
+  readonly [HKT.E]!: () => E;
+  readonly [HKT.A]!: () => A;
+  readonly [HKT.T]!: Z<HKT._W<this>, HKT._Q<this>, HKT._S<this>, HKT._R<this>, HKT._E<this>, HKT._A<this>>;
+}
+
+export interface ZFixed<W, S, R, E, A> {
+  readonly _typeId: ZTypeId;
+  readonly [HKT.F]: ZF;
+  readonly [HKT.W]: () => W;
+  readonly [HKT.Q]: (_: S) => void;
+  readonly [HKT.S]: () => S;
+  readonly [HKT.R]: (_: R) => void;
+  readonly [HKT.E]: () => E;
+  readonly [HKT.A]: () => A;
+  readonly [HKT.T]: Z<HKT._W<this>, HKT._S<this>, HKT._S<this>, HKT._R<this>, HKT._E<this>, HKT._A<this>>;
 }
 
 /**
  * @tsplus unify fncts.control.Z
  */
-export function unifyZ<X extends Z<any, any, any, any, any, any>>(_: X): Z<_W<X>, _S1<X>, _S2<X>, _R<X>, _E<X>, _A<X>> {
+export function unifyZ<X extends Z<any, any, any, any, any, any>>(
+  _: X,
+): Z<HKT._W<X>, HKT._Q<X>, HKT._S<X>, HKT._R<X>, HKT._E<X>, HKT._A<X>> {
   return _;
 }
 

package/_src/control/Z/instances.ts

@@ -1,14 +1,15 @@
-import type { ZF } from "./definition.js";
+import type * as P from "../../typeclass.js";
+import type { ZFixedF } from "./definition.js";
 
-import * as P from "../../typeclass.js";
-import { ap_, crossWith_, map_, succeedNow } from "./api.js";
+import { map_, succeedNow, zip_, zipWith_ } from "./api.js";
 
 /**
  * @tsplus static fncts.control.ZOps Applicative
+ * @tsplus implicit
  */
-export const Applicative: P.Applicative<ZF> = P.Applicative({
-  map_,
-  ap_,
-  zipWith_: crossWith_,
+export const Applicative: P.Applicative<ZFixedF> = {
+  map: map_,
+  zip: zip_,
+  zipWith: zipWith_,
   pure: succeedNow,
-});
+};

package/_src/data/Branded/definition.ts

@@ -0,0 +1,47 @@
+import type { Union } from "@fncts/typelevel";
+
+type Brand_<A, K extends string> = Brand<A, K>;
+
+export declare namespace Branded {
+  const Symbol: unique symbol;
+  export type Symbol = typeof Symbol;
+
+  export interface Brand<A, K extends string> {
+    readonly [Branded.Symbol]: {
+      [_ in K]: A;
+    };
+  }
+
+  export type Type<A extends Brand_<any, any>> = [A] extends [Brand_<infer A, infer K>] ? Validated<A, K> : never;
+
+  export type Validated<A, K extends string> = A & Brand<A, K>;
+
+  export type IsValidated<P extends Brand<any, any>> = {
+    [K in keyof P[Branded.Symbol]]: P extends P[Branded.Symbol][K] ? 0 : 1
+  }[keyof P[Branded.Symbol]] extends 0 ? unknown : never;
+
+  export type Unbrand<P extends Brand<any, any>> = P extends infer Q & Brands<P> ? Q : P;
+
+  export type Brands<P extends Brand<any, any>> = Union.IntersectionOf<{
+    [K in keyof P[Branded.Symbol]]: P extends P[Branded.Symbol][K]
+      ? K extends string
+        ? Brand<P[Branded.Symbol][K], K>
+        : never
+      : never;
+  }[keyof P[Branded.Symbol]]>;
+}
+
+/**
+ * @tsplus type fncts.Brand
+ * @tsplus companion fncts.BrandOps
+ */
+export class Brand<A, K extends string> {
+  constructor(readonly validate: Refinement<A, A & Branded.Brand<A, K>>) {}
+}
+
+/**
+ * @tsplus static fncts.BrandOps __call
+ */
+export function makeBrand<A, K extends string>(p: Predicate<A>): Brand<A, K> {
+  return new Brand(p as Refinement<A, A & Branded.Brand<A, K>>);
+}

package/_src/data/Branded/derivations.ts

@@ -0,0 +1,57 @@
+import type { Brand, Branded } from "@fncts/base/data/Branded/definition";
+import type { Check } from "@fncts/typelevel/Check";
+
+import { BrandedError, CompoundError } from "@fncts/base/data/DecodeError";
+import { Decoder } from "@fncts/base/data/Decoder/definition";
+
+/**
+ * @tsplus derive fncts.Guard<_> 10
+ */
+export function deriveGuard<A extends Branded.Brand<any, any>>(
+  ...[base, brands]: Check<Branded.IsValidated<A>> extends Check.True
+    ? [
+      base: Guard<Branded.Unbrand<A>>,
+      brands: {
+        [K in keyof A[Branded.Symbol] & string]: Brand<A[Branded.Symbol][K], K>;
+      }
+    ]
+    : never
+): Guard<A> {
+  const validations = Object.values(brands) as ReadonlyArray<Brand<A, any>>;
+  return Guard((u): u is A => base.is(u) && validations.every((brand) => brand.validate(u)));
+}
+
+/**
+ * @tsplus derive fncts.Decoder<_> 10
+ */
+export function deriveDecoder<A extends Branded.Brand<any, any>>(
+  ...[base, brands]: Check<Branded.IsValidated<A>> extends Check.True
+    ? [
+        base: Decoder<Branded.Unbrand<A>>,
+        brands: {
+          [K in keyof A[Branded.Symbol] & string]: Brand<A[Branded.Symbol][K], K>;
+        },
+      ]
+    : never
+): Decoder<A> {
+  const label = "Brand<" + Object.keys(brands).join(" & ") + ">";
+  return Decoder((u) => base.decode(u).match2(
+    These.left,
+    (warning, value) => {
+      const failedBrands: Array<string> = [];
+      for (const brand in brands) {
+        if (!brands[brand]!.validate(value as any)) {
+          failedBrands.push(brand);
+        }
+      }
+      if (failedBrands.length > 0) {
+        const error = new BrandedError(label, Vector.from(failedBrands));
+        return warning.match(
+          () => These.left(error),
+          (warning) => These.left(new CompoundError(label, Vector(warning, error)))
+        );
+      }
+      return These.rightOrBoth(warning, value);
+    }
+  ), label);
+}

package/_src/data/Branded.ts

@@ -0,0 +1,4 @@
+// codegen:start { preset: barrel, include: ./Branded/*.ts }
+export * from "./Branded/definition.js";
+export * from "./Branded/derivations.js";
+// codegen:end

package/_src/data/Cause/api/fold.ts

@@ -56,6 +56,7 @@ function foldLoop<E, Z>(
     }
   } else {
     return out.foldLeft(List.empty(), (acc, v) => {
+      Either.concrete(v);
       if (v.isRight()) {
         return acc.prepend(v.right);
       } else {

package/_src/data/Cause/api.ts

@@ -218,6 +218,7 @@ export function filterDefects_<E>(self: Cause<E>, p: Predicate<unknown>): Maybe<
  */
 function findLoop<A, B>(self: Cause<A>, f: (cause: Cause<A>) => Maybe<B>, stack: List<Cause<A>>): Maybe<B> {
   const r = f(self);
+  Maybe.concrete(r);
   switch (r._tag) {
     case MaybeTag.Nothing: {
       switch (self._tag) {
@@ -630,6 +631,15 @@ export function isThen<E>(self: Cause<E>): self is Then<E> {
   return self._tag === CauseTag.Then;
 }
 
+/**
+ * A type-guard matching `Interrupt`
+ *
+ * @tsplus fluent fncts.Cause isInterrupt
+ */
+export function isInterrupt<E>(self: Cause<E>): self is Interrupt {
+  return self._tag === CauseTag.Interrupt;
+}
+
 /**
  * A type-guard matching `Traced`
  *
@@ -799,6 +809,8 @@ function sequenceCauseEitherEval<E, A>(self: Cause<Either<E, A>>): Eval<Either<C
       return Eval.defer(() => sequenceCauseEitherEval(self.left)).zipWith(
         Eval.defer(() => sequenceCauseEitherEval(self.right)),
         (lefts, rights) => {
+          Either.concrete(lefts);
+          Either.concrete(rights);
           return lefts._tag === "Left"
             ? rights._tag === "Right"
               ? Either.right(rights.right)
@@ -811,6 +823,8 @@ function sequenceCauseEitherEval<E, A>(self: Cause<Either<E, A>>): Eval<Either<C
       return Eval.defer(() => sequenceCauseEitherEval(self.left)).zipWith(
         Eval.defer(() => sequenceCauseEitherEval(self.right)),
         (lefts, rights) => {
+          Either.concrete(lefts);
+          Either.concrete(rights);
           return lefts._tag === "Left"
             ? rights._tag === "Right"
               ? Either.right(rights.right)
@@ -854,6 +868,8 @@ function sequenceCauseMaybeEval<E>(self: Cause<Maybe<E>>): Eval<Maybe<Cause<E>>>
       return Eval.defer(() => sequenceCauseMaybeEval(self.left)).zipWith(
         Eval.defer(() => sequenceCauseMaybeEval(self.right)),
         (lefts, rights) => {
+          Maybe.concrete(lefts);
+          Maybe.concrete(rights);
           return lefts._tag === "Just"
             ? rights._tag === "Just"
               ? Maybe.just(Cause.then(lefts.value, rights.value))
@@ -868,6 +884,8 @@ function sequenceCauseMaybeEval<E>(self: Cause<Maybe<E>>): Eval<Maybe<Cause<E>>>
       return Eval.defer(() => sequenceCauseMaybeEval(self.left)).zipWith(
         Eval.defer(() => sequenceCauseMaybeEval(self.right)),
         (lefts, rights) => {
+          Maybe.concrete(lefts);
+          Maybe.concrete(rights);
           return lefts._tag === "Just"
             ? rights._tag === "Just"
               ? Maybe.just(Cause.both(lefts.value, rights.value))

package/_src/data/Const/api.ts

@@ -1,10 +1,10 @@
-import type { Const } from "./definition.js";
+import { Const } from "./definition.js";
 
 /**
  * @tsplus fluent fncts.Const map
  */
 export function map_<E, A, B>(self: Const<E, A>, _f: (a: A) => B): Const<E, B> {
-  return unsafeCoerce(self);
+  return new Const(self.getConst);
 }
 
 /**
@@ -12,5 +12,5 @@ export function map_<E, A, B>(self: Const<E, A>, _f: (a: A) => B): Const<E, B> {
  * @tsplus static fncts.ConstOps __call
  */
 export function mkConst<E, A = never>(e: E): Const<E, A> {
-  return unsafeCoerce(e);
+  return new Const(e);
 }