@fncts/base 0.0.21 → 0.0.22

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

@@ -1,6 +1,6 @@
 import { HKT } from "@fncts/typelevel/HKT";
-import { Hashable } from "@fncts/base/typeclass/Hashable";
-import { Equatable } from "@fncts/base/typeclass/Equatable";
+import { Hashable } from "@fncts/base/data/Hashable";
+import { Equatable } from "@fncts/base/data/Equatable";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import type { Node } from "@fncts/base/collection/immutable/HashMap/internal";
 import type { HashEq } from "@fncts/base/typeclass";
@@ -12,6 +12,8 @@ export interface HashMapF extends HKT {
     };
     index: this["K"];
 }
+export declare const TypeId: unique symbol;
+export type TypeId = typeof TypeId;
 /**
  * @tsplus type fncts.HashMap
  * @tsplus companion fncts.HashMapOps
@@ -22,13 +24,20 @@ export declare class HashMap<K, V> implements Iterable<readonly [K, V]>, Hashabl
     readonly config: HashEq<K>;
     root: Node<K, V>;
     size: number;
-    readonly _K: () => K;
-    readonly _A: () => V;
+    readonly _typeId: TypeId;
+    _K: () => K;
+    _A: () => V;
     constructor(editable: boolean, edit: number, config: HashEq<K>, root: Node<K, V>, size: number);
     [Symbol.iterator](): Iterator<readonly [K, V]>;
     get [Symbol.hash](): number;
     [Symbol.equals](other: unknown): boolean;
 }
+/**
+ * @tsplus static fncts.HashMapOps is
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/definition"
+ */
+export declare function isHashMap<K, V>(u: Iterable<readonly [K, V]>): u is HashMap<K, V>;
+export declare function isHashMap(u: unknown): u is HashMap<unknown, unknown>;
 export declare class HashMapIterator<K, V, T> implements IterableIterator<T> {
     readonly map: HashMap<K, V>;
     readonly f: (node: readonly [K, V]) => T;

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

@@ -4,49 +4,50 @@ import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Either } from "@fncts/base/data/Either/definition";
 import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
 import * as P from "@fncts/base/typeclass";
+import { HashEq } from "@fncts/base/typeclass";
 /**
  * @tsplus pipeable fncts.HashSet add
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function add<A>(value: A): (set: HashSet<A>) => HashSet<A>;
+export declare function add<A>(value: A): (self: HashSet<A>) => HashSet<A>;
 /**
  * Mark `set` as mutable.
  * @tsplus getter fncts.HashSet beginMutation
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function beginMutation<K>(set: HashSet<K>): HashSet<K>;
+export declare function beginMutation<K>(self: HashSet<K>): HashSet<K>;
 /**
  * Mark `set` as immutable.
  * @tsplus getter fncts.HashSet endMutation
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function endMutation<K>(set: HashSet<K>): HashSet<K>;
+export declare function endMutation<K>(self: HashSet<K>): HashSet<K>;
 /**
  * Appy f to each element
  * @tsplus pipeable fncts.HashSet forEach
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function forEach<V>(f: (v: V, m: HashSet<V>) => void): (map: HashSet<V>) => void;
+export declare function forEach<V>(f: (v: V, m: HashSet<V>) => void): (self: HashSet<V>) => void;
 /**
  * @tsplus pipeable fncts.HashSet has
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function has<A>(value: A): (set: HashSet<A>) => boolean;
+export declare function has<A>(value: A): (self: HashSet<A>) => boolean;
 /**
- * @tsplus static fncts.HashSetOps make
+ * @tsplus static fncts.HashSetOps emptyWith
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function make<A>(config: P.Hash<A> & P.Eq<A>): HashSet<A>;
+export declare function emptyWith<A>(config: HashEq<A>): HashSet<A>;
 /**
- * @tsplus static fncts.HashSetOps makeDefault
+ * @tsplus static fncts.HashSetOps empty
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function makeDefault<A>(): HashSet<A>;
+export declare function empty<A>(): HashSet<A>;
 /**
- * @tsplus static fncts.HashSetOps fromDefault
+ * @tsplus static fncts.HashSetOps make
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function fromDefault<A>(...values: ReadonlyArray<A>): HashSet<A>;
+export declare function make<A>(...values: ReadonlyArray<A>): HashSet<A>;
 /**
  * Mutate `set` within the context of `f`.
  * @tsplus pipeable fncts.HashSet mutate
@@ -57,38 +58,38 @@ export declare function mutate<A>(transient: (set: HashSet<A>) => void): (self:
  * @tsplus pipeable fncts.HashSet remove
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function remove<A>(value: A): (set: HashSet<A>) => HashSet<A>;
+export declare function remove<A>(value: A): (self: HashSet<A>) => HashSet<A>;
 /**
  * Calculate the number of keys pairs in a set
  * @tsplus getter fncts.HashSet size
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function size<A>(set: HashSet<A>): number;
+export declare function size<A>(self: HashSet<A>): number;
 /**
  * If element is present remove it, if not add it
  * @tsplus pipeable fncts.HashSet toggle
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function toggle<A>(a: A): (set: HashSet<A>) => HashSet<A>;
+export declare function toggle<A>(a: A): (self: HashSet<A>) => HashSet<A>;
 /**
  * Projects a Set through a function
  */
-export declare function map<B>(C: P.HashEq<B>): <A>(f: (x: A) => B) => (fa: HashSet<A>) => HashSet<B>;
+export declare function mapWith<B>(B: P.HashEq<B>): <A>(f: (a: A) => B) => (self: HashSet<A>) => HashSet<B>;
 /**
  * Projects a Set through a function
  * @tsplus pipeable fncts.HashSet map
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function mapDefault<A, B>(f: (a: A) => B): (self: HashSet<A>) => HashSet<B>;
+export declare function map<A, B>(f: (a: A) => B): (self: HashSet<A>) => HashSet<B>;
 /**
  * Map + Flatten
  */
-export declare function flatMap<B>(C: P.HashEq<B>): <A>(f: (x: A) => Iterable<B>) => (self: HashSet<A>) => HashSet<B>;
+export declare function flatMapWith<B>(C: P.HashEq<B>): <A>(f: (x: A) => Iterable<B>) => (self: HashSet<A>) => HashSet<B>;
 /**
  * @tsplus pipeable fncts.HashSet flatMap
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function flatMapDefault<A, B>(f: (a: A) => Iterable<B>): (self: HashSet<A>) => HashSet<B>;
+export declare function flatMap<A, B>(f: (a: A) => Iterable<B>): (self: HashSet<A>) => HashSet<B>;
 /**
  * Creates an equal for a set
  * @tsplus static fncts.HashSetOps getEq
@@ -102,7 +103,12 @@ export declare function getEq<A>(): P.Eq<HashSet<A>>;
  */
 export declare function filter<A, B extends A>(refinement: Refinement<A, B>): (set: HashSet<A>) => HashSet<B>;
 export declare function filter<A>(predicate: Predicate<A>): (set: HashSet<A>) => HashSet<A>;
-export declare function filterMap<B>(B: P.HashEq<B>): <A>(f: (a: A) => Maybe<B>) => (fa: HashSet<A>) => HashSet<B>;
+export declare function filterMapWith<B>(B: P.HashEq<B>): <A>(f: (a: A) => Maybe<B>) => (fa: HashSet<A>) => HashSet<B>;
+/**
+ * @tsplus pipeable fncts.HashSet filterMap
+ * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
+ */
+export declare function filterMap<A, B>(f: (a: A) => Maybe<B>): (self: HashSet<A>) => HashSet<B>;
 /**
  * Partition set values using predicate
  * @tsplus pipeable fncts.HashSet partition
@@ -113,13 +119,18 @@ export declare function partition<A>(p: Predicate<A>): (self: HashSet<A>) => rea
 /**
  * Partition set values using predicate
  */
-export declare function partitionMap<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>];
+export declare 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>];
+/**
+ * @tsplus pipeable fncts.HashSet partitionMap
+ * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
+ */
+export declare function partitionMap<A, B, C>(f: (a: A) => Either<B, C>): (self: HashSet<A>) => readonly [HashSet<B>, HashSet<C>];
 /**
  * Reduce a state over the set elements
  * @tsplus pipeable fncts.HashSet foldLeft
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function foldLeft<A, B>(b: B, f: (b: B, v: A) => B): (fa: HashSet<A>) => B;
+export declare function foldLeft<A, B>(b: B, f: (b: B, v: A) => B): (self: HashSet<A>) => B;
 /**
  * @tsplus pipeable fncts.HashSet join
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
@@ -130,7 +141,7 @@ export declare function join(separator: string): (self: HashSet<string>) => stri
  * @tsplus pipeable fncts.HashSet difference
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function difference<A>(y: Iterable<A>): (x: HashSet<A>) => HashSet<A>;
+export declare function difference<A>(that: Iterable<A>): (self: HashSet<A>) => HashSet<A>;
 /**
  * true if all elements match predicate
  * @tsplus pipeable fncts.HashSet every
@@ -152,13 +163,13 @@ export declare function intersection<A>(that: Iterable<A>): (self: HashSet<A>) =
  * @tsplus pipeable fncts.HashSet isSubset
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function isSubset<A>(y: HashSet<A>): (x: HashSet<A>) => boolean;
+export declare function isSubset<A>(that: HashSet<A>): (self: HashSet<A>) => boolean;
 /**
  * true if one or more elements match predicate
- * @tsplus pipeable fncts.HashSet exists
+ * @tsplus pipeable fncts.HashSet some
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function exists<A>(predicate: Predicate<A>): (set: HashSet<A>) => boolean;
+export declare function some<A>(predicate: Predicate<A>): (self: HashSet<A>) => boolean;
 /**
  * Form the union of two sets,
  *
@@ -166,9 +177,9 @@ export declare function exists<A>(predicate: Predicate<A>): (set: HashSet<A>) =>
  * @tsplus pipeable fncts.HashSet union
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function union<A>(r: Iterable<A>): (l: HashSet<A>) => HashSet<A>;
+export declare function union<A>(that: Iterable<A>): (self: HashSet<A>) => HashSet<A>;
 /**
- * @tsplus static fncts.HashSet toArray
+ * @tsplus pipeable fncts.HashSet toArray
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function toArray<A>(set: HashSet<A>, O: P.Ord<A>): ReadonlyArray<A>;
+export declare function toArray<A>(O: P.Ord<A>): (self: HashSet<A>) => ReadonlyArray<A>;

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

@@ -1,5 +1,7 @@
-import { Hashable } from "@fncts/base/typeclass/Hashable";
+import { Hashable } from "@fncts/base/data/Hashable";
 import * as P from "@fncts/base/typeclass";
+export declare const TypeId: unique symbol;
+export type TypeId = typeof TypeId;
 /**
  * @tsplus type fncts.HashSet
  * @tsplus companion fncts.HashSetOps
@@ -25,6 +27,7 @@ export declare class HashSet<A> implements Iterable<A>, P.Hashable, P.Equatable
      * @internal
      */
     _size: number;
+    readonly _typeId: TypeId;
     constructor(
     /**
      * @internal
@@ -51,6 +54,12 @@ export declare class HashSet<A> implements Iterable<A>, P.Hashable, P.Equatable
     get [Symbol.hash](): number;
     [Symbol.equals](other: unknown): boolean;
 }
+/**
+ * @tsplus static fncts.HashSetOps is
+ * @tsplus location "@fncts/base/collection/immutable/HashSet/definition"
+ */
+export declare function isHashSet<A>(u: Iterable<A>): u is HashSet<A>;
+export declare function isHashSet(u: unknown): u is HashSet<unknown>;
 interface SizeRef {
     value: number;
 }
@@ -58,7 +67,7 @@ export declare function canEditNode<A>(edit: number, node: Node<A>): boolean;
 export type Node<A> = EmptyNode<A> | LeafNode<A> | CollisionNode<A> | IndexedNode<A> | ArrayNode<A>;
 export declare class EmptyNode<A> {
     readonly _tag = "EmptyNode";
-    modify(remove: boolean, edit: number, eq: (x: A, y: A) => boolean, shift: number, hash: number, value: A, size: SizeRef): this | LeafNode<A>;
+    modify(remove: boolean, edit: number, eq: (y: A) => (x: A) => boolean, shift: number, hash: number, value: A, size: SizeRef): this | LeafNode<A>;
 }
 export declare const _EmptyNode: EmptyNode<never>;
 export declare function isEmptyNode<A>(n: Node<A>): n is EmptyNode<A>;
@@ -68,7 +77,7 @@ export declare class LeafNode<A> {
     value: A;
     readonly _tag = "LeafNode";
     constructor(edit: number, hash: number, value: A);
-    modify(remove: boolean, edit: number, eq: (x: A, y: A) => boolean, shift: number, hash: number, value: A, size: SizeRef): Node<A>;
+    modify(remove: boolean, edit: number, eq: (y: A) => (x: A) => boolean, shift: number, hash: number, value: A, size: SizeRef): Node<A>;
 }
 export declare class CollisionNode<A> {
     edit: number;
@@ -76,7 +85,7 @@ export declare class CollisionNode<A> {
     children: Array<Node<A>>;
     readonly _tag = "CollisionNode";
     constructor(edit: number, hash: number, children: Array<Node<A>>);
-    modify(remove: boolean, edit: number, eq: (x: A, y: A) => boolean, shift: number, hash: number, value: A, size: SizeRef): Node<A>;
+    modify(remove: boolean, edit: number, eq: (y: A) => (x: A) => boolean, shift: number, hash: number, value: A, size: SizeRef): Node<A>;
 }
 export declare function isLeaf<A>(node: Node<A>): node is EmptyNode<A> | LeafNode<A> | CollisionNode<A>;
 export declare class IndexedNode<A> {
@@ -85,7 +94,7 @@ export declare class IndexedNode<A> {
     children: Array<Node<A>>;
     readonly _tag = "IndexNode";
     constructor(edit: number, mask: number, children: Array<Node<A>>);
-    modify(remove: boolean, edit: number, eq: (x: A, y: A) => boolean, shift: number, hash: number, value: A, size: SizeRef): Node<A>;
+    modify(remove: boolean, edit: number, eq: (y: A) => (x: A) => boolean, shift: number, hash: number, value: A, size: SizeRef): Node<A>;
 }
 export declare class ArrayNode<A> {
     edit: number;
@@ -93,6 +102,6 @@ export declare class ArrayNode<A> {
     children: Array<Node<A>>;
     readonly _tag = "ArrayNode";
     constructor(edit: number, size: number, children: Array<Node<A>>);
-    modify(remove: boolean, edit: number, eq: (x: A, y: A) => boolean, shift: number, hash: number, value: A, size: SizeRef): Node<A>;
+    modify(remove: boolean, edit: number, eq: (y: A) => (x: A) => boolean, shift: number, hash: number, value: A, size: SizeRef): Node<A>;
 }
 export {};

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

@@ -150,10 +150,10 @@ export declare function every<A>(p: Predicate<A>): (self: ImmutableArray<A>) =>
 export declare function everyWithIndex<A, B extends A>(p: RefinementWithIndex<number, A, B>): (self: ImmutableArray<A>) => self is ImmutableArray<B>;
 export declare function everyWithIndex<A>(p: PredicateWithIndex<number, A>): (self: ImmutableArray<A>) => boolean;
 /**
- * @tsplus pipeable fncts.ImmutableArray exists
+ * @tsplus pipeable fncts.ImmutableArray some
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function exists<A>(p: Predicate<A>): (self: ImmutableArray<A>) => self is import("../ImmutableNonEmptyArray").ImmutableNonEmptyArray<A>;
+export declare function some<A>(p: Predicate<A>): (self: ImmutableArray<A>) => self is import("../ImmutableNonEmptyArray").ImmutableNonEmptyArray<A>;
 /**
  * @tsplus pipeable fncts.ImmutableArray filter
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"

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

@@ -1,6 +1,6 @@
 import { HKT } from "@fncts/typelevel/HKT";
-import { Equatable } from "@fncts/base/typeclass/Equatable";
-import { Hashable } from "@fncts/base/typeclass/Hashable";
+import { Equatable } from "@fncts/base/data/Equatable";
+import { Hashable } from "@fncts/base/data/Hashable";
 export declare const ImmutableArrayTypeId: unique symbol;
 export type ImmutableArrayTypeId = typeof ImmutableArrayTypeId;
 export interface ImmutableArrayF extends HKT {

package/collection/immutable/ImmutableArray.d.ts

@@ -1,7 +1,6 @@
 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";
 export * from "./ImmutableArray/api/chunksOf.js";
 export * from "./ImmutableArray/api/slice.js";

package/collection/immutable/ImmutableNonEmptyArray.d.ts

@@ -1,6 +1,5 @@
 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";

package/collection/immutable/List/api.d.ts

@@ -1,5 +1,6 @@
 import { List, Cons } from "@fncts/base/collection/immutable/List/definition";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
+import { Refinement } from "@fncts/base/data/Refinement/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import type * as P from "@fncts/base/typeclass";
 /**
@@ -13,14 +14,15 @@ export declare function flatMap<A, B>(f: (a: A) => List<B>): (self: List<A>) =>
  */
 export declare function concat<B>(that: List<B>): <A>(self: import("@fncts/base/collection/immutable/List/definition").List<A>) => import("@fncts/base/collection/immutable/List/definition").List<B | A>;
 /**
- * @tsplus pipeable fncts.List exists
+ * @tsplus pipeable fncts.List some
  * @tsplus location "@fncts/base/collection/immutable/List/api"
  */
-export declare function exists<A>(p: Predicate<A>): (self: List<A>) => boolean;
+export declare function some<A>(p: Predicate<A>): (self: List<A>) => boolean;
 /**
  * @tsplus pipeable fncts.List filter
  * @tsplus location "@fncts/base/collection/immutable/List/api"
  */
+export declare function filter<A, B extends A>(p: Refinement<A, B>): (self: List<A>) => List<B>;
 export declare function filter<A>(p: Predicate<A>): (self: List<A>) => List<A>;
 /**
  * @tsplus pipeable fncts.List forEach
@@ -76,7 +78,7 @@ export declare function sort<A>(/** @tsplus auto */ O: P.Ord<A>): (self: List<A>
  * @tsplus pipeable fncts.List sortWith
  * @tsplus location "@fncts/base/collection/immutable/List/api"
  */
-export declare function sortWith_<A>(compare: (x: A, y: A) => P.Ordering): (self: List<A>) => List<A>;
+export declare function sortWith<A>(compare: (x: A, y: A) => P.Ordering): (self: List<A>) => List<A>;
 /**
  * @tsplus getter fncts.List tail
  * @tsplus location "@fncts/base/collection/immutable/List/api"
@@ -86,14 +88,14 @@ export declare function tail<A>(self: List<A>): Maybe<List<A>>;
  * @tsplus pipeable fncts.List take
  * @tsplus location "@fncts/base/collection/immutable/List/api"
  */
-export declare function take_(n: number): <A>(self: import("@fncts/base/collection/immutable/List/definition").List<A>) => import("@fncts/base/collection/immutable/List/definition").List<A>;
+export declare function take(n: number): <A>(self: import("@fncts/base/collection/immutable/List/definition").List<A>) => import("@fncts/base/collection/immutable/List/definition").List<A>;
 /**
  * @tsplus getter fncts.List unsafeHead
  * @tsplus location "@fncts/base/collection/immutable/List/api"
  */
-export declare function unsafeHead<A>(list: List<A>): A;
+export declare function unsafeHead<A>(self: List<A>): A;
 /**
  * @tsplus getter fncts.List unsafeLast
  * @tsplus location "@fncts/base/collection/immutable/List/api"
  */
-export declare function unsafeLast<A>(list: List<A>): A;
+export declare function unsafeLast<A>(self: List<A>): A;

package/collection/immutable/List/constructors.d.ts

@@ -11,7 +11,7 @@ export declare function cons<A>(head: A, tail?: List<A>): Cons<A>;
 export declare function empty<A>(): List<A>;
 /**
  * @tsplus static fncts.ListOps from
- * @tsplus getter fncts.Iterable asList
+ * @tsplus getter fncts.Iterable toList
  * @tsplus location "@fncts/base/collection/immutable/List/constructors"
  */
 export declare function from<A>(prefix: Iterable<A>): List<A>;

package/collection/immutable/Queue/api.d.ts

@@ -5,74 +5,74 @@ import { Queue } from "@fncts/base/collection/immutable/Queue/definition";
  * @tsplus getter fncts.ImmutableQueue length
  * @tsplus location "@fncts/base/collection/immutable/Queue/api"
  */
-export declare function length<A>(queue: Queue<A>): number;
+export declare function length<A>(self: Queue<A>): number;
 /**
  * @tsplus getter fncts.ImmutableQueue unsafeHead
  * @tsplus location "@fncts/base/collection/immutable/Queue/api"
  */
-export declare function unsafeHead<A>(queue: Queue<A>): A;
+export declare function unsafeHead<A>(self: Queue<A>): A;
 /**
  * @tsplus getter fncts.ImmutableQueue head
  * @tsplus location "@fncts/base/collection/immutable/Queue/api"
  */
-export declare function head<A>(queue: Queue<A>): Maybe<A>;
+export declare function head<A>(self: Queue<A>): Maybe<A>;
 /**
  * @tsplus getter fncts.ImmutableQueue unsafeTail
  * @tsplus location "@fncts/base/collection/immutable/Queue/api"
  */
-export declare function unsafeTail<A>(queue: Queue<A>): Queue<A>;
+export declare function unsafeTail<A>(self: Queue<A>): Queue<A>;
 /**
  * @tsplus getter fncts.ImmutableQueue tail
  * @tsplus location "@fncts/base/collection/immutable/Queue/api"
  */
-export declare function tail<A>(queue: Queue<A>): Maybe<Queue<A>>;
+export declare function tail<A>(self: Queue<A>): Maybe<Queue<A>>;
 /**
  * @tsplus pipeable fncts.ImmutableQueue prepend
  * @tsplus location "@fncts/base/collection/immutable/Queue/api"
  */
-export declare function prepend<B>(elem: B): <A>(queue: Queue<A>) => Queue<B | A>;
+export declare function prepend<B>(elem: B): <A>(self: Queue<A>) => Queue<B | A>;
 /**
  * @tsplus pipeable fncts.ImmutableQueue enqueue
  * @tsplus location "@fncts/base/collection/immutable/Queue/api"
  */
-export declare function enqueue<B>(elem: B): <A>(queue: Queue<A>) => Queue<B | A>;
+export declare function enqueue<B>(elem: B): <A>(self: Queue<A>) => Queue<B | A>;
 /**
  * @tsplus getter fncts.ImmutableQueue unsafeDequeue
  * @tsplus location "@fncts/base/collection/immutable/Queue/api"
  */
-export declare function unasfeDequeue<A>(queue: Queue<A>): readonly [A, Queue<A>];
+export declare function unasfeDequeue<A>(self: Queue<A>): readonly [A, Queue<A>];
 /**
  * @tsplus getter fncts.ImmutableQueue dequeue
  * @tsplus location "@fncts/base/collection/immutable/Queue/api"
  */
-export declare function dequeue<A>(queue: Queue<A>): Maybe<readonly [A, Queue<A>]>;
+export declare function dequeue<A>(self: Queue<A>): Maybe<readonly [A, Queue<A>]>;
 /**
  * @tsplus pipeable fncts.ImmutableQueue map
  * @tsplus location "@fncts/base/collection/immutable/Queue/api"
  */
-export declare function map<A, B>(f: (a: A) => B): (fa: Queue<A>) => Queue<B>;
+export declare function map<A, B>(f: (a: A) => B): (self: Queue<A>) => Queue<B>;
 /**
  * @tsplus pipeable fncts.ImmutableQueue foldLeft
  * @tsplus location "@fncts/base/collection/immutable/Queue/api"
  */
-export declare function foldLeft<A, B>(b: B, f: (b: B, a: A) => B): (fa: Queue<A>) => B;
+export declare function foldLeft<A, B>(b: B, f: (b: B, a: A) => B): (self: Queue<A>) => B;
 /**
- * @tsplus pipeable fncts.ImmutableQueue exists
+ * @tsplus pipeable fncts.ImmutableQueue some
  * @tsplus location "@fncts/base/collection/immutable/Queue/api"
  */
-export declare function exists<A>(p: Predicate<A>): (queue: Queue<A>) => boolean;
+export declare function some<A>(p: Predicate<A>): (self: Queue<A>) => boolean;
 /**
  * @tsplus pipeable fncts.ImmutableQueue find
  * @tsplus location "@fncts/base/collection/immutable/Queue/api"
  */
-export declare function find<A>(p: Predicate<A>): (queue: Queue<A>) => Maybe<A>;
+export declare function find<A>(p: Predicate<A>): (self: Queue<A>) => Maybe<A>;
 /**
  * @tsplus pipeable fncts.ImmutableQueue filter
  * @tsplus location "@fncts/base/collection/immutable/Queue/api"
  */
-export declare function filter<A>(p: Predicate<A>): (queue: Queue<A>) => Queue<A>;
+export declare function filter<A>(p: Predicate<A>): (self: Queue<A>) => Queue<A>;
 /**
  * @tsplus pipeable fncts.ImmutableQueue count
  * @tsplus location "@fncts/base/collection/immutable/Queue/api"
  */
-export declare function count<A>(p: Predicate<A>): (queue: Queue<A>) => number;
+export declare function count<A>(p: Predicate<A>): (self: Queue<A>) => number;

package/collection/immutable/Queue/guards.d.ts

@@ -3,4 +3,4 @@ import type { Queue } from "./definition.js";
  * @tsplus getter fncts.ImmutableQueue isEmpty
  * @tsplus location "@fncts/base/collection/immutable/Queue/guards"
  */
-export declare function isEmpty<A>(queue: Queue<A>): boolean;
+export declare function isEmpty<A>(self: Queue<A>): boolean;

package/collection/immutable/RoseTree/definition.d.ts

@@ -1,6 +1,6 @@
 import { HKT } from "@fncts/typelevel/HKT";
-import { Hashable } from "@fncts/base/typeclass/Hashable";
-import { Equatable } from "@fncts/base/typeclass/Equatable";
+import { Hashable } from "@fncts/base/data/Hashable";
+import { Equatable } from "@fncts/base/data/Equatable";
 import { Vector } from "@fncts/base/collection/immutable/Vector";
 export declare const RoseTreeTypeId: unique symbol;
 export type RoseTreeTypeId = typeof RoseTreeTypeId;