@fncts/base 0.0.13 → 0.0.14

package/_mjs/util.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.mjs","mappings":"","names":[],"sourceRoot":"","sources":[],"sourcesContent":[]}

package/_src/collection/compat/Array/api.ts

@@ -1,8 +1,8 @@
 import type { Eq } from "@fncts/base/typeclass";
 
 /**
- * @tsplus getter fncts.base.Array elem
- * @tsplus getter fncts.base.ReadonlyArray elem
+ * @tsplus getter fncts.Array elem
+ * @tsplus getter fncts.ReadonlyArray elem
  */
 export function elem<A>(self: ReadonlyArray<A>) {
   return (eq: Eq<A>) =>
@@ -17,32 +17,32 @@ export function elem<A>(self: ReadonlyArray<A>) {
 }
 
 /**
- * @tsplus fluent fncts.base.Array isEmpty
- * @tsplus fluent fncts.base.ReadonlyArray isEmpty
+ * @tsplus fluent fncts.Array isEmpty
+ * @tsplus fluent fncts.ReadonlyArray isEmpty
  */
 export function isEmpty<A>(self: ReadonlyArray<A>): boolean {
   return self.length === 0;
 }
 
 /**
- * @tsplus fluent fncts.base.Array isNonEmpty
- * @tsplus fluent fncts.base.ReadonlyArray isNonEmpty
+ * @tsplus fluent fncts.Array isNonEmpty
+ * @tsplus fluent fncts.ReadonlyArray isNonEmpty
  */
 export function isNonEmpty<A>(self: ReadonlyArray<A>): self is ReadonlyNonEmptyArray<A> {
   return self.length > 0;
 }
 
 /**
- * @tsplus fluent fncts.base.Array foldLeft
- * @tsplus fluent fncts.base.ReadonlyArray foldLeft
+ * @tsplus fluent fncts.Array foldLeft
+ * @tsplus fluent fncts.ReadonlyArray foldLeft
  */
 export function foldLeft<A, B>(self: ReadonlyArray<A>, b: B, f: (b: B, a: A) => B): B {
   return self.foldLeftWithIndex(b, (_, b, a) => f(b, a));
 }
 
 /**
- * @tsplus fluent fncts.base.Array foldLeftWithIndex
- * @tsplus fluent fncts.base.ReadonlyArray foldLeftWithIndex
+ * @tsplus fluent fncts.Array foldLeftWithIndex
+ * @tsplus fluent fncts.ReadonlyArray foldLeftWithIndex
  */
 export function foldLeftWithIndex<A, B>(self: ReadonlyArray<A>, b: B, f: (i: number, b: B, a: A) => B): B {
   let out = b;

package/_src/collection/compat/Array/definition.ts

@@ -1,16 +1,16 @@
 declare global {
   /**
-   * @tsplus type fncts.base.ReadonlyArray
+   * @tsplus type fncts.ReadonlyArray
    */
   export interface ReadonlyArray<T> {}
 
   /**
-   * @tsplus type fncts.base.Array
+   * @tsplus type fncts.Array
    */
   export interface Array<T> {}
 
   /**
-   * @tsplus type fncts.base.ArrayOps
+   * @tsplus type fncts.ArrayOps
    */
   export interface ArrayConstructor {}
 }

package/_src/collection/compat/Array/derivations.ts

@@ -0,0 +1,85 @@
+import type { DecodeError } from "@fncts/base/data/DecodeError";
+import type { Check } from "@fncts/typelevel/Check";
+
+import { CompoundError, OptionalIndexError, PrimitiveError } from "@fncts/base/data/DecodeError";
+
+/**
+ * @tsplus derive fncts.Guard[fncts.Array]<_> 10
+ */
+export function deriveGuard<A extends Array<any>>(
+  ...[element]: [A] extends [Array<infer _A>]
+    ? Check<Check.IsEqual<A, Array<_A>>> extends Check.True
+      ? [element: Guard<_A>]
+      : never
+    : never
+): Guard<A> {
+  return Guard((u): u is A => {
+    if (Array.isArray(u)) {
+      return u.every(element.is);
+    }
+    return false;
+  });
+}
+
+/**
+ * @tsplus derive fncts.Guard[fncts.ReadonlyArray]<_> 10
+ */
+export const deriveReadonlyArrayGuard: <A extends ReadonlyArray<any>>(
+  ...[element]: [A] extends [ReadonlyArray<infer _A>]
+    ? Check<Check.IsEqual<A, ReadonlyArray<_A>>> extends Check.True
+      ? [element: Guard<_A>]
+      : never
+    : never
+) => Guard<A> = deriveGuard.unsafeCoerce();
+
+/**
+ * @tsplus derive fncts.Decoder[fncts.Array]<_> 10
+ */
+export function deriveDecoder<A extends Array<any>>(
+  ...[element]: [A] extends [Array<infer _A>]
+    ? Check<Check.IsEqual<A, Array<_A>>> extends Check.True
+      ? [element: Decoder<_A>]
+      : never
+    : never
+): Decoder<A> {
+  return Decoder((u) => {
+    if (Array.isArray(u)) {
+      const errors = Vector.emptyPushable<DecodeError>();
+      let failed   = false;
+      const out    = Array(u.length);
+      for (let i = 0; i < u.length; i++) {
+        const decoded = element.decode(u[i]!);
+        decoded.match2(
+          (err) => {
+            failed = true;
+            errors.push(new OptionalIndexError(i, err));
+          },
+          (warning, value) => {
+            out[i] = value;
+            if (warning.isJust()) {
+              errors.push(warning.value);
+            }
+          },
+        );
+      }
+      if (failed) {
+        return These.left(new CompoundError("Array", errors));
+      }
+      return These.rightOrBoth(errors.length > 0 ? Just(new CompoundError("Array", errors)) : Nothing(), out as A);
+    }
+    return These.left(new PrimitiveError(u, "Array"));
+  }, `Array<${element.label}>`);
+}
+
+/**
+ * @tsplus derive fncts.Decoder[fncts.ReadonlyArray]<_> 10
+ */
+export function deriveReadonlyArrayDecoder<A extends ReadonlyArray<any>>(
+  ...[element]: [A] extends [ReadonlyArray<infer _A>]
+    ? Check<Check.IsEqual<A, ReadonlyArray<_A>>> extends Check.True
+      ? [element: Decoder<_A>]
+      : never
+    : never
+): Decoder<A> {
+  return Decoder((u) => deriveDecoder(element).decode(u) as These<DecodeError, A>, `ReadonlyArray<${element.label}>`);
+}

package/_src/collection/compat/Array.ts

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

package/_src/collection/compat/Record/instances.ts

@@ -100,4 +100,3 @@ export function deriveDecoder<A extends Record<string, any>>(
     return These.right(res as A);
   }, `Record<string, ${valueDecoder.label}>`);
 }
-

package/_src/collection/compat.ts

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

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

@@ -32,7 +32,7 @@ export interface ConcF extends HKT {
  * @tsplus companion fncts.ConcOps
  */
 export abstract class Conc<A> implements Iterable<A>, Hashable, Equatable {
-  readonly _A!: () => A;
+  declare _A: () => A;
 
   readonly _typeId: ConcTypeId = ConcTypeId;
   abstract readonly length: number;
@@ -43,19 +43,19 @@ export abstract class Conc<A> implements Iterable<A>, Hashable, Equatable {
   }
 
   [Symbol.equals](that: unknown): boolean {
-    return Conc.isConc(that) && (this as Conc<A>).corresponds(that, Equatable.strictEquals);
+    return Conc.is(that) && (this as Conc<A>).corresponds(that, Equatable.strictEquals);
   }
 }
 
 abstract class ConcImplementation<A> implements Iterable<A> {
   readonly _typeId: ConcTypeId = ConcTypeId;
-  readonly _A!: () => A;
+  declare _A: () => A;
   get [Symbol.hash](): number {
     return Hashable.iterator(this[Symbol.iterator]());
   }
 
   [Symbol.equals](that: unknown): boolean {
-    return Conc.isConc(that) && (this as Conc<A>).corresponds(that, Equatable.strictEquals);
+    return Conc.is(that) && (this as Conc<A>).corresponds(that, Equatable.strictEquals);
   }
 
   abstract readonly length: number;
@@ -108,8 +108,8 @@ abstract class ConcImplementation<A> implements Iterable<A> {
   }
 
   concat<B>(that: ConcImplementation<B>): ConcImplementation<A | B> {
-    concrete<A>(this);
-    concrete<B>(that);
+    concrete(this);
+    concrete(that);
     if (this._tag === ConcTag.Empty) {
       return that;
     }
@@ -126,7 +126,7 @@ abstract class ConcImplementation<A> implements Iterable<A> {
     }
     const diff = that.depth - this.depth;
     if (Math.abs(diff) <= 1) {
-      return new Concat(this, that);
+      return new Concat<A | B>(this, that);
     } else if (diff < -1) {
       if (this.left.depth >= this.right.depth) {
         const nr = this.right.concat(that);
@@ -165,7 +165,7 @@ abstract class ConcImplementation<A> implements Iterable<A> {
     } else if (n >= this.length) {
       return this;
     } else {
-      concrete<A>(this);
+      concrete(this);
       switch (this._tag) {
         case ConcTag.Empty:
           return _Empty;
@@ -267,9 +267,10 @@ export class Empty<A> extends ConcImplementation<A> {
   }
 }
 
-export const _Empty = new Empty<any>();
+export const _Empty = new Empty<never>();
 
 export class Concat<A> extends ConcImplementation<A> {
+  declare _A: () => A;
   readonly _tag = ConcTag.Concat;
 
   length = this.left.length + this.right.length;
@@ -729,7 +730,7 @@ export function fromArray<A>(array: ArrayLike<A>): ConcImplementation<A> {
 }
 
 /**
- * @tsplus static fncts.ConcOps isConc
+ * @tsplus static fncts.ConcOps is
  */
 export function isConc<A>(u: Iterable<A>): u is Conc<A>;
 export function isConc(u: unknown): u is Conc<unknown>;

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

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

package/_src/collection/immutable/Conc.ts

@@ -2,6 +2,7 @@
 export * from "./Conc/api.js";
 export * from "./Conc/constructors.js";
 export * from "./Conc/definition.js";
+export * from "./Conc/derivations.js";
 // codegen:end
 
 // codegen:start { preset: barrel, include: ./Conc/api/*.ts }

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

@@ -538,7 +538,7 @@ export function findLastMapWithIndex_<A, B>(as: ImmutableArray<A>, f: (i: number
 
 /**
  * @tsplus fluent fncts.ImmutableArray foldLeftWithIndex
- * @tsplus fluent fncts.base.MutableArray foldLeftWithIndex
+ * @tsplus fluent fncts.MutableArray foldLeftWithIndex
  */
 export function foldLeftWithIndex_<A, B>(self: ImmutableArray<A>, b: B, f: (i: number, b: B, a: A) => B): B {
   const len = self.length;
@@ -551,7 +551,7 @@ export function foldLeftWithIndex_<A, B>(self: ImmutableArray<A>, b: B, f: (i: n
 
 /**
  * @tsplus fluent fncts.ImmutableArray foldLeft
- * @tsplus fluent fncts.base.MutableArray foldLeft
+ * @tsplus fluent fncts.MutableArray foldLeft
  */
 export function foldLeft_<A, B>(self: ImmutableArray<A>, b: B, f: (b: B, a: A) => B): B {
   return self.foldLeftWithIndex(b, (_, b, a) => f(b, a));
@@ -559,7 +559,7 @@ export function foldLeft_<A, B>(self: ImmutableArray<A>, b: B, f: (b: B, a: A) =
 
 /**
  * @tsplus fluent fncts.ImmutableArray foldLeftWhile
- * @tsplus fluent fncts.base.MutableArray foldLeftWhile
+ * @tsplus fluent fncts.MutableArray foldLeftWhile
  */
 export function foldLeftWhile_<A, B>(self: ImmutableArray<A>, b: B, p: Predicate<B>, f: (b: B, a: A) => B): B {
   return self.foldLeftWithIndexWhile(b, p, (_, b, a) => f(b, a));
@@ -567,7 +567,7 @@ export function foldLeftWhile_<A, B>(self: ImmutableArray<A>, b: B, p: Predicate
 
 /**
  * @tsplus fluent fncts.ImmutableArray foldLeftWithIndexWhile
- * @tsplus fluent fncts.base.MutableArray foldLeftWithIndexWhile
+ * @tsplus fluent fncts.MutableArray foldLeftWithIndexWhile
  */
 export function foldLeftWithIndexWhile_<A, B>(
   self: ImmutableArray<A>,
@@ -661,7 +661,7 @@ export function forEach_<A, B>(self: ImmutableArray<A>, f: (a: A) => B): void {
 
 /**
  * @tsplus fluent fncts.ImmutableArray get
- * @tsplus fluent fncts.base.MutableArray get
+ * @tsplus fluent fncts.MutableArray get
  */
 export function get_<A>(self: ImmutableArray<A>, i: number): Maybe<A> {
   return self.isOutOfBound(i) ? Nothing() : Just(self._array[i]!);
@@ -954,7 +954,7 @@ export function prepend_<A, B>(self: ImmutableArray<A>, head: B): ImmutableArray
 
 /**
  * @tsplus fluent fncts.ImmutableArray prependAll
- * @tsplus fluent fncts.base.MutableArray prependAll
+ * @tsplus fluent fncts.MutableArray prependAll
  */
 export function prependAll_<A>(self: ImmutableArray<A>, a: A): ImmutableArray<A> {
   const out: Array<A> = [];

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

@@ -1,6 +1,6 @@
 /**
- * @tsplus getter fncts.base.ReadonlyArray asImmutableArray
- * @tsplus getter fncts.base.Array asImmutableArray
+ * @tsplus getter fncts.ReadonlyArray asImmutableArray
+ * @tsplus getter fncts.Array asImmutableArray
  */
 export function asImmutableArray<A>(self: ReadonlyArray<A>): ImmutableArray<A> {
   return new ImmutableArray(self);

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

@@ -35,6 +35,9 @@ export class ImmutableArray<A> implements Equatable, Hashable, Iterable<A> {
   }
 }
 
+/**
+ * @tsplus static fncts.ImmutableArrayOps is
+ */
 export function isImmutableArray(u: unknown): u is ImmutableArray<unknown> {
   return hasTypeId(u, ImmutableArrayTypeId);
 }

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 {