@fncts/base 0.0.13 → 0.0.16

package/_src/collection/immutable/ImmutableArray/derivations.ts

@@ -0,0 +1,28 @@
+import type { Check } from "@fncts/typelevel/Check";
+
+/**
+ * @tsplus derive fncts.Guard[fncts.ImmutableArray]<_> 10
+ */
+export function deriveGuard<A extends ImmutableArray<any>>(
+  ...[element]: [A] extends [ImmutableArray<infer A>] ? [element: Guard<A>] : never
+): Guard<A> {
+  return Guard((u): u is A => {
+    if (ImmutableArray.is(u)) {
+      return u._array.every(element.is);
+    }
+    return false;
+  });
+}
+
+/**
+ * @tsplus derive fncts.Decoder[fncts.ImmutableArray]<_> 10
+ */
+export function deriveDecoder<A extends ImmutableArray<any>>(
+  ...[array, elem]: [A] extends [ImmutableArray<infer _A>]
+    ? Check<Check.IsEqual<A, ImmutableArray<_A>>> extends Check.True
+      ? [array: Decoder<Array<_A>>, elem: Decoder<_A>]
+      : never
+    : never
+): Decoder<A> {
+  return Decoder((u) => array.decode(u).map((as) => new ImmutableArray(as) as A), `ImmutableArray<${elem.label}>`);
+}

package/_src/collection/immutable/ImmutableArray/instances.ts

@@ -1,5 +1,7 @@
 import type { ImmutableArrayF } from "@fncts/base/collection/immutable/ImmutableArray/definition";
+import type { DecodeError } from "@fncts/base/data/DecodeError";
 import type * as P from "@fncts/base/typeclass";
+import type { Check } from "@fncts/typelevel/Check";
 
 import {
   alignWith_,
@@ -29,6 +31,9 @@ import {
   witherWithIndex,
 } from "@fncts/base/collection/immutable/ImmutableArray/api";
 import { empty } from "@fncts/base/collection/immutable/ImmutableArray/constructors";
+import { isImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
+import { CompoundError, OptionalIndexError, PrimitiveError } from "@fncts/base/data/DecodeError";
+import { Decoder } from "@fncts/base/data/Decoder";
 
 /**
  * @tsplus implicit

package/_src/collection/immutable/ImmutableArray.ts

@@ -2,6 +2,7 @@
 export * from "./ImmutableArray/api.js";
 export * from "./ImmutableArray/constructors.js";
 export * from "./ImmutableArray/definition.js";
+export * from "./ImmutableArray/derivations.js";
 export * from "./ImmutableArray/instances.js";
 // codegen:end
 

package/_src/collection/immutable/ImmutableNonEmptyArray/constructors.ts

@@ -7,8 +7,8 @@ export function allocWithHead<A>(head: A, length: number): Array<A> & { 0: A } {
 }
 
 /**
- * @tsplus getter fncts.base.ReadonlyArray unsafeAsNonEmptyArray
- * @tsplus getter fncts.base.Array unsafeAsNonEmptyArray
+ * @tsplus getter fncts.ReadonlyArray unsafeAsNonEmptyArray
+ * @tsplus getter fncts.Array unsafeAsNonEmptyArray
  */
 export function unsafeAsNonEmptyArray<A>(self: ReadonlyArray<A>): ImmutableNonEmptyArray<A> {
   if (self.length === 0) {

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

@@ -20,14 +20,14 @@ export class ImmutableNonEmptyArray<A> extends ImmutableArray<A> {
 }
 
 /**
- * @tsplus type fncts.base.NonEmptyArray
+ * @tsplus type fncts.NonEmptyArray
  */
 export interface NonEmptyArray<T> extends Array<T> {
   0: T;
 }
 
 /**
- * @tsplus type fncts.base.ReadonlyNonEmptyArray
+ * @tsplus type fncts.ReadonlyNonEmptyArray
  */
 export interface ReadonlyNonEmptyArray<T> extends ReadonlyArray<T> {
   readonly 0: T;

package/_src/collection/immutable/ImmutableNonEmptyArray/derivations.ts

@@ -0,0 +1,44 @@
+import type { Check } from "@fncts/typelevel/Check";
+
+import { CompoundError, EmptyError } from "@fncts/base/data/DecodeError";
+
+/**
+ * @tsplus derive fncts.Guard[fncts.ImmutableNonEmptyArray]<_> 10
+ */
+export function deriveGuard<A extends ImmutableNonEmptyArray<any>>(
+  ...[elem]: [A] extends [ImmutableNonEmptyArray<infer _A>] ? [elem: Guard<_A>] : never
+): Guard<A> {
+  return Guard((u): u is A => {
+    if (ImmutableNonEmptyArray.is(u)) {
+      return u.every(elem.is);
+    }
+    return false;
+  });
+}
+
+/**
+ * @tsplus derive fncts.Decoder[fncts.ImmutableNonEmptyArray]<_> 10
+ */
+export function deriveDecoder<A extends ImmutableNonEmptyArray<any>>(
+  ...[array, elem]: [A] extends [ImmutableNonEmptyArray<infer _A>]
+    ? Check<Check.IsEqual<A, ImmutableNonEmptyArray<_A>>> extends Check.True
+      ? [array: Decoder<Array<_A>>, elem: Decoder<_A>]
+      : never
+    : never
+): Decoder<A> {
+  return Decoder(
+    (u) =>
+      array.decode(u).match2(These.left, (warn, as) => {
+        if (as.isNonEmpty()) {
+          return These.right(new ImmutableNonEmptyArray(as) as A);
+        } else {
+          const err = new EmptyError(as);
+          return warn.match(
+            () => These.left(err),
+            (err0) => These.left(new CompoundError(`ImmutableNonEmptyArray<${elem.label}>`, Vector(err0, err))),
+          );
+        }
+      }),
+    `ImmutableNonEmptyArray<${elem.label}>`,
+  );
+}

package/_src/collection/immutable/ImmutableNonEmptyArray.ts

@@ -2,6 +2,7 @@
 export * from "./ImmutableNonEmptyArray/api.js";
 export * from "./ImmutableNonEmptyArray/constructors.js";
 export * from "./ImmutableNonEmptyArray/definition.js";
+export * from "./ImmutableNonEmptyArray/derivations.js";
 export * from "./ImmutableNonEmptyArray/destructors.js";
 export * from "./ImmutableNonEmptyArray/instances.js";
 // codegen:end

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

@@ -13,7 +13,7 @@
  */
 
 /**
- * @tsplus type fncts.base.List.Cons
+ * @tsplus type fncts.List.Cons
  * @tsplus companion fncts.ConsOps
  */
 export class Cons<A> implements Iterable<A> {
@@ -48,7 +48,7 @@ export class Cons<A> implements Iterable<A> {
 }
 
 /**
- * @tsplus type fncts.base.List.Nil
+ * @tsplus type fncts.List.Nil
  * @tsplus companion fncts.NilOps
  */
 export class Nil<A> implements Iterable<A> {

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

@@ -53,7 +53,7 @@ export class Vector<A> implements Iterable<A> {
 }
 
 /**
- * @tsplus type fncts.base.MutableVector
+ * @tsplus type fncts.MutableVector
  */
 export interface MutableVector<A> {
   readonly _typeId: VectorTypeId;

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

@@ -357,7 +357,7 @@ export function decrementDepth(bits: number): number {
 /**
  * Appends the value to the Vector by _mutating_ the Vector and its content.
  *
- * @tsplus fluent fncts.base.MutableVector push
+ * @tsplus fluent fncts.MutableVector push
  */
 export function push<A>(l: MutableVector<A>, value: A): MutableVector<A> {
   const suffixSize = getSuffixSize(l);

package/_src/collection/immutable.ts

@@ -0,0 +1,12 @@
+// codegen:start { preset: type-barrel, include: ./immutable/*.ts }
+export type {} from "./immutable/Conc.js";
+export type {} from "./immutable/HashMap.js";
+export type {} from "./immutable/HashSet.js";
+export type {} from "./immutable/ImmutableArray.js";
+export type {} from "./immutable/ImmutableNonEmptyArray.js";
+export type {} from "./immutable/List.js";
+export type {} from "./immutable/Queue.js";
+export type {} from "./immutable/RoseTree.js";
+export type {} from "./immutable/SortedMap.js";
+export type {} from "./immutable/Vector.js";
+// codegen:end

package/_src/collection/mutable/HashMap.ts

@@ -56,6 +56,10 @@ export class HashMap<K, V> implements Iterable<readonly [K, V]> {
     return this.findNode(key) !== undefined;
   }
 
+  unsafeGet(key: K): V | undefined {
+    return this.findNode(key)?.value;
+  }
+
   get(key: K): Maybe<V> {
     const n = this.findNode(key);
     return n ? Just(n.value) : Nothing();

package/_src/collection/mutable.ts

@@ -0,0 +1,6 @@
+// codegen:start { preset: type-barrel, include: ./mutable/*.ts }
+export type {} from "./mutable/HashMap.js";
+export type {} from "./mutable/HashSet.js";
+export type {} from "./mutable/internal.js";
+export type {} from "./mutable/ListBuffer.js";
+// codegen:end

package/_src/collection/weak.ts

@@ -0,0 +1,4 @@
+// codegen:start { preset: type-barrel, include: ./weak/*.ts }
+export type {} from "./weak/IterableWeakMap.js";
+export type {} from "./weak/IterableWeakSet.js";
+// codegen:end

package/_src/collection.ts

@@ -0,0 +1,7 @@
+// codegen:start { preset: type-barrel, include: ./collection/*.ts }
+export type {} from "./collection/compat.js";
+export type {} from "./collection/immutable.js";
+export type {} from "./collection/Iterable.js";
+export type {} from "./collection/mutable.js";
+export type {} from "./collection/weak.js";
+// codegen:end

package/_src/control/Eval/definition.ts

@@ -1,4 +1,4 @@
-export const EvalTypeId = Symbol.for("@fncts.base/control/Eval");
+export const EvalTypeId = Symbol.for("@fncts/control/Eval");
 export type EvalTypeId = typeof EvalTypeId;
 
 export interface EvalF extends HKT {

package/_src/control/Z/api.ts

@@ -60,7 +60,7 @@ export function bimap_<W, S1, S2, R, E, A, G, B>(
 export function catchAll_<W, S1, S2, R, E, A, S3, R1, E1, B>(
   fa: Z<W, S1, S2, R, E, A>,
   onFailure: (e: E) => Z<W, S1, S3, R1, E1, B>,
-): Z<W, S1, S3, R & R1, E1, A | B> {
+): Z<W, S1, S3, R | R1, E1, A | B> {
   return fa.matchZ(onFailure, Z.succeedNow);
 }
 
@@ -70,7 +70,7 @@ export function catchAll_<W, S1, S2, R, E, A, S3, R1, E1, B>(
 export function catchJust_<W, S1, S2, R, E, A, S3, R1, E1, B>(
   fa: Z<W, S1, S2, R, E, A>,
   f: (e: E) => Maybe<Z<W, S1, S3, R1, E1, B>>,
-): Z<W, S1, S2 | S3, R & R1, E | E1, A | B> {
+): Z<W, S1, S2 | S3, R | R1, E | E1, A | B> {
   return fa.catchAll((e) => f(e).getOrElse(fa));
 }
 
@@ -184,31 +184,28 @@ export function erase<W, S1, S2, R, E, A>(wa: Z<W, S1, S2, R, E, A>): Z<never, S
 /**
  * @tsplus static fncts.control.ZOps fail
  */
-export function fail<E>(e: Lazy<E>, __tsplusTrace?: string): Z<never, unknown, never, unknown, E, never> {
+export function fail<E>(e: Lazy<E>, __tsplusTrace?: string): Z<never, unknown, never, never, E, never> {
   return Z.failCause(Cause.fail(e()));
 }
 
 /**
  * @tsplus static fncts.control.ZOps failNow
  */
-export function failNow<E>(e: E, __tsplusTrace?: string): Z<never, unknown, never, unknown, E, never> {
+export function failNow<E>(e: E, __tsplusTrace?: string): Z<never, unknown, never, never, E, never> {
   return Z.failCauseNow(Cause.fail(e));
 }
 
 /**
  * @tsplus static fncts.control.ZOps failCause
  */
-export function failCause<E>(
-  cause: Lazy<Cause<E>>,
-  __tsplusTrace?: string,
-): Z<never, unknown, never, unknown, E, never> {
+export function failCause<E>(cause: Lazy<Cause<E>>, __tsplusTrace?: string): Z<never, unknown, never, never, E, never> {
   return Z.defer(Z.failCauseNow(cause()));
 }
 
 /**
  * @tsplus static fncts.control.ZOps failCauseNow
  */
-export function failCauseNow<E>(cause: Cause<E>, __tsplusTrace?: string): Z<never, unknown, never, unknown, E, never> {
+export function failCauseNow<E>(cause: Cause<E>, __tsplusTrace?: string): Z<never, unknown, never, never, E, never> {
   return new Fail(cause);
 }
 
@@ -226,14 +223,14 @@ export function flatten<W, S1, S2, R, E, A, W1, S3, R1, E1>(
  *
  * @tsplus static fncts.control.ZOps get
  */
-export function get<S>(): Z<never, S, S, unknown, never, S> {
+export function get<S>(): Z<never, S, S, never, never, S> {
   return Z.modify((s) => [s, s]);
 }
 
 /**
  * @tsplus static fncts.control.ZOps gets
  */
-export function gets<S, A>(f: (s: S) => A): Z<never, S, S, unknown, never, A> {
+export function gets<S, A>(f: (s: S) => A): Z<never, S, S, never, never, A> {
   return Z.modify((s) => [f(s), s]);
 }
 
@@ -247,14 +244,14 @@ export function getsZ<S, W, R, E, A>(f: (s: S) => Z<W, S, S, R, E, A>): Z<W, S,
 /**
  * @tsplus static fncts.control.ZOps halt
  */
-export function halt(defect: Lazy<unknown>, __tsplusTrace?: string): Z<never, unknown, never, unknown, never, never> {
+export function halt(defect: Lazy<unknown>, __tsplusTrace?: string): Z<never, unknown, never, never, never, never> {
   return Z.failCause(Cause.halt(defect()));
 }
 
 /**
  * @tsplus static fncts.control.ZOps haltNow
  */
-export function haltNow(defect: unknown, __tsplusTrace?: string): Z<never, unknown, never, unknown, never, never> {
+export function haltNow(defect: unknown, __tsplusTrace?: string): Z<never, unknown, never, never, never, never> {
   return Z.failCauseNow(Cause.halt(defect));
 }
 
@@ -341,7 +338,7 @@ export function matchZ_<W, S1, S5, S2, R, E, A, W1, S3, R1, E1, B, W2, S4, R2, E
   fa: Z<W, S1, S2, R, E, A>,
   onFailure: (e: E) => Z<W1, S5, S3, R1, E1, B>,
   onSuccess: (a: A) => Z<W2, S2, S4, R2, E2, C>,
-): Z<W | W1 | W2, S1 & S5, S3 | S4, R & R1 & R2, E1 | E2, B | C> {
+): Z<W | W1 | W2, S1 & S5, S3 | S4, R | R1 | R2, E1 | E2, B | C> {
   return fa.matchCauseZ((cause) => cause.failureOrCause.match(onFailure, Z.failCauseNow), onSuccess);
 }
 
@@ -352,7 +349,7 @@ export function matchCauseZ_<W, S1, S2, R, E, A, W1, S0, S3, R1, E1, B, W2, S4,
   fa: Z<W, S1, S2, R, E, A>,
   onFailure: (e: Cause<E>) => Z<W1, S0, S3, R1, E1, B>,
   onSuccess: (a: A) => Z<W2, S2, S4, R2, E2, C>,
-): Z<W | W1 | W2, S0 & S1, S3 | S4, R & R1 & R2, E1 | E2, B | C> {
+): Z<W | W1 | W2, S0 & S1, S3 | S4, R | R1 | R2, E1 | E2, B | C> {
   return matchLogCauseZ_(
     fa,
     (ws, e) => onFailure(e).mapLog((w1s) => ws.concat(w1s)),
@@ -367,7 +364,7 @@ export function matchLogZ_<W, S1, S5, S2, R, E, A, W1, S3, R1, E1, B, W2, S4, R2
   fa: Z<W, S1, S2, R, E, A>,
   onFailure: (ws: Conc<W>, e: E) => Z<W1, S5, S3, R1, E1, B>,
   onSuccess: (ws: Conc<W>, a: A) => Z<W2, S2, S4, R2, E2, C>,
-): Z<W | W1 | W2, S1 & S5, S3 | S4, R & R1 & R2, E1 | E2, B | C> {
+): Z<W | W1 | W2, S1 & S5, S3 | S4, R | R1 | R2, E1 | E2, B | C> {
   return matchLogCauseZ_(
     fa,
     (ws, cause) => cause.failureOrCause.match((e) => onFailure(ws, e), Z.failCauseNow),
@@ -398,7 +395,7 @@ export function matchLogCauseZ_<W, S1, S2, R, E, A, W1, S0, S3, R1, E1, B, W2, S
  *
  * @tsplus static fncts.control.ZOps modify
  */
-export function modify<S1, S2, A>(f: (s: S1) => readonly [A, S2]): Z<never, S1, S2, unknown, never, A> {
+export function modify<S1, S2, A>(f: (s: S1) => readonly [A, S2]): Z<never, S1, S2, never, never, A> {
   return new Modify(f);
 }
 
@@ -407,7 +404,7 @@ export function modify<S1, S2, A>(f: (s: S1) => readonly [A, S2]): Z<never, S1,
  *
  * @tsplus static fncts.control.ZOps modifyEither
  */
-export function modifyEither<S1, S2, E, A>(f: (s: S1) => Either<E, readonly [A, S2]>): Z<never, S1, S2, unknown, E, A> {
+export function modifyEither<S1, S2, E, A>(f: (s: S1) => Either<E, readonly [A, S2]>): Z<never, S1, S2, never, E, A> {
   return Z.get<S1>()
     .map(f)
     .flatMap((r) => r.match(Z.failNow, ([a, s2]) => Z.succeedNow(a).mapState(() => s2)));
@@ -419,7 +416,7 @@ export function modifyEither<S1, S2, E, A>(f: (s: S1) => Either<E, readonly [A,
 export function orElse_<W, S1, S2, R, E, A, W1, S3, R1, E1, A1>(
   fa: Z<W, S1, S2, R, E, A>,
   fb: Lazy<Z<W1, S1, S3, R1, E1, A1>>,
-): Z<W | W1, S1, S2 | S3, R & R1, E | E1, A | A1> {
+): Z<W | W1, S1, S2 | S3, R | R1, E | E1, A | A1> {
   return fa.matchZ(() => fb(), Z.succeedNow);
 }
 
@@ -432,7 +429,7 @@ export function orElse_<W, S1, S2, R, E, A, W1, S3, R1, E1, A1>(
 export function orElseEither_<W, S1, S2, R, E, A, S3, S4, R1, E1, A1>(
   fa: Z<W, S1, S2, R, E, A>,
   that: Lazy<Z<W, S3, S4, R1, E1, A1>>,
-): Z<W, S1 & S3, S2 | S4, R & R1, E1, Either<A, A1>> {
+): Z<W, S1 & S3, S2 | S4, R | R1, E1, Either<A, A1>> {
   return fa.matchZ(
     () => that().map(Either.right),
     (a) => Z.succeedNow(Either.left(a)),
@@ -454,7 +451,7 @@ export function provideEnvironment_<W, S1, S2, R, E, A>(
  *
  * @tsplus static fncts.control.ZOps put
  */
-export function put<S>(s: S): Z<never, unknown, S, unknown, never, void> {
+export function put<S>(s: S): Z<never, unknown, S, never, never, void> {
   return Z.modify(() => [undefined, s]);
 }
 
@@ -487,7 +484,7 @@ export function repeatUntil_<W, S1, S2 extends S1, R, E, A>(
 export function succeed<A, W = never, S1 = unknown, S2 = never>(
   effect: Lazy<A>,
   __tsplusTrace?: string,
-): Z<W, S1, S2, unknown, never, A> {
+): Z<W, S1, S2, never, never, A> {
   return new Succeed(effect);
 }
 
@@ -497,7 +494,7 @@ export function succeed<A, W = never, S1 = unknown, S2 = never>(
 export function succeedNow<A, W = never, S1 = unknown, S2 = never>(
   a: A,
   __tsplusTrace?: string,
-): Z<W, S1, S2, unknown, never, A> {
+): Z<W, S1, S2, never, never, A> {
   return new SucceedNow(a);
 }
 
@@ -514,14 +511,14 @@ export function tap_<W, S1, S2, R, E, A, W1, S3, R1, E1, B>(
 /**
  * @tsplus static fncts.control.ZOps tell
  */
-export function tell<W>(w: W): Z<W, unknown, never, unknown, never, void> {
+export function tell<W>(w: W): Z<W, unknown, never, never, never, void> {
   return Z.tellAll(Conc.single(w));
 }
 
 /**
  * @tsplus static fncts.control.ZOps tellAll
  */
-export function tellAll<W>(ws: Conc<W>): Z<W, unknown, never, unknown, never, void> {
+export function tellAll<W>(ws: Conc<W>): Z<W, unknown, never, never, never, void> {
   return new Tell(ws);
 }
 
@@ -540,14 +537,14 @@ export function transform_<W, S1, S2, R, E, A, S3, B>(
 /**
  * @tsplus static fncts.control.ZOps unit
  */
-export const unit: Z<never, unknown, never, unknown, never, void> = Z.succeedNow(undefined);
+export const unit: Z<never, unknown, never, never, never, void> = Z.succeedNow(undefined);
 
 /**
  * Constructs a computation from the specified update function.
  *
  * @tsplus static fncts.control.ZOps update
  */
-export function update<S1, S2>(f: (s: S1) => S2): Z<never, S1, S2, unknown, never, void> {
+export function update<S1, S2>(f: (s: S1) => S2): Z<never, S1, S2, never, never, void> {
   return Z.modify((s) => [undefined, f(s)]);
 }
 

package/_src/control/Z/definition.ts

@@ -32,7 +32,7 @@ export abstract class Z<W, S1, S2, R, E, A> {
   readonly _W!: () => W;
   readonly _S1!: (_: S1) => void;
   readonly _S2!: () => S2;
-  readonly _R!: (_: R) => void;
+  readonly _R!: () => R;
   readonly _E!: () => E;
   readonly _A!: () => A;
 }
@@ -75,14 +75,14 @@ export const enum ZTag {
   MapLog = "MapLog",
 }
 
-export class SucceedNow<A> extends Z<never, unknown, never, unknown, never, A> {
+export class SucceedNow<A> extends Z<never, unknown, never, never, never, A> {
   readonly _tag = ZTag.SucceedNow;
   constructor(readonly value: A) {
     super();
   }
 }
 
-export class Succeed<A> extends Z<never, unknown, never, unknown, never, A> {
+export class Succeed<A> extends Z<never, unknown, never, never, never, A> {
   readonly _tag = ZTag.Succeed;
   constructor(readonly effect: () => A) {
     super();
@@ -96,14 +96,14 @@ export class Defer<W, S1, S2, R, E, A> extends Z<W, S1, S2, R, E, A> {
   }
 }
 
-export class Fail<E> extends Z<never, unknown, never, unknown, E, never> {
+export class Fail<E> extends Z<never, unknown, never, never, E, never> {
   readonly _tag = ZTag.Fail;
   constructor(readonly cause: Cause<E>) {
     super();
   }
 }
 
-export class Modify<S1, S2, A> extends Z<never, S1, S2, unknown, never, A> {
+export class Modify<S1, S2, A> extends Z<never, S1, S2, never, never, A> {
   readonly _tag = ZTag.Modify;
   constructor(readonly run: (s1: S1) => readonly [A, S2]) {
     super();
@@ -149,7 +149,7 @@ export class Provide<W, S1, S2, R, E, A> extends Z<W, S1, S2, never, E, A> {
   }
 }
 
-export class Tell<W> extends Z<W, unknown, never, unknown, never, void> {
+export class Tell<W> extends Z<W, unknown, never, never, never, void> {
   readonly _tag = ZTag.Tell;
   constructor(readonly log: Conc<W>) {
     super();
@@ -179,7 +179,6 @@ export type Concrete =
 /**
  * @tsplus static fncts.control.ZOps concrete
  */
-// @ts-expect-error
 export function concrete(_: Z<any, any, any, any, any, any>): asserts _ is Concrete {
   //
 }

package/_src/control/Z/runtime.ts

@@ -246,7 +246,7 @@ export function unsafeRunReader_<W, R, A>(ma: Z<W, unknown, never, R, never, A>,
  *
  * @tsplus fluent fncts.control.Z unsafeRunState
  */
-export function unsafeRunState_<W, S1, S2, A>(ma: Z<W, S1, S2, unknown, never, A>, s: S1): S2 {
+export function unsafeRunState_<W, S1, S2, A>(ma: Z<W, S1, S2, never, never, A>, s: S1): S2 {
   return ma.unsafeRun(s)[0];
 }
 
@@ -256,7 +256,7 @@ export function unsafeRunState_<W, S1, S2, A>(ma: Z<W, S1, S2, unknown, never, A
  *
  * @tsplus fluent fncts.control.Z unsafeRunStateResult
  */
-export function unsafeRunStateResult_<W, S1, S2, A>(ma: Z<W, S1, S2, unknown, never, A>, s: S1): A {
+export function unsafeRunStateResult_<W, S1, S2, A>(ma: Z<W, S1, S2, never, never, A>, s: S1): A {
   return ma.unsafeRunAll(s)[1].match(
     (cause) => {
       // throw cause.squash
@@ -271,7 +271,7 @@ export function unsafeRunStateResult_<W, S1, S2, A>(ma: Z<W, S1, S2, unknown, ne
  *
  * @tsplus getter fncts.control.Z unsafeRunExit
  */
-export function unsafeRunExit<E, A>(ma: Z<never, unknown, unknown, unknown, E, A>): Exit<E, A> {
+export function unsafeRunExit<E, A>(ma: Z<never, unknown, unknown, never, E, A>): Exit<E, A> {
   return ma.unsafeRunAll({} as never)[1].map(([_, a]) => a);
 }
 
@@ -279,7 +279,7 @@ export function unsafeRunExit<E, A>(ma: Z<never, unknown, unknown, unknown, E, A
  *
  * @tsplus getter fncts.control.Z unsafeRunWriter
  */
-export function unsafeRunWriter<W, A>(ma: Z<W, unknown, unknown, unknown, never, A>): readonly [Conc<W>, A] {
+export function unsafeRunWriter<W, A>(ma: Z<W, unknown, unknown, never, never, A>): readonly [Conc<W>, A] {
   const [w, exit] = ma.unsafeRunAll({});
   return exit.match(
     () => {

package/_src/control.ts

@@ -0,0 +1,5 @@
+// codegen:start { preset: type-barrel, include: ./control/*.ts }
+export type {} from "./control/Eval.js";
+export type {} from "./control/LazyValue.js";
+export type {} from "./control/Z.js";
+// codegen:end

package/_src/data/DecodeError/definition.ts

@@ -225,3 +225,11 @@ export class UnionError extends DecodeError {
       .map((errors) => RoseTree(`${this.errors.length} error(s) found while decoding ${this.label}`, errors)),
   );
 }
+
+export class EmptyError extends DecodeError {
+  readonly _tag = "EmptyError";
+  constructor(readonly actual: unknown) {
+    super();
+  }
+  render = Eval(RoseTree(cannotDecode(this.actual, "a collection containing at least one element")));
+}

package/_src/data/DecodeError.ts

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

package/_src/data/Either/definition.ts

@@ -3,7 +3,7 @@ export const enum EitherTag {
   Right = "Right",
 }
 
-export const EitherTypeId = Symbol.for("fncts.base.data.Either");
+export const EitherTypeId = Symbol.for("fncts.data.Either");
 export type EitherTypeId = typeof EitherTypeId;
 
 export interface EitherF extends HKT {

package/_src/data/Environment/api.ts

@@ -2,8 +2,7 @@
  * @tsplus fluent fncts.Environment add
  */
 export function add<R, H extends S, S = H>(self: Environment<R>, service: H, tag: Tag<S>): Environment<R | S> {
-  const self0 = self.index === Number.MAX_SAFE_INTEGER ? self.clean : self;
-  return new Environment(self0.map.set(tag, [service, self0.index]), self0.index + 1);
+  return new Environment(self.map.set(tag, service));
 }
 
 /**
@@ -31,7 +30,7 @@ export function getMaybe<R extends Has<S>, S>(self: Environment<R>, tag: Tag<S>)
  * @tsplus static fncts.EnvironmentOps __call
  */
 export function make(): Environment<never> {
-  return new Environment(HashMap.makeDefault(), 0, HashMap.makeDefault());
+  return new Environment(HashMap.makeDefault(), HashMap.makeDefault());
 }
 
 /**
@@ -39,10 +38,8 @@ export function make(): Environment<never> {
  * @tsplus fluent fncts.Environment union
  */
 export function union<R, R1>(self: Environment<R>, that: Environment<R1>): Environment<R & R1> {
-  const [self0, that0] = self.index + that.index < self.index ? [self.clean, that.clean] : [self, that];
   return new Environment(
-    self0.map.union(that0.map.map(([service, index]) => [service, self0.index + index] as const)),
-    self0.index + that0.index,
+    self.map.union(that.map),
   );
 }
 
@@ -51,13 +48,12 @@ export function union<R, R1>(self: Environment<R>, that: Environment<R1>): Envir
  */
 export function clean<R>(self: Environment<R>): Environment<R> {
   const [map, index] = self.map.toList
-    .sort(Number.Ord.contramap(([, [, idx]]) => idx))
     .foldLeft(
       [HashMap.makeDefault<Tag<unknown>, readonly [unknown, number]>(), 0],
-      ([map, index], [tag, [service]]) => [map.set(tag, [service, index] as const), index + 1],
+      ([map, index], [tag, service]) => [map.set(tag, [service, index] as const), index + 1],
     );
 
-  return new Environment(map, index);
+  return new Environment(map);
 }
 
 /**
@@ -66,14 +62,12 @@ export function clean<R>(self: Environment<R>): Environment<R> {
 export function unsafeGet<R, S>(self: Environment<R>, tag: Tag<S>): S {
   return self.cache.get(tag).match(
     () => {
-      let index      = -1;
       const iterator = self.map[Symbol.iterator]();
       let service: S = null!;
-      let r: IteratorResult<readonly [Tag<unknown>, readonly [unknown, number]]>;
+      let r: IteratorResult<readonly [Tag<unknown>, unknown]>;
       while (!(r = iterator.next()).done) {
-        const [curTag, [curService, curIndex]] = r.value;
-        if (curTag == tag && curIndex > index) {
-          index   = curIndex;
+        const [curTag, curService] = r.value;
+        if (curTag == tag) {
           service = curService as S;
         }
       }

package/_src/data/Environment/definition.ts

@@ -13,8 +13,7 @@ export class Environment<R> implements Hashable, Equatable {
   readonly _typeId: EnvSymbol = EnvSymbol;
   readonly [EnvSymbol]!: (_: never) => R;
   constructor(
-    readonly map: HashMap<Tag<any>, readonly [unknown, number]>,
-    readonly index: number,
+    readonly map: HashMap<Tag<any>, unknown>,
     public cache: HashMap<Tag<any>, unknown> = HashMap.makeDefault(),
   ) {}