@fncts/base 0.0.21 → 0.0.23

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

@@ -11,8 +11,8 @@ import { HashEq } from "@fncts/base/typeclass";
  * @tsplus pipeable fncts.HashSet add
  */
 export function add<A>(value: A) {
-  return (set: HashSet<A>): HashSet<A> => {
-    return modifyHash(set, value, set.config.hash(value), false);
+  return (self: HashSet<A>): HashSet<A> => {
+    return modifyHash(self, value, self.config.hash(value), false);
   };
 }
 
@@ -21,8 +21,8 @@ export function add<A>(value: A) {
  *
  * @tsplus getter fncts.HashSet beginMutation
  */
-export function beginMutation<K>(set: HashSet<K>): HashSet<K> {
-  return new HashSet(true, set._edit + 1, set.config, set._root, set._size);
+export function beginMutation<K>(self: HashSet<K>): HashSet<K> {
+  return new HashSet(true, self._edit + 1, self.config, self._root, self._size);
 }
 
 /**
@@ -30,9 +30,9 @@ export function beginMutation<K>(set: HashSet<K>): HashSet<K> {
  *
  * @tsplus getter fncts.HashSet endMutation
  */
-export function endMutation<K>(set: HashSet<K>): HashSet<K> {
-  set._editable = false;
-  return set;
+export function endMutation<K>(self: HashSet<K>): HashSet<K> {
+  self._editable = false;
+  return self;
 }
 
 /**
@@ -41,8 +41,8 @@ export function endMutation<K>(set: HashSet<K>): HashSet<K> {
  * @tsplus pipeable fncts.HashSet forEach
  */
 export function forEach<V>(f: (v: V, m: HashSet<V>) => void) {
-  return (map: HashSet<V>): void => {
-    map.foldLeft(undefined as void, (_, value) => f(value, map));
+  return (self: HashSet<V>): void => {
+    self.foldLeft(undefined as void, (_, value) => f(value, self));
   };
 }
 
@@ -50,30 +50,30 @@ export function forEach<V>(f: (v: V, m: HashSet<V>) => void) {
  * @tsplus pipeable fncts.HashSet has
  */
 export function has<A>(value: A) {
-  return (set: HashSet<A>): boolean => {
-    return hasHash(set, value, set.config.hash(value));
+  return (self: HashSet<A>): boolean => {
+    return hasHash(self, value, self.config.hash(value));
   };
 }
 
 /**
- * @tsplus static fncts.HashSetOps make
+ * @tsplus static fncts.HashSetOps emptyWith
  */
-export function make<A>(config: P.Hash<A> & P.Eq<A>): HashSet<A> {
+export function emptyWith<A>(config: HashEq<A>): HashSet<A> {
   return new HashSet(false, 0, config, _EmptyNode, 0);
 }
 
 /**
- * @tsplus static fncts.HashSetOps makeDefault
+ * @tsplus static fncts.HashSetOps empty
  */
-export function makeDefault<A>(): HashSet<A> {
-  return make<A>(P.HashEq.StructuralStrict);
+export function empty<A>(): HashSet<A> {
+  return emptyWith<A>(P.HashEq.StructuralStrict);
 }
 
 /**
- * @tsplus static fncts.HashSetOps fromDefault
+ * @tsplus static fncts.HashSetOps make
  */
-export function fromDefault<A>(...values: ReadonlyArray<A>): HashSet<A> {
-  return makeDefault<A>().mutate((set) => {
+export function make<A>(...values: ReadonlyArray<A>): HashSet<A> {
+  return empty<A>().mutate((set) => {
     values.forEach((v) => {
       set.add(v);
     });
@@ -97,8 +97,8 @@ export function mutate<A>(transient: (set: HashSet<A>) => void) {
  * @tsplus pipeable fncts.HashSet remove
  */
 export function remove<A>(value: A) {
-  return (set: HashSet<A>): HashSet<A> => {
-    return modifyHash(set, value, set.config.hash(value), true);
+  return (self: HashSet<A>): HashSet<A> => {
+    return modifyHash(self, value, self.config.hash(value), true);
   };
 }
 
@@ -107,8 +107,8 @@ export function remove<A>(value: A) {
  *
  * @tsplus getter fncts.HashSet size
  */
-export function size<A>(set: HashSet<A>): number {
-  return set._size;
+export function size<A>(self: HashSet<A>): number {
+  return self._size;
 }
 
 /**
@@ -117,16 +117,16 @@ export function size<A>(set: HashSet<A>): number {
  * @tsplus pipeable fncts.HashSet toggle
  */
 export function toggle<A>(a: A) {
-  return (set: HashSet<A>): HashSet<A> => {
-    return set.has(a) ? set.remove(a) : set.add(a);
+  return (self: HashSet<A>): HashSet<A> => {
+    return self.has(a) ? self.remove(a) : self.add(a);
   };
 }
 
 /**
  * Projects a Set through a function
  */
-export function map<B>(C: P.HashEq<B>): <A>(f: (x: A) => B) => (fa: HashSet<A>) => HashSet<B> {
-  const r = make(C);
+export function mapWith<B>(B: P.HashEq<B>): <A>(f: (a: A) => B) => (self: HashSet<A>) => HashSet<B> {
+  const r = emptyWith(B);
   return (f) => (fa) =>
     r.mutate((r) => {
       fa.forEach((e) => {
@@ -144,17 +144,17 @@ export function map<B>(C: P.HashEq<B>): <A>(f: (x: A) => B) => (fa: HashSet<A>)
  *
  * @tsplus pipeable fncts.HashSet map
  */
-export function mapDefault<A, B>(f: (a: A) => B) {
+export function map<A, B>(f: (a: A) => B) {
   return (self: HashSet<A>): HashSet<B> => {
-    return map(P.HashEq.StructuralStrict as P.HashEq<B>)(f)(self);
+    return mapWith<B>(HashEq.StructuralStrict)(f)(self);
   };
 }
 
 /**
  * Map + Flatten
  */
-export function flatMap<B>(C: P.HashEq<B>): <A>(f: (x: A) => Iterable<B>) => (self: HashSet<A>) => HashSet<B> {
-  const r = make<B>(C);
+export function flatMapWith<B>(C: P.HashEq<B>): <A>(f: (x: A) => Iterable<B>) => (self: HashSet<A>) => HashSet<B> {
+  const r = emptyWith<B>(C);
   return (f) => (self) =>
     r.mutate((r) => {
       self.forEach((e) => {
@@ -171,9 +171,9 @@ export function flatMap<B>(C: P.HashEq<B>): <A>(f: (x: A) => Iterable<B>) => (se
 /**
  * @tsplus pipeable fncts.HashSet flatMap
  */
-export function flatMapDefault<A, B>(f: (a: A) => Iterable<B>) {
+export function flatMap<A, B>(f: (a: A) => Iterable<B>) {
   return (self: HashSet<A>): HashSet<B> => {
-    return flatMap<B>(HashEq.StructuralStrict)(f)(self);
+    return flatMapWith<B>(HashEq.StructuralStrict)(f)(self);
   };
 }
 
@@ -184,7 +184,7 @@ export function flatMapDefault<A, B>(f: (a: A) => Iterable<B>) {
  */
 export function getEq<A>(): P.Eq<HashSet<A>> {
   return P.Eq({
-    equals: (x, y) => {
+    equals: (y) => (x) => {
       if (y === x) {
         return true;
       }
@@ -212,7 +212,7 @@ export function filter<A, B extends A>(refinement: Refinement<A, B>): (set: Hash
 export function filter<A>(predicate: Predicate<A>): (set: HashSet<A>) => HashSet<A>;
 export function filter<A>(predicate: Predicate<A>) {
   return (set: HashSet<A>): HashSet<A> => {
-    const r = make(set.config);
+    const r = emptyWith(set.config);
     return r.mutate((r) => {
       set.forEach((v) => {
         if (predicate(v)) {
@@ -223,9 +223,9 @@ export function filter<A>(predicate: Predicate<A>) {
   };
 }
 
-export function filterMap<B>(B: P.HashEq<B>): <A>(f: (a: A) => Maybe<B>) => (fa: HashSet<A>) => HashSet<B> {
+export function filterMapWith<B>(B: P.HashEq<B>): <A>(f: (a: A) => Maybe<B>) => (fa: HashSet<A>) => HashSet<B> {
   return (f) => (fa) => {
-    const out = beginMutation(make(B));
+    const out = beginMutation(emptyWith(B));
     fa.forEach((a) => {
       const ob = f(a);
       if (ob.isJust()) {
@@ -236,6 +236,13 @@ export function filterMap<B>(B: P.HashEq<B>): <A>(f: (a: A) => Maybe<B>) => (fa:
   };
 }
 
+/**
+ * @tsplus pipeable fncts.HashSet filterMap
+ */
+export function filterMap<A, B>(f: (a: A) => Maybe<B>): (self: HashSet<A>) => HashSet<B> {
+  return filterMapWith<B>(HashEq.StructuralStrict)(f);
+}
+
 /**
  * Partition set values using predicate
  *
@@ -245,8 +252,8 @@ export function partition<A, B extends A>(p: Refinement<A, B>): (self: HashSet<A
 export function partition<A>(p: Predicate<A>): (self: HashSet<A>) => readonly [HashSet<A>, HashSet<A>];
 export function partition<A>(p: Predicate<A>) {
   return (self: HashSet<A>): readonly [HashSet<A>, HashSet<A>] => {
-    const right = beginMutation(make(self.config));
-    const left  = beginMutation(make(self.config));
+    const right = beginMutation(emptyWith(self.config));
+    const left  = beginMutation(emptyWith(self.config));
     self.forEach((v) => {
       if (p(v)) {
         right.add(v);
@@ -261,13 +268,13 @@ export function partition<A>(p: Predicate<A>) {
 /**
  * Partition set values using predicate
  */
-export function partitionMap<B, C>(
+export function partitionMapWith<B, C>(
   B: P.HashEq<B>,
   C: P.HashEq<C>,
 ): <A>(f: (a: A) => Either<B, C>) => (self: HashSet<A>) => readonly [HashSet<B>, HashSet<C>] {
   return (f) => (fa) => {
-    const right = beginMutation(make(C));
-    const left  = beginMutation(make(B));
+    const right = beginMutation(emptyWith(C));
+    const left  = beginMutation(emptyWith(B));
     fa.forEach((v) => {
       f(v).match(
         (b) => {
@@ -282,14 +289,23 @@ export function partitionMap<B, C>(
   };
 }
 
+/**
+ * @tsplus pipeable fncts.HashSet partitionMap
+ */
+export function partitionMap<A, B, C>(
+  f: (a: A) => Either<B, C>,
+): (self: HashSet<A>) => readonly [HashSet<B>, HashSet<C>] {
+  return partitionMapWith<B, C>(HashEq.StructuralStrict, HashEq.StructuralStrict)(f);
+}
+
 /**
  * Reduce a state over the set elements
  *
  * @tsplus pipeable fncts.HashSet foldLeft
  */
 export function foldLeft<A, B>(b: B, f: (b: B, v: A) => B) {
-  return (fa: HashSet<A>): B => {
-    const root = fa._root;
+  return (self: HashSet<A>): B => {
+    const root = self._root;
     if (root._tag === "LeafNode") return f(b, root.value);
     if (root._tag === "EmptyNode") return b;
     const toVisit: Stack<Array<Node<A>>> = Stack();
@@ -343,10 +359,10 @@ export function join(separator: string) {
  *
  * @tsplus pipeable fncts.HashSet difference
  */
-export function difference<A>(y: Iterable<A>) {
-  return (x: HashSet<A>): HashSet<A> => {
-    return x.mutate((s) => {
-      for (const k of y) {
+export function difference<A>(that: Iterable<A>) {
+  return (self: HashSet<A>): HashSet<A> => {
+    return self.mutate((s) => {
+      for (const k of that) {
         s.remove(k);
       }
     });
@@ -378,7 +394,7 @@ export function every<A>(predicate: Predicate<A>) {
  */
 export function intersection<A>(that: Iterable<A>) {
   return (self: HashSet<A>): HashSet<A> => {
-    const out = make<A>(self.config);
+    const out = emptyWith<A>(self.config);
     return out.mutate((y) => {
       for (const k of that) {
         if (self.has(k)) {
@@ -396,19 +412,19 @@ export function intersection<A>(that: Iterable<A>) {
  *
  * @tsplus pipeable fncts.HashSet isSubset
  */
-export function isSubset<A>(y: HashSet<A>) {
-  return (x: HashSet<A>): boolean => x.every((a) => y.has(a));
+export function isSubset<A>(that: HashSet<A>) {
+  return (self: HashSet<A>): boolean => self.every((a) => that.has(a));
 }
 
 /**
  * true if one or more elements match predicate
  *
- * @tsplus pipeable fncts.HashSet exists
+ * @tsplus pipeable fncts.HashSet some
  */
-export function exists<A>(predicate: Predicate<A>) {
-  return (set: HashSet<A>): boolean => {
+export function some<A>(predicate: Predicate<A>) {
+  return (self: HashSet<A>): boolean => {
     let found = false;
-    for (const e of set) {
+    for (const e of self) {
       found = predicate(e);
       if (found) {
         break;
@@ -425,10 +441,10 @@ export function exists<A>(predicate: Predicate<A>) {
  *
  * @tsplus pipeable fncts.HashSet union
  */
-export function union<A>(r: Iterable<A>) {
-  return (l: HashSet<A>): HashSet<A> => {
-    return l.mutate((x) => {
-      for (const a of r) {
+export function union<A>(that: Iterable<A>) {
+  return (self: HashSet<A>): HashSet<A> => {
+    return self.mutate((x) => {
+      for (const a of that) {
         x.add(a);
       }
     });
@@ -436,20 +452,16 @@ export function union<A>(r: Iterable<A>) {
 }
 
 /**
- * @tsplus static fncts.HashSet toArray
+ * @tsplus pipeable fncts.HashSet toArray
  */
-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);
+export function toArray<A>(O: P.Ord<A>) {
+  return (self: HashSet<A>): ReadonlyArray<A> => {
+    const r: Array<A> = [];
+    self.forEach((a) => r.push(a));
+    return r.sort((a, b) => O.compare(b)(a));
+  };
 }
 
-/*
- * -------------------------------------------------------------------------------------------------
- * internal
- * -------------------------------------------------------------------------------------------------
- */
-
 function setTree<A>(set: HashSet<A>, newRoot: Node<A>, newSize: number) {
   if (set._editable) {
     set._root = newRoot;
@@ -474,14 +486,14 @@ function tryGetHash<A>(set: HashSet<A>, value: A, hash: number): Maybe<A> {
   while (true) {
     switch (node._tag) {
       case "LeafNode": {
-        return eq(node.value, value) ? Just(node.value) : Nothing();
+        return eq(value)(node.value) ? Just(node.value) : Nothing();
       }
       case "CollisionNode": {
         if (hash === node.hash) {
           const children = node.children;
           for (let i = 0, len = children.length; i < len; ++i) {
             const child = children[i]!;
-            if ("value" in child && eq(child.value, value)) return Just(child.value);
+            if ("value" in child && eq(value)(child.value)) return Just(child.value);
           }
         }
         return Nothing();

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

@@ -12,11 +12,22 @@ import {
 import { identity } from "@fncts/base/data/function";
 import * as P from "@fncts/base/typeclass";
 
+export const HashSetVariance = Symbol.for("fncts.HashSet.Variance");
+export type HashSetVariance = typeof HashSetVariance;
+
+export const HashSetTypeId = Symbol.for("fncts.HashSet");
+export type HashSetTypeId = typeof HashSetTypeId;
+
 /**
  * @tsplus type fncts.HashSet
  * @tsplus companion fncts.HashSetOps
  */
-export class HashSet<A> implements Iterable<A>, P.Hashable, P.Equatable {
+export class HashSet<in out A> implements Iterable<A>, P.Hashable, P.Equatable {
+  readonly [HashSetTypeId]: HashSetTypeId = HashSetTypeId;
+  declare [HashSetVariance]: {
+    readonly _A: (_: A) => A;
+  };
+
   constructor(
     /**
      * @internal
@@ -54,13 +65,22 @@ export class HashSet<A> implements Iterable<A>, P.Hashable, P.Equatable {
 
   [Symbol.equals](other: unknown): boolean {
     return (
-      other instanceof HashSet &&
+      isHashSet(other) &&
       this._size === other._size &&
       (this as Iterable<A>).corresponds(other, P.Equatable.strictEquals)
     );
   }
 }
 
+/**
+ * @tsplus static fncts.HashSetOps is
+ */
+export function isHashSet<A>(u: Iterable<A>): u is HashSet<A>;
+export function isHashSet(u: unknown): u is HashSet<unknown>;
+export function isHashSet(u: unknown): u is HashSet<unknown> {
+  return isObject(u) && HashSetTypeId in u;
+}
+
 class HashSetIterator<A, T> implements IterableIterator<T> {
   v: VisitResult<A, T> | undefined;
 
@@ -104,7 +124,7 @@ export class EmptyNode<A> {
   modify(
     remove: boolean,
     edit: number,
-    eq: (x: A, y: A) => boolean,
+    eq: (y: A) => (x: A) => boolean,
     shift: number,
     hash: number,
     value: A,
@@ -129,13 +149,13 @@ export class LeafNode<A> {
   modify(
     remove: boolean,
     edit: number,
-    eq: (x: A, y: A) => boolean,
+    eq: (y: A) => (x: A) => boolean,
     shift: number,
     hash: number,
     value: A,
     size: SizeRef,
   ): Node<A> {
-    if (eq(value, this.value)) {
+    if (eq(this.value)(value)) {
       if (remove) {
         --size.value;
         return _EmptyNode;
@@ -163,7 +183,7 @@ export class CollisionNode<A> {
   modify(
     remove: boolean,
     edit: number,
-    eq: (x: A, y: A) => boolean,
+    eq: (y: A) => (x: A) => boolean,
     shift: number,
     hash: number,
     value: A,
@@ -185,7 +205,7 @@ function updateCollisionList<A>(
   remove: boolean,
   mutate: boolean,
   edit: number,
-  eq: (x: A, y: A) => boolean,
+  eq: (y: A) => (x: A) => boolean,
   hash: number,
   list: Array<Node<A>>,
   value: A,
@@ -194,7 +214,7 @@ function updateCollisionList<A>(
   const len = list.length;
   for (let i = 0; i < len; ++i) {
     const child = list[i]!;
-    if ("value" in child && eq(child.value, value)) {
+    if ("value" in child && eq(value)(child.value)) {
       if (remove) {
         --size.value;
         return arraySpliceOut(mutate, i, list);
@@ -219,7 +239,7 @@ export class IndexedNode<A> {
   modify(
     remove: boolean,
     edit: number,
-    eq: (x: A, y: A) => boolean,
+    eq: (y: A) => (x: A) => boolean,
     shift: number,
     hash: number,
     value: A,
@@ -267,7 +287,7 @@ export class ArrayNode<A> {
   modify(
     remove: boolean,
     edit: number,
-    eq: (x: A, y: A) => boolean,
+    eq: (y: A) => (x: A) => boolean,
     shift: number,
     hash: number,
     value: A,

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

@@ -359,7 +359,7 @@ export function dropLastWhile<A>(p: Predicate<A>) {
  */
 export function elem<A>(a: A, /** @tsplus auto */ E: P.Eq<A>) {
   return (as: ImmutableArray<A>): boolean => {
-    const predicate = (element: A) => E.equals(element, a);
+    const predicate = (element: A) => E.equals(a)(element);
     const len       = as.length;
     for (let i = 0; i < len; i++) {
       if (predicate(as._array[i]!)) {
@@ -401,9 +401,9 @@ export function everyWithIndex<A>(p: PredicateWithIndex<number, A>) {
 }
 
 /**
- * @tsplus pipeable fncts.ImmutableArray exists
+ * @tsplus pipeable fncts.ImmutableArray some
  */
-export function exists<A>(p: Predicate<A>) {
+export function some<A>(p: Predicate<A>) {
   return (self: ImmutableArray<A>): self is ImmutableNonEmptyArray<A> => {
     let result = false;
     let i      = 0;
@@ -642,7 +642,7 @@ export function foldLeftWithIndexWhile<A, B>(b: B, p: Predicate<B>, f: (i: numbe
  */
 export function fold<M>(/** @tsplus auto */ M: Monoid<M>) {
   return (self: ImmutableArray<M>): M => {
-    return self.foldLeft(M.nat, M.combine);
+    return self.foldLeft(M.nat, (b, a) => M.combine(a)(b));
   };
 }
 
@@ -651,7 +651,7 @@ export function fold<M>(/** @tsplus auto */ M: Monoid<M>) {
  */
 export function foldMapWithIndex<A, M>(f: (i: number, a: A) => M, /** @tsplus auto */ M: Monoid<M>) {
   return (self: ImmutableArray<A>): M => {
-    return self.foldLeftWithIndex(M.nat, (i, b, a) => M.combine(b, f(i, a)));
+    return self.foldLeftWithIndex(M.nat, (i, b, a) => M.combine(f(i, a))(b));
   };
 }
 
@@ -739,7 +739,7 @@ export function group<A>(E: P.Eq<A>): (self: ImmutableArray<A>) => ImmutableArra
     let i     = 1;
     for (; i < self.length; i++) {
       const a = self._array[i]!;
-      if (E.equals(a, h)) {
+      if (E.equals(h)(a)) {
         out.push(a);
       } else {
         break;
@@ -1114,7 +1114,9 @@ export function scanRight<A, B>(b: B, f: (a: A, b: B) => B) {
  */
 export function sort<A>(/** @tsplus auto */ O: P.Ord<A>) {
   return (self: ImmutableArray<A>): ImmutableArray<A> => {
-    return self.isEmpty() || self.length === 1 ? self : self._array.slice().sort(O.compare).asImmutableArray;
+    return self.isEmpty() || self.length === 1
+      ? self
+      : self._array.slice().sort((a, b) => O.compare(b)(a)).asImmutableArray;
   };
 }
 

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

@@ -1,3 +1,6 @@
+export const ImmutableArrayVariance = Symbol.for("fncts.ImmutableArray.Variance");
+export type ImmutableArrayVariance = typeof ImmutableArrayVariance;
+
 export const ImmutableArrayTypeId = Symbol.for("fncts.ImmutableArray");
 export type ImmutableArrayTypeId = typeof ImmutableArrayTypeId;
 
@@ -14,8 +17,10 @@ export interface ImmutableArrayF extends HKT {
  * @tsplus companion fncts.ImmutableArrayOps
  */
 export class ImmutableArray<A> implements Equatable, Hashable, Iterable<A> {
-  readonly _typeId: ImmutableArrayTypeId = ImmutableArrayTypeId;
-  readonly _A!: () => A;
+  readonly [ImmutableArrayTypeId]: ImmutableArrayTypeId = ImmutableArrayTypeId;
+  declare [ImmutableArrayVariance]: {
+    readonly _A: (_: never) => A;
+  };
   constructor(readonly _array: ReadonlyArray<A>) {}
 
   [Symbol.equals](that: unknown): boolean {
@@ -39,5 +44,5 @@ 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);
+  return isObject(u) && ImmutableArrayTypeId in u;
 }

package/_src/collection/immutable/ImmutableArray.ts

@@ -2,9 +2,9 @@
 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
+
 // codegen:start { preset: barrel, include: ./ImmutableArray/api/*.ts }
 export * from "./ImmutableArray/api/chunksOf.js";
 export * from "./ImmutableArray/api/slice.js";

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

@@ -176,7 +176,7 @@ export function cross<B>(fb: ImmutableNonEmptyArray<B>) {
  */
 export function elem<A>(a: A, /** @tsplus auto */ E: P.Eq<A>) {
   return (self: ImmutableNonEmptyArray<A>): boolean => {
-    const p   = (element: A) => E.equals(a, element);
+    const p   = (element: A) => E.equals(element)(a);
     const len = self.length;
     for (let i = 0; i < len; i++) {
       if (p(self._array[i]!)) {
@@ -199,7 +199,7 @@ export function flatten<A>(self: ImmutableNonEmptyArray<ImmutableNonEmptyArray<A
  */
 export function fold<A>(/** @tsplus auto */ S: P.Semigroup<A>) {
   return (self: ImmutableNonEmptyArray<A>): A => {
-    return self.slice(1).foldLeft(self._array[0], S.combine);
+    return self.slice(1).foldLeft(self._array[0], (b, a) => S.combine(a)(b));
   };
 }
 
@@ -231,7 +231,7 @@ export function foldLeftWithIndex<A, B>(b: B, f: (i: number, b: B, a: A) => B) {
  */
 export function foldMapWithIndex<A, M>(f: (i: number, a: A) => M, /** @tsplus auto */ M: P.Monoid<M>) {
   return (self: ImmutableNonEmptyArray<A>): M => {
-    return self.foldLeftWithIndex(M.nat, (i, b, a) => M.combine(b, f(i, a)));
+    return self.foldLeftWithIndex(M.nat, (i, b, a) => M.combine(f(i, a))(b));
   };
 }
 
@@ -277,7 +277,7 @@ export function group<A>(/** @tsplus auto */ E: P.Eq<A>) {
       let i     = 1;
       for (; i < as.length; i++) {
         const a = as._array[i]!;
-        if (E.equals(a, h)) {
+        if (E.equals(h)(a)) {
           out.push(a);
         } else {
           break;
@@ -333,7 +333,7 @@ export function max<A>(/** @tsplus auto */ O: P.Ord<A>) {
   return (self: ImmutableNonEmptyArray<A>): A => {
     const S            = P.Semigroup.max(O);
     const [head, tail] = self.unprepend;
-    return tail.isNonEmpty() ? tail.foldLeft(head, S.combine) : head;
+    return tail.isNonEmpty() ? tail.foldLeft(head, (b, a) => S.combine(a)(b)) : head;
   };
 }
 
@@ -344,7 +344,7 @@ export function min<A>(/** @tsplus auto */ O: P.Ord<A>) {
   return (self: ImmutableNonEmptyArray<A>): A => {
     const S            = P.Semigroup.min(O);
     const [head, tail] = self.unprepend;
-    return tail.isNonEmpty() ? tail.foldLeft(head, S.combine) : head;
+    return tail.isNonEmpty() ? tail.foldLeft(head, (b, a) => S.combine(a)(b)) : head;
   };
 }
 
@@ -403,7 +403,7 @@ export function sort<A>(/** @tsplus auto */ O: P.Ord<A>) {
   return (self: ImmutableNonEmptyArray<A>): ImmutableNonEmptyArray<A> => {
     return self.length === 1
       ? self
-      : self._array.slice().sort((first, second) => O.compare(first, second)).unsafeAsNonEmptyArray;
+      : self._array.slice().sort((first, second) => O.compare(second)(first)).unsafeAsNonEmptyArray;
   };
 }
 

package/_src/collection/immutable/ImmutableNonEmptyArray.ts

@@ -2,7 +2,6 @@
 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