@fncts/base 0.0.3 → 0.0.6

package/_src/collection/Iterable/api.ts

@@ -314,43 +314,27 @@ export function foldLeft_<A, B>(self: Iterable<A>, b: B, f: (b: B, a: A) => B):
 }
 
 /**
- * @constrained
+ * @tsplus fluent fncts.Iterable foldMap
  */
-export function foldMap_<M>(M: P.Monoid<M>) {
-  return <A>(self: Iterable<A>, f: (a: A) => M): M => self.foldMapWithIndex(M)((_, a) => f(a));
+export function foldMap_<A, M>(self: Iterable<A>, f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): M {
+  return self.foldMapWithIndex((_, a) => f(a), M);
 }
 
 /**
- * @tsplus getter fncts.Iterable foldMap
+ * @tsplus fluent fncts.Iterable foldMapWithIndex
  */
-export function foldMapSelf<A>(self: Iterable<A>) {
-  return <M>(M: P.Monoid<M>) =>
-    (f: (a: A) => M): M =>
-      self.foldMapWithIndex(M)((_, a) => f(a));
-}
-
-/**
- * @constrained
- */
-export function foldMapWithIndex_<M>(M: P.Monoid<M>) {
-  return <A>(self: Iterable<A>, f: (i: number, a: A) => M): M => {
-    let res = M.nat;
-    let n   = -1;
-    for (const value of self) {
-      n  += 1;
-      res = M.combine_(res, f(n, value));
-    }
-    return res;
-  };
-}
-
-/**
- * @tsplus getter fncts.Iterable foldMapWithIndex
- */
-export function foldMapWithIndexSelf<A>(self: Iterable<A>) {
-  return <M>(M: P.Monoid<M>) =>
-    (f: (i: number, a: A) => M): M =>
-      foldMapWithIndex_(M)(self, f);
+export function foldMapWithIndex_<A, M>(
+  self: Iterable<A>,
+  f: (i: number, a: A) => M,
+  /** @tsplus auto */ M: P.Monoid<M>,
+): M {
+  let res = M.nat;
+  let n   = -1;
+  for (const value of self) {
+    n  += 1;
+    res = M.combine(res, f(n, value));
+  }
+  return res;
 }
 
 /**
@@ -430,6 +414,7 @@ function handlePartitionMap<A, B, C>(
   h: "Left" | "Right",
 ): PartitionHandleResult<B | C> {
   const bc = f(i, a);
+  Either.concrete(bc);
   return h === "Left" && bc._tag === "Left"
     ? { emit: true, value: bc.left }
     : h === "Right" && bc._tag === "Right"
@@ -592,15 +577,16 @@ export function size<A>(self: Iterable<A>): number {
 export function take<A>(self: Iterable<A>, n: number): Iterable<A> {
   return Iterable.make<A>(() => {
     let done       = false;
-    const i        = 0;
+    let i          = 0;
     let value: IteratorResult<A>;
     const iterator = self[Symbol.iterator]();
     return {
       next() {
-        if (done || i > n) {
+        if (done || i >= n) {
           return this.return!();
         }
         value = iterator.next();
+        i++;
         if (value.done) {
           this.return!();
         }

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

@@ -8,7 +8,7 @@ export function elem<A>(self: ReadonlyArray<A>) {
   return (eq: Eq<A>) =>
     (a: A): boolean => {
       for (let i = 0; i < self.length; i++) {
-        if (eq.equals_(self[i]!, a)) {
+        if (eq.equals(self[i]!, a)) {
           return true;
         }
       }

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

@@ -1,5 +1,6 @@
 import type { Concat, ConcF } from "@fncts/base/collection/immutable/Conc/definition";
 import type { Eq } from "@fncts/base/typeclass";
+import type * as P from "@fncts/base/typeclass";
 
 import {
   _Empty,
@@ -13,7 +14,6 @@ import {
 import { EitherTag } from "@fncts/base/data/Either";
 import { identity, tuple } from "@fncts/base/data/function";
 import { Stack } from "@fncts/base/internal/Stack";
-import * as P from "@fncts/base/typeclass";
 
 /**
  * @tsplus fluent fncts.Conc align
@@ -103,6 +103,7 @@ export function chainRecDepthFirst<A, B>(a: A, f: (a: A) => Conc<Either<A, B>>):
   while (buffer.length > 0) {
     const e = buffer.unsafeHead;
     buffer  = buffer.unsafeTail;
+    Either.concrete(e);
     if (e._tag === EitherTag.Left) {
       buffer = f(e.left).concat(buffer);
     } else {
@@ -122,6 +123,7 @@ export function chainRecBreadthFirst<A, B>(a: A, f: (a: A) => Conc<Either<A, B>>
   let out       = Conc.empty<B>();
 
   function go(e: Either<A, B>): void {
+    Either.concrete(e);
     if (e._tag === EitherTag.Left) {
       f(e.left).forEach((ab) => ((buffer = buffer.append(ab)), undefined));
     } else {
@@ -211,12 +213,10 @@ export function concat_<A, B>(self: Conc<A>, that: Conc<B>): Conc<A | B> {
 }
 
 /**
- * @tsplus getter fncts.Conc elem
+ * @tsplus fluent fncts.Conc elem
  */
-export function elem_<A>(self: Conc<A>) {
-  return (E: Eq<A>) =>
-    (a: A): boolean =>
-      self.exists((el) => E.equals_(el, a));
+export function elem_<A>(self: Conc<A>, a: A, /** @tsplus auto */ E: Eq<A>): boolean {
+  return self.exists((el) => E.equals(el, a));
 }
 
 /**
@@ -458,36 +458,17 @@ export function foldLeftWithIndex_<A, B>(self: Conc<A>, b: B, f: (i: number, b:
 }
 
 /**
- * @constrained
+ * @tsplus fluent fncts.Conc foldMap
  */
-export function foldMap_<M>(M: P.Monoid<M>) {
-  return <A>(fa: Conc<A>, f: (a: A) => M) => fa.foldMapWithIndex(M)((_, a) => f(a));
+export function foldMap_<A, M>(fa: Conc<A>, f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): M {
+  return fa.foldMapWithIndex((_, a) => f(a), M);
 }
 
 /**
- * @tsplus getter fncts.Conc foldMap
+ * @tsplus fluent fncts.Conc foldMapWithIndex
  */
-export function foldMapSelf<A>(self: Conc<A>) {
-  return <M>(M: P.Monoid<M>) =>
-    (f: (a: A) => M): M =>
-      self.foldMapWithIndex(M)((_, a) => f(a));
-}
-
-/**
- * @constrained
- */
-export function foldMapWithIndex_<M>(M: P.Monoid<M>) {
-  return <A>(fa: Conc<A>, f: (i: number, a: A) => M): M =>
-    fa.foldLeftWithIndex(M.nat, (i, b, a) => M.combine_(b, f(i, a)));
-}
-
-/**
- * @tsplus getter fncts.Conc foldMapWithIndex
- */
-export function foldMapWithIndexSelf<A>(self: Conc<A>) {
-  return <M>(M: P.Monoid<M>) =>
-    (f: (i: number, a: A) => M): M =>
-      foldMapWithIndex_(M)(self, f);
+export function foldMapWithIndex_<A, M>(fa: Conc<A>, f: (i: number, a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): M {
+    return fa.foldLeftWithIndex(M.nat, (i, b, a) => M.combine(b, f(i, a)));
 }
 
 /**
@@ -593,7 +574,7 @@ export function map_<A, B>(self: Conc<A>, f: (a: A) => B): Conc<B> {
  *
  * @tsplus fluent fncts.Conc mapAccum
  */
-export function mapAccum_<A, S, B>(self: Conc<A>, s: S, f: (s: S, a: A) => readonly [B, S]): readonly [Conc<B>, S] {
+export function mapAccum_<A, S, B>(self: Conc<A>, s: S, f: (s: S, a: A) => readonly [S, B]): readonly [S, Conc<B>] {
   concrete(self);
   const iterator = self.arrayIterator();
   const out      = builder<B>();
@@ -605,11 +586,11 @@ export function mapAccum_<A, S, B>(self: Conc<A>, s: S, f: (s: S, a: A) => reado
     for (let i = 0; i < length; i++) {
       const a   = array[i]!;
       const tup = f(state, a);
-      out.append(tup[0]);
-      state = tup[1];
+      out.append(tup[1]);
+      state = tup[0];
     }
   }
-  return tuple(out.result(), s);
+  return tuple(s, out.result());
 }
 
 function mapArrayLike<A, B>(as: ArrayLike<A>, len: number, startIndex: number, f: (i: number, a: A) => B): Conc<B> {
@@ -980,22 +961,21 @@ export function takeWhile_<A>(self: Conc<A>, p: Predicate<A>): Conc<A> {
   }
 }
 
-export const traverse_: P.traverse_<ConcF> = (A) => (ta, f) => traverseWithIndex_(A)(ta, (_, a) => f(a));
-
 /**
- * @tsplus getter fncts.Conc traverse
+ * @tsplus fluent fncts.Conc traverse
  */
-export const traverseSelf: P.traverseSelf<ConcF> = (ta) => (A) => (f) => traverseWithIndex_(A)(ta, (_, a) => f(a));
-
-export const traverseWithIndex_: P.traverseWithIndex_<ConcF> = P.mkTraverseWithIndex_<ConcF>()(
-  (_) => (A) => (ta, f) =>
-    ta.foldLeftWithIndex(A.pure(Conc.empty()), (i, fbs, a) => A.zipWith_(fbs, f(i, a), (bs, b) => bs.append(b))),
-);
+export const traverse: P.Traversable<ConcF>["traverse"] = (self, f, G) => self.traverseWithIndex((_, a) => f(a), G);
 
 /**
- * @tsplus getter fncts.Conc traverseWithIndex
+ * @tsplus fluent fncts.Conc traverseWithIndex
  */
-export const traverseSelfWithIndex: P.traverseWithIndexSelf<ConcF> = (ta) => (A) => (f) => traverseWithIndex_(A)(ta, f);
+export function traverseWithIndex<G extends HKT, KG, QG, WG, XG, IG, SG, RG, EG, A, B>(
+  self: Conc<A>,
+  f: (i: number, a: A) => HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, B>,
+  /** @tsplus auto */ G: P.Applicative<G>,
+): HKT.Kind<G, KG, QG, WG, XG, IG, SG, RG, EG, Conc<B>> {
+  return self.foldLeftWithIndex(G.pure(Conc.empty()), (i, fbs, a) => fbs.zipWith(f(i, a), (bs, b) => bs.append(b), G));
+}
 
 /**
  * @tsplus fluent fncts.ConcOps unfold

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

@@ -1,10 +1,5 @@
 import { Iterable } from "../../Iterable/definition.js";
 
-export interface ConcF extends HKT {
-  readonly type: Conc<this["A"]>;
-  readonly index: number;
-}
-
 export const BUFFER_SIZE = 64;
 
 export const UPDATE_BUFFER_SIZE = 256;
@@ -24,13 +19,19 @@ export const enum ConcTag {
   ByteChunk = "ByteChunk",
 }
 
+export interface ConcF extends Conc<any> {}
+
 /**
  * @tsplus type fncts.Conc
  * @tsplus companion fncts.ConcOps
  */
 export abstract class Conc<A> implements Iterable<A>, Hashable, Equatable {
+  [HKT.F]?: ConcF;
+  [HKT.A]?: () => A;
+  [HKT.T]?: Conc<HKT._A<this>>;
+  [HKT.Ix]?: number;
+
   readonly _typeId: ConcTypeId = ConcTypeId;
-  readonly _A!: () => A;
   abstract readonly length: number;
   abstract [Symbol.iterator](): Iterator<A>;
 
@@ -43,7 +44,17 @@ export abstract class Conc<A> implements Iterable<A>, Hashable, Equatable {
   }
 }
 
-abstract class ConcImplementation<A> extends Conc<A> {
+abstract class ConcImplementation<A> implements Iterable<A> {
+
+  readonly _typeId: ConcTypeId = ConcTypeId;
+  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);
+  }
+
   abstract readonly length: number;
   abstract readonly binary: boolean;
   abstract get(n: number): A;
@@ -309,7 +320,7 @@ class AppendN<A> extends ConcImplementation<A> {
   }
 
   [Symbol.iterator](): Iterator<A> {
-    return this.start.asIterable.concat(this.buffer).take(this.bufferUsed)[Symbol.iterator]() as Iterator<A>;
+    return this.start.asIterable.concat(this.buffer.asIterable.take(this.bufferUsed))[Symbol.iterator]() as Iterator<A>;
   }
 
   append<A1>(a: A1): ConcImplementation<A | A1> {

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

@@ -1,5 +1,5 @@
 interface DictionaryN extends HKT {
-  readonly type: Dictionary<this["A"]>;
+  readonly [HKT.T]: Dictionary<HKT._A<this>>;
 }
 
 /**

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

@@ -55,12 +55,12 @@ export function makeDefault<K, V>(): HashMap<K, V> {
  *
  * @tsplus fluent fncts.HashMapOps fromFoldable
  */
-export function fromFoldable<F extends HKT, C, K, A>(config: P.HashEq<K>, S: P.Semigroup<A>, F: P.Foldable<F, C>) {
-  return <K_, Q, W, X, I, S, R, E>(fka: HKT.Kind<F, C, K_, Q, W, X, I, S, R, E, readonly [K, A]>): HashMap<K, A> => {
-    return F.foldLeft_(fka, makeWith(config), (b, [k, a]) => {
+export function fromFoldable<F extends HKT, C, K, A>(config: P.HashEq<K>, S: P.Semigroup<A>, F: P.Foldable<F>) {
+  return <K_, Q, W, X, I, S, R, E>(fka: HKT.Kind<F, K_, Q, W, X, I, S, R, E, readonly [K, A]>): HashMap<K, A> => {
+    return F.foldLeft(fka, makeWith(config), (b, [k, a]) => {
       const oa = b.get(k);
       if (oa.isJust()) {
-        return b.set(k, S.combine_(oa.value, a));
+        return b.set(k, S.combine(oa.value, a));
       } else {
         return b.set(k, a);
       }
@@ -117,7 +117,7 @@ export function has_<K, V>(map: HashMap<K, V>, key: K): boolean {
  */
 export function modifyHash_<K, V>(map: HashMap<K, V>, key: K, hash: number, f: UpdateFn<V>): HashMap<K, V> {
   const size    = { value: map.size };
-  const newRoot = map.root.modify(map.editable ? map.edit : NaN, map.config.equals_, 0, f, hash, key, size);
+  const newRoot = map.root.modify(map.editable ? map.edit : NaN, map.config.equals, 0, f, hash, key, size);
   return setTree(map, newRoot, size.value);
 }
 
@@ -528,31 +528,16 @@ export function foldLeft_<K, V, Z>(map: HashMap<K, V>, z: Z, f: (z: Z, v: V) =>
   return map.foldLeftWithIndex(z, (_, b, a) => f(b, a));
 }
 
-export const traverseWithIndex_: P.traverseWithIndex_<HashMapF> = P.mkTraverseWithIndex_<HashMapF>()(
-  () => (A) => (ta, f) =>
-    foldLeftWithIndex_(ta, A.pure(makeWith(ta.config)), (k, b, a) => A.zipWith_(b, f(k, a), (map, b) => map.set(k, b))),
-);
-
-export const traverseWithIndex: P.traverseWithIndex<HashMapF> = (A) => {
-  const traverseWithIndexA_ = traverseWithIndex_(A);
-  return (f) => (ta) => traverseWithIndexA_(ta, f);
-};
-
 /**
- * @tsplus getter fncts.HashMap traverseWithIndex
+ * @tsplus fluent fncts.HashMap traverseWithIndex
  */
-export const traverseWithIndexSelf: P.traverseWithIndexSelf<HashMapF> = (self) => (A) => (f) =>
-  traverseWithIndex_(A)(self, f);
+export const traverseWithIndex_: P.TraversableWithIndex<HashMapF>["traverseWithIndex"] = (ta, f, G) =>
+  ta.foldLeftWithIndex(G.pure(makeWith(ta.config)), (k, b, a) => b.zipWith(f(k, a), (map, b) => map.set(k, b), G));
 
-export const traverse_: P.traverse_<HashMapF> = (A) => {
-  const traverseWithIndexA_ = traverseWithIndex_(A);
-  return (ta, f) => traverseWithIndexA_(ta, (_, a) => f(a));
-};
-
-export const traverse: P.traverse<HashMapF> = (A) => {
-  const traverseWithIndexA_ = traverseWithIndex_(A);
-  return (f) => (ta) => traverseWithIndexA_(ta, (_, a) => f(a));
-};
+/**
+ * @tsplus fluent fncts.HashMap traverse
+ */
+export const traverse_: P.Traversable<HashMapF>["traverse"] = (ta, f, G) => ta.traverseWithIndex((_, a) => f(a), G);
 
 /**
  * @tsplus fluent fncts.HashMap unsafeGet
@@ -562,69 +547,27 @@ export function unsafeGet_<K, V>(self: HashMap<K, V>, key: K): V | undefined {
 }
 
 /**
- * @tsplus getter fncts.HashMap traverse
- */
-export const traverseSelf: P.traverseSelf<HashMapF> = (self) => (A) => (f) =>
-  traverseWithIndex_(A)(self, (_, a) => f(a));
-
-export const witherWithIndex_: P.witherWithIndex_<HashMapF> = (A) => (wa, f) =>
-  A.map_(wa.traverseWithIndex(A)(f), compact);
-
-export const witherWithIndex: P.witherWithIndex<HashMapF> = (A) => {
-  const witherWithIndexA_ = witherWithIndex_(A);
-  return (f) => (ta) => witherWithIndexA_(ta, f);
-};
-
-/**
- * @tsplus getter fncts.HashMap witherWithIndex
+ * @tsplus fluent fncts.HashMap witherWithIndex
  */
-export const witherWithIndexSelf: P.witherWithIndexSelf<HashMapF> = (self) => (A) => (f) =>
-  witherWithIndex_(A)(self, f);
-
-export const wither_: P.wither_<HashMapF> = (A) => {
-  const witherWithIndexA_ = witherWithIndex_(A);
-  return (wa, f) => witherWithIndexA_(wa, (_, a) => f(a));
-};
-
-export const wither: P.wither<HashMapF> = (A) => {
-  const witherWithIndexA_ = witherWithIndex_(A);
-  return (f) => (wa) => witherWithIndexA_(wa, (_, a) => f(a));
-};
+export const witherWithIndex_: P.WitherableWithIndex<HashMapF>["witherWithIndex"] = (wa, f, G) =>
+  wa.traverseWithIndex(f, G).map(compact, G);
 
 /**
- * @tsplus getter fncts.HashMap wither
+ * @tsplus fluent fncts.HashMap wither
  */
-export const witherSelf: P.witherSelf<HashMapF> = (self) => (A) => (f) => self.witherWithIndex(A)((_, a) => f(a));
-
-export const wiltWithIndex_: P.wiltWithIndex_<HashMapF> = (A) => {
-  const traverseWithIndexA_ = traverseWithIndex_(A);
-  return (wa, f) => traverseWithIndexA_(wa, f).via(A.map(separate));
-};
-
-export const wiltWithIndex: P.wiltWithIndex<HashMapF> = (A) => {
-  const wiltWithIndexA_ = wiltWithIndex_(A);
-  return (f) => (wa) => wiltWithIndexA_(wa, f);
-};
+export const wither_: P.Witherable<HashMapF>["wither"] = (wa, f, G) => wa.witherWithIndex((_, a) => f(a), G);
 
 /**
- * @tsplus getter fncts.HashMap wiltWithIndex
+ * @tsplus fluent fncts.HashMap wiltWithIndex
  */
-export const wiltWithIndexSelf: P.wiltWithIndexSelf<HashMapF> = (self) => (A) => (f) => wiltWithIndex_(A)(self, f);
-
-export const wilt_: P.wilt_<HashMapF> = (A) => {
-  const wiltWithIndexA_ = wiltWithIndex_(A);
-  return (wa, f) => wiltWithIndexA_(wa, (_, a) => f(a));
-};
-
-export const wilt: P.wilt<HashMapF> = (A) => {
-  const wiltWithIndexA_ = wiltWithIndex_(A);
-  return (f) => (wa) => wiltWithIndexA_(wa, (_, a) => f(a));
-};
+export const wiltWithIndex_: P.WitherableWithIndex<HashMapF>["wiltWithIndex"] = (wa, f, G) =>
+  wa.traverseWithIndex(f, G).map(separate, G);
 
 /**
- * @tsplus getter fncts.HashMap wilt
+ * @tsplus fluent fncts.HashMap wilt
  */
-export const wiltSelf: P.wiltSelf<HashMapF> = (self) => (A) => (f) => self.wiltWithIndex(A)((_, a) => f(a));
+export const wilt_: P.Witherable<HashMapF>["wilt"] = (wa, f, G) =>
+  wa.wiltWithIndex((_, a) => f(a), G);
 
 /**
  * @tsplus fluent fncts.HashMap unionWith
@@ -688,7 +631,7 @@ function setTree<K, V>(map: HashMap<K, V>, newRoot: Node<K, V>, newSize: number)
 function tryGetHash<K, V>(map: HashMap<K, V>, key: K, hash: number): Maybe<V> {
   let node    = map.root;
   let shift   = 0;
-  const keyEq = map.config.equals_;
+  const keyEq = map.config.equals;
 
   // eslint-disable-next-line no-constant-condition
   while (true) {

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

@@ -4,21 +4,18 @@ import type { HashEq } from "@fncts/base/typeclass";
 import { isEmptyNode } from "@fncts/base/collection/immutable/HashMap/internal";
 import { identity, tuple } from "@fncts/base/data/function";
 
-export interface HashMapF extends HKT {
-  readonly type: HashMap<this["K"], this["A"]>;
-  readonly variance: {
-    K: "_";
-    A: "+";
-  };
-}
+export interface HashMapF extends HashMap<any, any> {}
 
 /**
  * @tsplus type fncts.HashMap
  * @tsplus companion fncts.HashMapOps
  */
 export class HashMap<K, V> implements Iterable<readonly [K, V]>, Hashable, Equatable {
-  readonly _K!: () => K;
-  readonly _V!: () => V;
+  readonly [HKT.F]!: HashMapF;
+  readonly [HKT.K]!: () => K;
+  readonly [HKT.A]!: () => V;
+  readonly [HKT.T]!: HashMap<HKT._K<this>, HKT._A<this>>;
+  readonly [HKT.Ix]!: K;
 
   constructor(
     public editable: boolean,
@@ -55,6 +52,7 @@ export class HashMapIterator<K, V, T> implements IterableIterator<T> {
   }
 
   next(): IteratorResult<T> {
+    this.v.concrete();
     if (this.v.isNothing()) {
       return { done: true, value: undefined };
     }

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

@@ -133,7 +133,7 @@ export function canEditNode<K, V>(edit: number, node: Node<K, V>): boolean {
   return isEmptyNode(node) ? false : edit === node.edit;
 }
 
-export type KeyEq<K> = Eq<K>["equals_"];
+export type KeyEq<K> = Eq<K>["equals"];
 
 export type UpdateFn<V> = (v: Maybe<V>) => Maybe<V>;
 

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

@@ -169,7 +169,7 @@ export function flatMapDefault<A, B>(self: HashSet<A>, f: (a: A) => Iterable<B>)
  */
 export function getEq<A>(): P.Eq<HashSet<A>> {
   return P.Eq({
-    equals_: (x, y) => {
+    equals: (x, y) => {
       if (y === x) {
         return true;
       }
@@ -406,7 +406,7 @@ export function union_<A>(l: HashSet<A>, r: Iterable<A>): HashSet<A> {
 export function toArray_<A>(set: HashSet<A>, O: P.Ord<A>): ReadonlyArray<A> {
   const r: Array<A> = [];
   set.forEach((a) => r.push(a));
-  return r.sort(O.compare_);
+  return r.sort(O.compare);
 }
 
 /*
@@ -426,14 +426,14 @@ function setTree<A>(set: HashSet<A>, newRoot: Node<A>, newSize: number) {
 
 function modifyHash<A>(set: HashSet<A>, value: A, hash: number, remove: boolean): HashSet<A> {
   const size    = { value: set._size };
-  const newRoot = set._root.modify(remove, set._editable ? set._edit : NaN, set.config.equals_, 0, hash, value, size);
+  const newRoot = set._root.modify(remove, set._editable ? set._edit : NaN, set.config.equals, 0, hash, value, size);
   return setTree(set, newRoot, size.value);
 }
 
 function tryGetHash<A>(set: HashSet<A>, value: A, hash: number): Maybe<A> {
   let node  = set._root;
   let shift = 0;
-  const eq  = set.config.equals_;
+  const eq  = set.config.equals;
 
   // eslint-disable-next-line no-constant-condition
   while (true) {

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

@@ -0,0 +1,6 @@
+/**
+ * @tsplus fluent fncts.ImmutableArray chunksOf
+ */
+export function chunksOf_<A>(self: ImmutableArray<A>, n: number): ImmutableArray<ImmutableArray<A>> {
+  return self.chop((as) => as.splitAt(n));
+}

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

@@ -0,0 +1,6 @@
+/**
+ * @tsplus fluent fncts.ImmutableArray slice
+ */
+export function slice_<A>(self: ImmutableArray<A>, start?: number, end?: number): ImmutableArray<A> {
+  return self._array.slice(start, end).asImmutableArray;
+}

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

@@ -0,0 +1,6 @@
+/**
+ * @tsplus fluent fncts.ImmutableArray splitAt
+ */
+export function splitAt_<A>(as: ImmutableArray<A>, n: number): readonly [ImmutableArray<A>, ImmutableArray<A>] {
+  return [as.slice(0, n), as.slice(n)];
+}

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

@@ -0,0 +1,18 @@
+/**
+ * @tsplus fluent fncts.ImmutableArray splitWhere
+ */
+export function splitWhere_<A>(
+  self: ImmutableArray<A>,
+  p: Predicate<A>,
+): readonly [ImmutableArray<A>, ImmutableArray<A>] {
+  let cont = true;
+  let i    = 0;
+  while (cont && i < self.length) {
+    if (p(self._array[i]!)) {
+      cont = false;
+    } else {
+      i++;
+    }
+  }
+  return self.splitAt(i);
+}