@fncts/base 0.0.12 → 0.0.15

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

@@ -174,8 +174,8 @@ export function crossWith_<A, B, C>(
 export function cross_<A, B>(
   self: ImmutableNonEmptyArray<A>,
   fb: ImmutableNonEmptyArray<B>,
-): ImmutableNonEmptyArray<readonly [A, B]> {
-  return self.crossWith(fb, (a, b) => [a, b]);
+): ImmutableNonEmptyArray<Zipped.Make<A, B>> {
+  return self.crossWith(fb, (a, b) => Zipped(a, b));
 }
 
 /**
@@ -394,19 +394,21 @@ export function sort<A>(self: ImmutableNonEmptyArray<A>, /** @tsplus auto */ O:
 }
 
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray traverseWithIndex
+ * @tsplus getter fncts.ImmutableNonEmptyArray traverseWithIndex
  */
-export const traverseWithIndex_: P.TraversableWithIndex<ImmutableNonEmptyArrayF>["traverseWithIndex"] = (self, f, G) =>
-  self.tail.foldLeftWithIndex(
-    f(0, self.head).map((b) => ImmutableNonEmptyArray(b), G),
-    (i, fbs, a) => fbs.zipWith(f(i + 1, a), (bs, b) => bs.append(b), G),
-  );
+export const traverseWithIndex = P.TraversableWithIndex.makeTraverseWithIndex<ImmutableNonEmptyArrayF>()(
+  () => (self) => (G) => (f) =>
+    self.tail.foldLeftWithIndex(
+      G.map(f(0, self.head), (b) => ImmutableNonEmptyArray(b)),
+      (i, fbs, a) => G.zipWith(fbs, f(i + 1, a), (bs, b) => bs.append(b)),
+    ),
+);
 
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray traverse
+ * @tsplus getter fncts.ImmutableNonEmptyArray traverse
  */
-export const traverse_: P.Traversable<ImmutableNonEmptyArrayF>["traverse"] = (self, f, A) =>
-  self.traverseWithIndex((_, a) => f(a), A);
+export const traverse: P.Traversable<ImmutableNonEmptyArrayF>["traverse"] = (self) => (G) => (f) =>
+  self.traverseWithIndex(G)((_, a) => f(a));
 
 /**
  * @tsplus fluent fncts.ImmutableNonEmptyArray uniq

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

@@ -1,28 +1,33 @@
 import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
 
-export interface ImmutableNonEmptyArrayF extends ImmutableNonEmptyArray<any> {}
+export interface ImmutableNonEmptyArrayF extends HKT {
+  type: ImmutableNonEmptyArray<this["A"]>;
+  variance: {
+    A: "+";
+  };
+  index: number;
+}
 
 /**
  * @tsplus type fncts.ImmutableNonEmptyArray
  * @tsplus companion fncts.ImmutableNonEmptyArrayOps
  */
 export class ImmutableNonEmptyArray<A> extends ImmutableArray<A> {
-  [HKT.F]!: ImmutableNonEmptyArrayF;
-  [HKT.T]!: ImmutableNonEmptyArray<HKT._A<this>>;
+  readonly _A!: () => A;
   constructor(readonly _array: ReadonlyNonEmptyArray<A>) {
     super(_array);
   }
 }
 
 /**
- * @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/instances.ts

@@ -4,7 +4,6 @@ import type * as P from "@fncts/base/typeclass";
 import {
   align_,
   alignWith_,
-  ap_,
   cross_,
   crossWith_,
   flatMap_,
@@ -14,92 +13,92 @@ import {
   foldRightWithIndex_,
   map_,
   mapWithIndex_,
-  traverse_,
-  traverseWithIndex_,
+  traverse,
+  traverseWithIndex,
 } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api";
 import { make } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/constructors";
 
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Semialign
  */
-export const Semialign: P.Semialign<ImmutableNonEmptyArrayF> = {
+export const Semialign = HKT.instance<P.Semialign<ImmutableNonEmptyArrayF>>({
   map: map_,
   alignWith: alignWith_,
-};
+});
 
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Functor
  */
-export const Functor: P.Functor<ImmutableNonEmptyArrayF> = {
+export const Functor = HKT.instance<P.Functor<ImmutableNonEmptyArrayF>>({
   map: map_,
-};
+});
 
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps FunctorWithIndex
  */
-export const FunctorWithIndex: P.FunctorWithIndex<ImmutableNonEmptyArrayF> = {
+export const FunctorWithIndex = HKT.instance<P.FunctorWithIndex<ImmutableNonEmptyArrayF>>({
   map: map_,
   mapWithIndex: mapWithIndex_,
-};
+});
 
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Apply
  */
-export const Apply: P.Apply<ImmutableNonEmptyArrayF> = {
+export const Apply = HKT.instance<P.Apply<ImmutableNonEmptyArrayF>>({
   ...Functor,
   zip: cross_,
   zipWith: crossWith_,
-};
+});
 
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Applicative
  */
-export const Applicative: P.Applicative<ImmutableNonEmptyArrayF> = {
+export const Applicative = HKT.instance<P.Applicative<ImmutableNonEmptyArrayF>>({
   ...Apply,
   pure: make,
-};
+});
 
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Monad
  */
-export const Monad: P.Monad<ImmutableNonEmptyArrayF> = {
+export const Monad = HKT.instance<P.Monad<ImmutableNonEmptyArrayF>>({
   ...Applicative,
   flatMap: flatMap_,
-};
+});
 
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Foldable
  */
-export const Foldable: P.Foldable<ImmutableNonEmptyArrayF> = {
+export const Foldable = HKT.instance<P.Foldable<ImmutableNonEmptyArrayF>>({
   foldLeft: foldLeft_,
   foldRight: foldRight_,
-};
+});
 
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps FoldableWithIndex
  */
-export const FoldableWithIndex: P.FoldableWithIndex<ImmutableNonEmptyArrayF> = {
+export const FoldableWithIndex = HKT.instance<P.FoldableWithIndex<ImmutableNonEmptyArrayF>>({
   ...Foldable,
   foldLeftWithIndex: foldLeftWithIndex_,
   foldRightWithIndex: foldRightWithIndex_,
-};
+});
 
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Traversable
  */
-export const Traversable: P.Traversable<ImmutableNonEmptyArrayF> = {
+export const Traversable = HKT.instance<P.Traversable<ImmutableNonEmptyArrayF>>({
   ...Functor,
   ...Foldable,
-  traverse: traverse_,
-};
+  traverse: traverse,
+});
 
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps TraversableWithIndex
  */
-export const TraversableWithIndex: P.TraversableWithIndex<ImmutableNonEmptyArrayF> = {
+export const TraversableWithIndex = HKT.instance<P.TraversableWithIndex<ImmutableNonEmptyArrayF>>({
   ...Functor,
   ...FunctorWithIndex,
   ...FoldableWithIndex,
   ...Traversable,
-  traverseWithIndex: traverseWithIndex_,
-};
+  traverseWithIndex: traverseWithIndex,
+});

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/RoseTree/definition.ts

@@ -1,7 +1,12 @@
 export const RoseTreeTypeId = Symbol.for("fncts.RoseTree");
 export type RoseTreeTypeId = typeof RoseTreeTypeId;
 
-export interface RoseTreeF extends RoseTree<any> {}
+export interface RoseTreeF extends HKT {
+  type: RoseTree<this["A"]>;
+  variance: {
+    A: "+";
+  };
+}
 
 /**
  * @tsplus type fncts.RoseTree
@@ -9,9 +14,7 @@ export interface RoseTreeF extends RoseTree<any> {}
  */
 export class RoseTree<A> implements Hashable, Equatable {
   readonly _typeId: RoseTreeTypeId = RoseTreeTypeId;
-  readonly [HKT.F]!: RoseTreeF;
-  readonly [HKT.A]!: () => A;
-  readonly [HKT.T]!: RoseTree<HKT._A<this>>;
+  declare _A: () => A;
   constructor(readonly value: A, readonly forest: Vector<RoseTree<A>>) {}
   [Symbol.equals](that: unknown): boolean {
     return isRoseTree(that) ? Equatable.strictEquals(this.value, that.value) && this.forest == that.forest : false;

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

@@ -1,6 +1,6 @@
 /* eslint-disable prefer-const */
 import type { MutableVector, VectorF } from "@fncts/base/collection/immutable/Vector/definition";
-import type { Eq, Monoid, Ord, Ordering, Traversable, TraversableWithIndex } from "@fncts/base/typeclass";
+import type { Eq, Monoid, Ord, Ordering, Traversable } from "@fncts/base/typeclass";
 
 import {
   affixPush,
@@ -48,6 +48,7 @@ import {
   updateNode,
   zeroOffset,
 } from "@fncts/base/collection/immutable/Vector/internal";
+import { TraversableWithIndex } from "@fncts/base/typeclass";
 
 /**
  * Appends an element to the end of a Vector and returns the new Vector.
@@ -1201,27 +1202,22 @@ export function toList<A>(self: Vector<A>): List<A> {
 }
 
 /**
- * @tsplus fluent fncts.Vector traverseWithIndex
+ * @tsplus getter fncts.Vector traverseWithIndex
  */
-export const traverseWithIndex: TraversableWithIndex<VectorF>["traverseWithIndex"] = (self, f, G) => {
+export const traverseWithIndex = TraversableWithIndex.makeTraverseWithIndex<VectorF>()(() => (self) => (G) => (f) => {
   return self.foldLeftWithIndex(G.pure(Vector.emptyPushable()), (i, b, a) =>
-    b.zipWith(
-      f(i, a),
-      (v, b) => {
-        push(v, b);
-        return v;
-      },
-      G,
-    ),
+    G.zipWith(b, f(i, a), (v, b) => {
+      push(v, b);
+      return v;
+    }),
   );
-};
+});
 
 /**
- * @tsplus fluent fncts.Vector traverse
+ * @tsplus getter fncts.Vector traverse
  */
-export const traverse: Traversable<VectorF>["traverse"] = (self, f, G) => {
-  return self.traverseWithIndex((_, a) => f(a));
-};
+export const traverse: Traversable<VectorF>["traverse"] = (self) => (G) => (f) =>
+  self.traverseWithIndex(G)((_, a) => f(a));
 
 /**
  * Returns a new Vector without repeated elements by using the given

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

@@ -8,7 +8,13 @@ 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> {}
+export interface VectorF extends HKT {
+  type: Vector<this["A"]>;
+  variance: {
+    A: "+";
+  };
+  index: number;
+}
 
 /**
  * Represents a Vector of elements.
@@ -18,10 +24,7 @@ export interface VectorF extends Vector<any> {}
  */
 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;
+  readonly _A!: () => A;
   constructor(
     /** @private */
     readonly bits: number,
@@ -50,14 +53,11 @@ export class Vector<A> implements Iterable<A> {
 }
 
 /**
- * @tsplus type fncts.base.MutableVector
+ * @tsplus type fncts.MutableVector
  */
 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;
+  readonly _A: () => A;
   bits: number;
   offset: number;
   length: number;

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/IterableWeakMap.ts

@@ -1,7 +1,7 @@
 /**
  * @tsplus type fncts.IterableWeakMap
  */
-export class IterableWeakMap<K extends object, V> implements Iterable<readonly [K, V]> {
+export class IterableWeakMap<K extends object, V> implements Iterable<readonly [K, V]>, Map<K, V> {
   private weakMap           = new WeakMap<K, { value: V; ref: WeakRef<K> }>();
   private refSet            = new Set<WeakRef<K>>();
   private finalizationGroup = new FinalizationRegistry<{ ref: WeakRef<K>; set: Set<WeakRef<K>> }>(
@@ -44,11 +44,48 @@ export class IterableWeakMap<K extends object, V> implements Iterable<readonly [
     return true;
   }
 
-  [Symbol.iterator](this: this): IterableIterator<readonly [K, V]> {
+  has(this: this, key: K): boolean {
+    return this.weakMap.has(key);
+  }
+
+  clear(): void {
+    for (const ref of this.refSet) {
+      const key = ref.deref();
+      if (!key) continue;
+      const entry = this.weakMap.get(key)!;
+      this.weakMap.delete(key);
+      this.refSet.delete(entry.ref);
+      this.finalizationGroup.unregister(entry.ref);
+    }
+    this.refSet.clear();
+  }
+
+  forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: IterableWeakMap<K, V>): void {
+    thisArg = thisArg ?? this;
+    for (const kv of this) {
+      callbackfn(kv[1], kv[0], thisArg);
+    }
+  }
+
+  get size(): number {
+    let n = 0;
+    for (const ref of this.refSet) {
+      const key = ref.deref();
+      if (!key) continue;
+      n++;
+    }
+    return n;
+  }
+
+  [Symbol.iterator](this: this): IterableIterator<[K, V]> {
     return this.entries();
   }
 
-  *entries(this: this): IterableIterator<readonly [K, V]> {
+  get [Symbol.toStringTag](): string {
+    return this.weakMap[Symbol.toStringTag];
+  }
+
+  *entries(this: this): IterableIterator<[K, V]> {
     for (const ref of this.refSet) {
       const key = ref.deref();
       if (!key) continue;
@@ -57,7 +94,15 @@ export class IterableWeakMap<K extends object, V> implements Iterable<readonly [
     }
   }
 
-  has(this: this, key: K): boolean {
-    return this.weakMap.has(key);
+  *keys(this: this): IterableIterator<K> {
+    for (const [key] of this) {
+      yield key;
+    }
+  }
+
+  *values(): IterableIterator<V> {
+    for (const [, value] of this) {
+      yield value;
+    }
   }
 }

package/_src/collection/weak/IterableWeakSet.ts

@@ -1,7 +1,7 @@
 /**
  * @tsplus type fncts.IterableWeakSet
  */
-export class IterableWeakSet<A extends object> implements Iterable<A> {
+export class IterableWeakSet<A extends object> implements Iterable<A>, Set<A> {
   private weakMap           = new WeakMap<A, { ref: WeakRef<A> }>();
   private refSet            = new Set<WeakRef<A>>();
   private finalizationGroup = new FinalizationRegistry<{ ref: WeakRef<A>; set: Set<WeakRef<A>> }>(
@@ -12,9 +12,11 @@ export class IterableWeakSet<A extends object> implements Iterable<A> {
     set.delete(ref);
   }
 
-  constructor(iterable: Iterable<A>) {
-    for (const value of iterable) {
-      this.add(value);
+  constructor(iterable?: Iterable<A>) {
+    if (iterable) {
+      for (const value of iterable) {
+        this.add(value);
+      }
     }
   }
 
@@ -35,14 +37,52 @@ export class IterableWeakSet<A extends object> implements Iterable<A> {
 
     this.weakMap.delete(value);
     this.refSet.delete(entry.ref);
+    this.finalizationGroup.unregister(entry.ref);
     return true;
   }
 
-  [Symbol.iterator](this: this): IterableIterator<A> {
-    return this.entries();
+  has(this: this, value: A): boolean {
+    return this.weakMap.has(value);
+  }
+
+  keys(): IterableIterator<A> {
+    return this[Symbol.iterator]();
+  }
+
+  values(): IterableIterator<A> {
+    return this[Symbol.iterator]();
+  }
+
+  forEach(f: (value: A, value2: A, set: Set<A>) => void, thisArg?: Set<A>): void {
+    thisArg = thisArg ?? this;
+    for (const value of this) {
+      f(value, value, thisArg);
+    }
   }
 
-  *entries(this: this): IterableIterator<A> {
+  clear(): void {
+    for (const ref of this.refSet) {
+      const key = ref.deref();
+      if (!key) continue;
+      const entry = this.weakMap.get(key)!;
+      this.weakMap.delete(key);
+      this.refSet.delete(entry.ref);
+      this.finalizationGroup.unregister(entry.ref);
+    }
+    this.refSet.clear();
+  }
+
+  get size(): number {
+    let n = 0;
+    for (const ref of this.refSet) {
+      const value = ref.deref();
+      if (!value) continue;
+      n++;
+    }
+    return n;
+  }
+
+  *[Symbol.iterator](this: this): IterableIterator<A> {
     for (const ref of this.refSet) {
       const key = ref.deref();
       if (!key) continue;
@@ -50,7 +90,15 @@ export class IterableWeakSet<A extends object> implements Iterable<A> {
     }
   }
 
-  has(this: this, value: A): boolean {
-    return this.weakMap.has(value);
+  get [Symbol.toStringTag]() {
+    return this.refSet[Symbol.toStringTag];
+  }
+
+  *entries(this: this): IterableIterator<[A, A]> {
+    for (const ref of this.refSet) {
+      const key = ref.deref();
+      if (!key) continue;
+      yield [key, key];
+    }
   }
 }

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

@@ -38,8 +38,11 @@ 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 zip
+ */
+export function zip_<A, B>(self: Eval<A>, fb: Eval<B>): Eval<Zipped.Make<A, B>> {
+  return self.zipWith(fb, (a, b) => Zipped(a, b));
 }
 
 /**