@fncts/base 0.0.20 → 0.0.22

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

@@ -4,91 +4,92 @@ 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 fluent fncts.HashSet add
+ * @tsplus pipeable fncts.HashSet add
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function add_<A>(set: HashSet<A>, value: 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 fluent fncts.HashSet forEach
+ * @tsplus pipeable fncts.HashSet forEach
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function forEach_<V>(map: HashSet<V>, f: (v: V, m: HashSet<V>) => void): void;
+export declare function forEach<V>(f: (v: V, m: HashSet<V>) => void): (self: HashSet<V>) => void;
 /**
- * @tsplus fluent fncts.HashSet has
+ * @tsplus pipeable fncts.HashSet has
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function has_<A>(set: HashSet<A>, value: 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 fluent fncts.HashSet mutate
+ * @tsplus pipeable fncts.HashSet mutate
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function mutate_<A>(set: HashSet<A>, transient: (set: HashSet<A>) => void): HashSet<A>;
+export declare function mutate<A>(transient: (set: HashSet<A>) => void): (self: HashSet<A>) => HashSet<A>;
 /**
- * @tsplus fluent fncts.HashSet remove
+ * @tsplus pipeable fncts.HashSet remove
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function remove_<A>(set: HashSet<A>, value: 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 fluent fncts.HashSet toggle
+ * @tsplus pipeable fncts.HashSet toggle
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function toggle_<A>(set: HashSet<A>, a: 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>(fa: HashSet<A>, f: (x: A) => B) => 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 fluent fncts.HashSet map
+ * @tsplus pipeable fncts.HashSet map
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function mapDefault<A, B>(self: HashSet<A>, f: (a: A) => B): 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>(set: HashSet<A>, f: (x: A) => Iterable<B>) => HashSet<B>;
+export declare function flatMapWith<B>(C: P.HashEq<B>): <A>(f: (x: A) => Iterable<B>) => (self: HashSet<A>) => HashSet<B>;
 /**
- * @tsplus fluent fncts.HashSet flatMap
+ * @tsplus pipeable fncts.HashSet flatMap
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function flatMapDefault<A, B>(self: HashSet<A>, f: (a: A) => Iterable<B>): 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
@@ -97,74 +98,88 @@ export declare function flatMapDefault<A, B>(self: HashSet<A>, f: (a: A) => Iter
 export declare function getEq<A>(): P.Eq<HashSet<A>>;
 /**
  * Filter set values using predicate
- * @tsplus fluent fncts.HashSet filter
+ * @tsplus pipeable fncts.HashSet filter
+ * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
+ */
+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 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 filter_<A, B extends A>(set: HashSet<A>, refinement: Refinement<A, B>): HashSet<B>;
-export declare function filter_<A>(set: HashSet<A>, predicate: Predicate<A>): HashSet<A>;
-export declare function filterMap_<B>(B: P.HashEq<B>): <A>(fa: HashSet<A>, f: (a: A) => Maybe<B>) => HashSet<B>;
+export declare function filterMap<A, B>(f: (a: A) => Maybe<B>): (self: HashSet<A>) => HashSet<B>;
 /**
  * Partition set values using predicate
- * @tsplus fluent fncts.HashSet partition
+ * @tsplus pipeable fncts.HashSet partition
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function partition_<A, B extends A>(self: HashSet<A>, p: Refinement<A, B>): readonly [HashSet<A>, HashSet<B>];
-export declare function partition_<A>(self: HashSet<A>, p: Predicate<A>): readonly [HashSet<A>, HashSet<A>];
+export declare function partition<A, B extends A>(p: Refinement<A, B>): (self: HashSet<A>) => readonly [HashSet<A>, HashSet<B>];
+export declare function partition<A>(p: Predicate<A>): (self: HashSet<A>) => readonly [HashSet<A>, HashSet<A>];
 /**
  * Partition set values using predicate
  */
-export declare function partitionMap_<B, C>(B: P.HashEq<B>, C: P.HashEq<C>): <A>(self: HashSet<A>, f: (a: A) => Either<B, C>) => 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 fluent fncts.HashSet foldLeft
+ * @tsplus pipeable fncts.HashSet foldLeft
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function foldLeft_<A, B>(fa: HashSet<A>, b: B, f: (b: B, v: A) => B): B;
+export declare function foldLeft<A, B>(b: B, f: (b: B, v: A) => B): (self: HashSet<A>) => B;
 /**
- * @tsplus fluent fncts.HashSet join
+ * @tsplus pipeable fncts.HashSet join
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function join_(self: HashSet<string>, separator: string): string;
+export declare function join(separator: string): (self: HashSet<string>) => string;
 /**
  * Form the set difference
- * @tsplus fluent fncts.HashSet difference
+ * @tsplus pipeable fncts.HashSet difference
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function difference_<A>(x: HashSet<A>, y: Iterable<A>): HashSet<A>;
+export declare function difference<A>(that: Iterable<A>): (self: HashSet<A>) => HashSet<A>;
 /**
  * true if all elements match predicate
- * @tsplus fluent fncts.HashSet every
+ * @tsplus pipeable fncts.HashSet every
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function every_<A>(self: HashSet<A>, predicate: Predicate<A>): boolean;
+export declare function every<A>(predicate: Predicate<A>): (self: HashSet<A>) => boolean;
 /**
  * The set of elements which are in both the first and second set,
  *
  * the hash and equal of the 2 sets has to be the same
+ * @tsplus pipeable fncts.HashSet intersection
+ * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function intersection_<A>(self: HashSet<A>, that: Iterable<A>): HashSet<A>;
+export declare function intersection<A>(that: Iterable<A>): (self: HashSet<A>) => HashSet<A>;
 /**
  * `true` if and only if every element in the first set is an element of the second set,
  *
  * the hash and equal of the 2 sets has to be the same
+ * @tsplus pipeable fncts.HashSet isSubset
+ * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function isSubset_<A>(x: HashSet<A>, y: HashSet<A>): boolean;
+export declare function isSubset<A>(that: HashSet<A>): (self: HashSet<A>) => boolean;
 /**
  * true if one or more elements match predicate
- * @tsplus fluent fncts.HashSet exists
+ * @tsplus pipeable fncts.HashSet some
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function exists_<A>(set: HashSet<A>, predicate: Predicate<A>): boolean;
+export declare function some<A>(predicate: Predicate<A>): (self: HashSet<A>) => boolean;
 /**
  * Form the union of two sets,
  *
  * the hash and equal of the 2 sets has to be the same
- * @tsplus fluent fncts.HashSet union
+ * @tsplus pipeable fncts.HashSet union
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function union_<A>(l: HashSet<A>, r: Iterable<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/chunksOf.d.ts

@@ -1,6 +1,6 @@
 import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
 /**
- * @tsplus fluent fncts.ImmutableArray chunksOf
+ * @tsplus pipeable fncts.ImmutableArray chunksOf
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api/chunksOf"
  */
-export declare function chunksOf_<A>(self: ImmutableArray<A>, n: number): ImmutableArray<ImmutableArray<A>>;
+export declare function chunksOf(n: number): <A>(self: import("../definition").ImmutableArray<A>) => import("../definition").ImmutableArray<import("../definition").ImmutableArray<A>>;

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

@@ -1,6 +1,6 @@
 import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
 /**
- * @tsplus fluent fncts.ImmutableArray slice
+ * @tsplus pipeable fncts.ImmutableArray slice
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api/slice"
  */
-export declare function slice_<A>(self: ImmutableArray<A>, start?: number, end?: number): ImmutableArray<A>;
+export declare function slice(start?: number, end?: number): <A>(self: import("../definition").ImmutableArray<A>) => import("../definition").ImmutableArray<A>;

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

@@ -1,6 +1,6 @@
 import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
 /**
- * @tsplus fluent fncts.ImmutableArray splitAt
+ * @tsplus pipeable fncts.ImmutableArray splitAt
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api/splitAt"
  */
-export declare function splitAt_<A>(as: ImmutableArray<A>, n: number): readonly [ImmutableArray<A>, ImmutableArray<A>];
+export declare function splitAt(n: number): <A>(as: import("../definition").ImmutableArray<A>) => readonly [import("../definition").ImmutableArray<A>, import("../definition").ImmutableArray<A>];

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

@@ -1,7 +1,7 @@
-import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
+import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
 /**
- * @tsplus fluent fncts.ImmutableArray splitWhere
+ * @tsplus pipeable fncts.ImmutableArray splitWhere
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api/splitWhere"
  */
-export declare function splitWhere_<A>(self: ImmutableArray<A>, p: Predicate<A>): readonly [ImmutableArray<A>, ImmutableArray<A>];
+export declare function splitWhere<A>(p: Predicate<A>): (self: ImmutableArray<A>) => readonly [ImmutableArray<A>, ImmutableArray<A>];