@fncts/base 0.0.1

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

@@ -0,0 +1,213 @@
+import { HKT } from "@fncts/typelevel/HKT";
+import { Hashable } from "@fncts/base/typeclass/Hashable";
+import { Equatable } from "@fncts/base/typeclass/Equatable";
+export interface ConcF extends HKT {
+    readonly type: Conc<this["A"]>;
+    readonly index: number;
+}
+export declare const BUFFER_SIZE = 64;
+export declare const UPDATE_BUFFER_SIZE = 256;
+export declare const ConcTypeId: unique symbol;
+export declare type ConcTypeId = typeof ConcTypeId;
+export declare const enum ConcTag {
+    Empty = "Empty",
+    Concat = "Concat",
+    AppendN = "AppendN",
+    PrependN = "PrependN",
+    Update = "Update",
+    Slice = "Slice",
+    Singleton = "Singleton",
+    Chunk = "Chunk",
+    ByteChunk = "ByteChunk"
+}
+/**
+ * @tsplus type fncts.Conc
+ * @tsplus companion fncts.ConcOps
+ */
+export declare abstract class Conc<A> implements Iterable<A>, Hashable, Equatable {
+    readonly _typeId: ConcTypeId;
+    readonly _A: () => A;
+    abstract readonly length: number;
+    abstract [Symbol.iterator](): Iterator<A>;
+    get [Symbol.hash](): number;
+    [Symbol.equals](that: unknown): boolean;
+}
+declare abstract class ConcImplementation<A> extends Conc<A> {
+    abstract readonly length: number;
+    abstract readonly binary: boolean;
+    abstract get(n: number): A;
+    abstract copyToArray(n: number, dest: Array<A> | Uint8Array): void;
+    abstract readonly left: ConcImplementation<A>;
+    abstract readonly right: ConcImplementation<A>;
+    readonly depth: number;
+    arrayIterator(): Iterator<ArrayLike<A>>;
+    reverseArrayIterator(): Iterator<ArrayLike<A>>;
+    [Symbol.iterator](): Iterator<A>;
+    forEach<B>(startIndex: number, f: (i: number, a: A) => B): void;
+    private arrayLikeCache;
+    arrayLike(): ArrayLike<A>;
+    private arrayCache;
+    array(): ReadonlyArray<A>;
+    concat<B>(that: ConcImplementation<B>): ConcImplementation<A | B>;
+    take(n: number): ConcImplementation<A>;
+    append<A1>(a: A1): ConcImplementation<A | A1>;
+    prepend<A1>(a: A1): ConcImplementation<A | A1>;
+    update<A1>(index: number, a1: A1): ConcImplementation<A | A1>;
+    /**
+     * Materializes a Conc into a Conc backed by an array. This method can
+     * improve the performance of bulk operations.
+     */
+    materialize(): ConcImplementation<A>;
+}
+export declare class Empty<A> extends ConcImplementation<A> {
+    readonly _tag = ConcTag.Empty;
+    length: number;
+    depth: number;
+    left: this;
+    right: this;
+    binary: boolean;
+    get(index: number): A;
+    forEach<B>(_: number, __: (i: number, a: never) => B): void;
+    copyToArray(_: number, __: Array<A> | Uint8Array): void;
+    [Symbol.iterator](): Iterator<A>;
+    arrayIterator(): Iterator<Array<A>>;
+    reverseArrayIterator(): Iterator<Array<A>>;
+}
+export declare const _Empty: Empty<any>;
+export declare class Concat<A> extends ConcImplementation<A> {
+    readonly left: ConcImplementation<A>;
+    readonly right: ConcImplementation<A>;
+    readonly _tag = ConcTag.Concat;
+    length: number;
+    depth: number;
+    binary: boolean;
+    constructor(left: ConcImplementation<A>, right: ConcImplementation<A>);
+    get(n: number): A;
+    forEach<B>(startIndex: number, f: (i: number, a: A) => B): void;
+    copyToArray(n: number, dest: Array<A> | Uint8Array): void;
+    [Symbol.iterator](): Iterator<A>;
+    arrayIterator(): Iterator<ArrayLike<A>>;
+    reverseArrayIterator(): Iterator<ArrayLike<A>>;
+}
+declare class AppendN<A> extends ConcImplementation<A> {
+    readonly start: ConcImplementation<A>;
+    readonly buffer: Array<unknown> | Uint8Array;
+    readonly bufferUsed: number;
+    readonly binary: boolean;
+    readonly _tag = ConcTag.AppendN;
+    length: number;
+    depth: number;
+    left: Empty<any>;
+    right: Empty<any>;
+    constructor(start: ConcImplementation<A>, buffer: Array<unknown> | Uint8Array, bufferUsed: number, binary: boolean);
+    [Symbol.iterator](): Iterator<A>;
+    append<A1>(a: A1): ConcImplementation<A | A1>;
+    get(n: number): A;
+    copyToArray(n: number, dest: Array<A> | Uint8Array): void;
+    forEach<B>(startIndex: number, f: (i: number, a: A) => B): void;
+}
+declare class PrependN<A> extends ConcImplementation<A> {
+    readonly end: ConcImplementation<A>;
+    readonly buffer: Array<unknown> | Uint8Array;
+    readonly bufferUsed: number;
+    readonly binary: boolean;
+    readonly _tag = ConcTag.PrependN;
+    length: number;
+    left: Empty<any>;
+    right: Empty<any>;
+    constructor(end: ConcImplementation<A>, buffer: Array<unknown> | Uint8Array, bufferUsed: number, binary: boolean);
+    [Symbol.iterator](): Iterator<A>;
+    prepend<A1>(a: A1): ConcImplementation<A | A1>;
+    get(n: number): A;
+    copyToArray(n: number, dest: Array<A> | Uint8Array): void;
+    forEach<B>(startIndex: number, f: (i: number, a: A) => B): void;
+}
+export declare class Singleton<A> extends ConcImplementation<A> {
+    readonly value: A;
+    readonly _tag = ConcTag.Singleton;
+    length: number;
+    depth: number;
+    left: Empty<any>;
+    right: Empty<any>;
+    binary: boolean;
+    constructor(value: A);
+    get(n: number): A;
+    forEach<B>(startIndex: number, f: (i: number, a: A) => B): void;
+    copyToArray(n: number, dest: Array<A> | Uint8Array): void;
+    [Symbol.iterator](): Iterator<A, any, undefined>;
+    arrayIterator(): Iterator<A[], any, undefined>;
+    reverseArrayIterator: () => Iterator<A[], any, undefined>;
+}
+export declare class Slice<A> extends ConcImplementation<A> {
+    readonly conc: ConcImplementation<A>;
+    readonly offset: number;
+    readonly l: number;
+    readonly _tag = ConcTag.Slice;
+    length: number;
+    binary: boolean;
+    depth: number;
+    left: Empty<any>;
+    right: Empty<any>;
+    constructor(conc: ConcImplementation<A>, offset: number, l: number);
+    get(n: number): A;
+    forEach<B>(startIndex: number, f: (i: number, a: A) => B): void;
+    copyToArray(n: number, dest: Array<A> | Uint8Array): void;
+}
+export declare class Chunk<A> extends ConcImplementation<A> {
+    readonly _array: ReadonlyArray<A>;
+    readonly _tag = ConcTag.Chunk;
+    length: number;
+    depth: number;
+    left: Empty<any>;
+    right: Empty<any>;
+    binary: boolean;
+    constructor(_array: ReadonlyArray<A>);
+    get(n: number): A;
+    forEach<B>(startIndex: number, f: (i: number, a: A) => B): void;
+    copyToArray(n: number, dest: Array<A> | Uint8Array): void;
+    [Symbol.iterator](): Iterator<A>;
+    arrayIterator(): Iterator<readonly A[], any, undefined>;
+    reverseArrayIterator: () => Iterator<readonly A[], any, undefined>;
+}
+export declare class ByteChunk<A> extends ConcImplementation<A> {
+    readonly _array: Uint8Array;
+    readonly _tag = ConcTag.ByteChunk;
+    length: number;
+    depth: number;
+    left: Empty<any>;
+    right: Empty<any>;
+    binary: boolean;
+    constructor(_array: Uint8Array);
+    get(n: number): A;
+    forEach<B>(startIndex: number, f: (i: number, a: A) => B): void;
+    [Symbol.iterator](): Iterator<A>;
+    copyToArray(n: number, dest: Array<A> | Uint8Array): void;
+    arrayIterator(): Iterator<Array<A>>;
+    reverseArrayIterator(): Iterator<Array<A>>;
+}
+/**
+ * @tsplus macro remove
+ */
+export declare function concrete<A>(_: Conc<A>): asserts _ is Empty<A> | Singleton<A> | Concat<A> | AppendN<A> | PrependN<A> | Slice<A> | Chunk<A> | ByteChunk<A>;
+/**
+ * @tsplus static fncts.ConcOps fromArray
+ * @tsplus location "@fncts/base/collection/immutable/Conc/definition"
+ */
+export declare function fromArray<A>(array: ArrayLike<A>): ConcImplementation<A>;
+/**
+ * @tsplus static fncts.ConcOps isConc
+ * @tsplus location "@fncts/base/collection/immutable/Conc/definition"
+ */
+export declare function isConc<A>(u: Iterable<A>): u is Conc<A>;
+export declare function isConc(u: unknown): u is Conc<unknown>;
+/**
+ * @tsplus fluent fncts.Conc corresponds
+ * @tsplus location "@fncts/base/collection/immutable/Conc/definition"
+ */
+export declare function corresponds_<A, B>(self: Conc<A>, bs: Conc<B>, f: (a: A, b: B) => boolean): boolean;
+/**
+ * @tsplus getter fncts.Conc toArray
+ * @tsplus location "@fncts/base/collection/immutable/Conc/definition"
+ */
+export declare function toArray<A>(conc: Conc<A>): ReadonlyArray<A>;
+export {};

package/collection/immutable/Conc.d.ts

@@ -0,0 +1,6 @@
+export * from "./Conc/api.js";
+export * from "./Conc/constructors.js";
+export * from "./Conc/definition.js";
+export * from "./Conc/api/empty.js";
+export * from "./Conc/api/makeBy.js";
+export * from "./Conc/api/replicate.js";

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

@@ -0,0 +1,27 @@
+import { Dictionary } from "@fncts/base/collection/immutable/Dictionary/definition";
+/**
+ * @tsplus fluent fncts.Dictionary foldLeftWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/Dictionary/api"
+ */
+export declare function foldLeftWithIndex_<A, B>(self: Dictionary<A>, b: B, f: (k: string, b: B, a: A) => B): B;
+/**
+ * @tsplus getter fncts.Dictionary keys
+ * @tsplus location "@fncts/base/collection/immutable/Dictionary/api"
+ */
+export declare function keys<A>(self: Dictionary<A>): ReadonlyArray<string>;
+/**
+ * @tsplus fluent fncts.Dictionary map
+ * @tsplus location "@fncts/base/collection/immutable/Dictionary/api"
+ */
+export declare function map_<A, B>(self: Dictionary<A>, f: (a: A) => B): Dictionary<B>;
+/**
+ * @tsplus fluent fncts.Dictionary mapWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/Dictionary/api"
+ */
+export declare function mapWithIndex_<A, B>(self: Dictionary<A>, f: (k: string, a: A) => B): Dictionary<B>;
+/**
+ * @tsplus getter fncts.Dictionary toRecord
+ * @tsplus macro identity
+ * @tsplus location "@fncts/base/collection/immutable/Dictionary/api"
+ */
+export declare function toRecord<A>(self: Dictionary<A>): Record<string, A>;

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

@@ -0,0 +1,19 @@
+import { HKT } from "@fncts/typelevel/HKT";
+import { Newtype, NewtypeIso } from "@fncts/base/data/Newtype";
+interface DictionaryN extends HKT {
+    readonly type: Dictionary<this["A"]>;
+}
+/**
+ * @tsplus type fncts.Dictionary
+ */
+export interface Dictionary<A> extends Newtype<{
+    readonly Dictionary: unique symbol;
+}, Readonly<Record<string, A>>> {
+}
+/**
+ * @tsplus type fncts.DictionaryOps
+ */
+export interface DictionaryOps extends NewtypeIso<DictionaryN> {
+}
+export declare const Dictionary: DictionaryOps;
+export {};

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

@@ -0,0 +1,336 @@
+import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
+import { HKT } from "@fncts/typelevel/HKT";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
+import { List } from "@fncts/base/collection/immutable/List/definition";
+import { Either } from "@fncts/base/data/Either/definition";
+import { RefinementWithIndex, Refinement } from "@fncts/base/data/Refinement/definition";
+import { PredicateWithIndex, Predicate } from "@fncts/base/data/Predicate/definition";
+import type { UpdateFn } from "./internal.js";
+import type { HashMapF } from "@fncts/base/collection/immutable/HashMap/definition";
+import * as P from "@fncts/base/typeclass";
+/**
+ * Does `map` contain any elements?
+ * @tsplus getter fncts.HashMap isEmpty
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function isEmpty<K, V>(map: HashMap<K, V>): boolean;
+/**
+ * Creates a new map
+ * @tsplus static fncts.HashMapOps makeWith
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function makeWith<K, V>(config: P.HashEq<K>): HashMap<K, V>;
+/**
+ * @tsplus static fncts.HashMapOps __call
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function make<K, V>(...items: readonly (readonly [K, V])[]): HashMap<K, V>;
+/**
+ * Make a new map that has randomly cached hash and structural equality
+ * @tsplus static fncts.HashMapOps makeDefault
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function makeDefault<K, V>(): HashMap<K, V>;
+/**
+ * Makes a new map from a Foldable of key-value pairs
+ * @tsplus fluent fncts.HashMapOps fromFoldable
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function fromFoldable<F extends HKT, C, K, A>(config: P.HashEq<K>, S: P.Semigroup<A>, F: P.Foldable<F, C>): <K_, Q, W, X, I, S, R, E>(fka: import("@fncts/typelevel/HKT.js").HKT.Kind<F, C, K_, Q, W, X, I, S, R, E, readonly [K, A]>) => HashMap<K, A>;
+/**
+ * Lookup the value for `key` in `map` using custom hash.
+ * @tsplus fluent fncts.HashMap getHash
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function getHash_<K, V>(map: HashMap<K, V>, key: K, hash: number): Maybe<V>;
+/**
+ * Lookup the value for `key` in `map` using internal hash function.
+ * @tsplus fluent fncts.HashMap get
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function get_<K, V>(map: HashMap<K, V>, key: K): Maybe<V>;
+/**
+ * Does an entry exist for `key` in `map`? Uses custom `hash`.
+ * @tsplus fluent fncts.HashMap hashHash
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function hasHash_<K, V>(map: HashMap<K, V>, key: K, hash: number): boolean;
+/**
+ * Does an entry exist for `key` in `map`? Uses internal hash function.
+ * @tsplus fluent fncts.HashMap has
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function has_<K, V>(map: HashMap<K, V>, key: K): boolean;
+/**
+ * Alter the value stored for `key` in `map` using function `f` using custom hash.
+ *
+ * `f` is invoked with the current value for `k` if it exists,
+ * or no arguments if no such value exists.
+ *
+ * `modify` will always either update or insert a value into the map.
+ * Returns a map with the modified value. Does not alter `map`.
+ * @tsplus fluent fncts.HashMap modifyHash
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function modifyHash_<K, V>(map: HashMap<K, V>, key: K, hash: number, f: UpdateFn<V>): HashMap<K, V>;
+/**
+ * Alter the value stored for `key` in `map` using function `f` using internal hash function.
+ *
+ * `f` is invoked with the current value for `k` if it exists,
+ * or no arguments if no such value exists.
+ *
+ * `modify` will always either update or insert a value into the map.
+ * Returns a map with the modified value. Does not alter `map`.
+ * @tsplus fluent fncts.HashMap modify
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function modify_<K, V>(map: HashMap<K, V>, key: K, f: UpdateFn<V>): HashMap<K, V>;
+/**
+ * Store `value` for `key` in `map` using internal hash function.
+ * @tsplus fluent fncts.HashMap set
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function set_<K, V>(map: HashMap<K, V>, key: K, value: V): HashMap<K, V>;
+/**
+ * Remove the entry for `key` in `map` using internal hash.
+ * @tsplus fluent fncts.HashMap remove
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function remove_<K, V>(map: HashMap<K, V>, key: K): HashMap<K, V>;
+/**
+ * Remove many keys
+ * @tsplus fluent fncts.HashMap removeMany
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function removeMany_<K, V>(map: HashMap<K, V>, keys: Iterable<K>): HashMap<K, V>;
+/**
+ * Mark `map` as mutable.
+ * @tsplus getter fncts.HashMap beginMutation
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function beginMutation<K, V>(map: HashMap<K, V>): HashMap<K, V>;
+/**
+ * Mark `map` as immutable.
+ * @tsplus getter fncts.HashMap endMutation
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function endMutation<K, V>(map: HashMap<K, V>): HashMap<K, V>;
+/**
+ * Mutate `map` within the context of `f`.
+ * @tsplus fluent fncts.HashMap mutate
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function mutate_<K, V>(map: HashMap<K, V>, f: (map: HashMap<K, V>) => void): HashMap<K, V>;
+/**
+ * Get an IterableIterator of the map keys
+ * @tsplus getter fncts.HashMap keys
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function keys<K, V>(map: HashMap<K, V>): IterableIterator<K>;
+/**
+ * Get the set of keys
+ * @tsplus getter fncts.HashMap keySet
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function keySet<K, V>(self: HashMap<K, V>): HashSet<K>;
+/**
+ * Get the set of values
+ * @tsplus getter fncts.HashMap keySetDefault
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function toSetDefault<K, V>(map: HashMap<K, V>): HashSet<V>;
+/**
+ * Get the set of values
+ * @tsplus getter fncts.HashMap toList
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function toList<K, V>(map: HashMap<K, V>): List<readonly [K, V]>;
+/**
+ * Get the set of values
+ * @tsplus getter fncts.HashMap toArray
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function toArray<K, V>(map: HashMap<K, V>): Array<readonly [K, V]>;
+/**
+ * Get an IterableIterator of the map values
+ * @tsplus getter fncts.HashMap values
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function values<K, V>(map: HashMap<K, V>): IterableIterator<V>;
+/**
+ * Update a value if exists
+ * @tsplus fluent fncts.HashMap update
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function update_<K, V>(map: HashMap<K, V>, key: K, f: (v: V) => V): HashMap<K, V>;
+/**
+ * Apply f to each element
+ * @tsplus fluent fncts.HashMap forEachWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function forEachWithIndex_<K, V>(map: HashMap<K, V>, f: (k: K, v: V, m: HashMap<K, V>) => void): void;
+/**
+ * Apply f to each element
+ * @tsplus fluent fncts.HashMap forEach
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function forEach_<K, V>(map: HashMap<K, V>, f: (v: V, m: HashMap<K, V>) => void): void;
+/**
+ * Maps over the map entries
+ * @tsplus fluent fncts.HashMap mapWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function mapWithIndex_<K, V, A>(fa: HashMap<K, V>, f: (k: K, v: V) => A): HashMap<K, A>;
+/**
+ * Maps over the map entries
+ * @tsplus fluent fncts.HashMap map
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function map_<K, V, A>(fa: HashMap<K, V>, f: (v: V) => A): HashMap<K, A>;
+/**
+ * Chain over the map entries, the hash and equal of the 2 maps has to be the same
+ * @tsplus fluent fncts.HashMap flatMapWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function flatMapWithIndex_<K, V, A>(ma: HashMap<K, V>, f: (k: K, v: V) => HashMap<K, A>): HashMap<K, A>;
+/**
+ * Chain over the map entries, the hash and equal of the 2 maps has to be the same
+ * @tsplus fluent fncts.HashMap flatMap
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function flatMap_<K, V, A>(ma: HashMap<K, V>, f: (v: V) => HashMap<K, A>): HashMap<K, A>;
+/**
+ * Removes values that are `Nothing`
+ * @tsplus getter fncts.HashMap compact
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function compact<K, A>(map: HashMap<K, Maybe<A>>): HashMap<K, A>;
+/**
+ * Removes `Either` values into two separate `HashMaps`
+ * @tsplus getter fncts.HashMap separate
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function separate<K, A, B>(map: HashMap<K, Either<A, B>>): readonly [HashMap<K, A>, HashMap<K, B>];
+/**
+ * Filter out None and map
+ * @tsplus fluent fncts.HashMap filterMapWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function filterMapWithIndex_<K, A, B>(map: HashMap<K, A>, f: (k: K, a: A) => Maybe<B>): HashMap<K, B>;
+/**
+ * Filter out None and map
+ * @tsplus fluent fncts.HashMap filterMap
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function filterMap_<K, A, B>(map: HashMap<K, A>, f: (a: A) => Maybe<B>): HashMap<K, B>;
+/**
+ * Filter out by predicate
+ * @tsplus fluent fncts.HashMap filterWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function filterWithIndex_<K, A, B extends A>(map: HashMap<K, A>, refinement: RefinementWithIndex<K, A, B>): HashMap<K, B>;
+export declare function filterWithIndex_<K, A>(map: HashMap<K, A>, predicate: PredicateWithIndex<K, A>): HashMap<K, A>;
+/**
+ * Filter out by predicate
+ * @tsplus fluent fncts.HashMap filter
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function filter_<K, A, B extends A>(map: HashMap<K, A>, refinement: Refinement<A, B>): HashMap<K, B>;
+export declare function filter_<K, A>(map: HashMap<K, A>, predicate: Predicate<A>): HashMap<K, A>;
+/**
+ * @tsplus fluent fncts.HashMap partitionMapWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function partitionMapWithIndex_<K, V, A, B>(map: HashMap<K, V>, f: (i: K, a: V) => Either<A, B>): readonly [HashMap<K, A>, HashMap<K, B>];
+/**
+ * @tsplus fluent fncts.HashMap partitionMap
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function partitionMap_<K, V, A, B>(map: HashMap<K, V>, f: (a: V) => Either<A, B>): readonly [HashMap<K, A>, HashMap<K, B>];
+/**
+ * @tsplus fluent fncts.HashMap partitionWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function partitionWithIndex_<K, V, B extends V>(map: HashMap<K, V>, refinement: RefinementWithIndex<K, V, B>): readonly [HashMap<K, V>, HashMap<K, B>];
+export declare function partitionWithIndex_<K, V>(map: HashMap<K, V>, predicate: PredicateWithIndex<K, V>): readonly [HashMap<K, V>, HashMap<K, V>];
+/**
+ * @tsplus fluent fncts.HashMap partition
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function partition_<K, V, B extends V>(map: HashMap<K, V>, refinement: Refinement<V, B>): readonly [HashMap<K, V>, HashMap<K, B>];
+export declare function partition_<K, V>(map: HashMap<K, V>, predicate: Predicate<V>): readonly [HashMap<K, V>, HashMap<K, V>];
+/**
+ * Reduce a state over the map entries
+ * @tsplus fluent fncts.HashMap foldLeftWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function foldLeftWithIndex_<K, V, Z>(map: HashMap<K, V>, z: Z, f: (k: K, z: Z, v: V) => Z): Z;
+/**
+ * Reduce a state over the map entries
+ * @tsplus fluent fncts.HashMap foldLeft
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function foldLeft_<K, V, Z>(map: HashMap<K, V>, z: Z, f: (z: Z, v: V) => Z): Z;
+export declare const traverseWithIndex_: P.traverseWithIndex_<HashMapF>;
+export declare const traverseWithIndex: P.traverseWithIndex<HashMapF>;
+/**
+ * @tsplus getter fncts.HashMap traverseWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare const traverseWithIndexSelf: P.traverseWithIndexSelf<HashMapF>;
+export declare const traverse_: P.traverse_<HashMapF>;
+export declare const traverse: P.traverse<HashMapF>;
+/**
+ * @tsplus fluent fncts.HashMap unsafeGet
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function unsafeGet_<K, V>(self: HashMap<K, V>, key: K): V | undefined;
+/**
+ * @tsplus getter fncts.HashMap traverse
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare const traverseSelf: P.traverseSelf<HashMapF>;
+export declare const witherWithIndex_: P.witherWithIndex_<HashMapF>;
+export declare const witherWithIndex: P.witherWithIndex<HashMapF>;
+/**
+ * @tsplus getter fncts.HashMap witherWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare const witherWithIndexSelf: P.witherWithIndexSelf<HashMapF>;
+export declare const wither_: P.wither_<HashMapF>;
+export declare const wither: P.wither<HashMapF>;
+/**
+ * @tsplus getter fncts.HashMap wither
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare const witherSelf: P.witherSelf<HashMapF>;
+export declare const wiltWithIndex_: P.wiltWithIndex_<HashMapF>;
+export declare const wiltWithIndex: P.wiltWithIndex<HashMapF>;
+/**
+ * @tsplus getter fncts.HashMap wiltWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare const wiltWithIndexSelf: P.wiltWithIndexSelf<HashMapF>;
+export declare const wilt_: P.wilt_<HashMapF>;
+export declare const wilt: P.wilt<HashMapF>;
+/**
+ * @tsplus getter fncts.HashMap wilt
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare const wiltSelf: P.wiltSelf<HashMapF>;
+/**
+ * @tsplus fluent fncts.HashMap unionWith
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function unionWith_<K, A>(self: HashMap<K, A>, that: Iterable<readonly [K, A]>, f: (x: A, y: A) => A): HashMap<K, A>;
+/**
+ * @tsplus fluent fncts.HashMap union
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function union_<K, A>(self: HashMap<K, A>, that: Iterable<readonly [K, A]>): HashMap<K, A>;
+/**
+ * @tsplus fluent fncts.HashMap pop
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
+ */
+export declare function pop_<K, A>(map: HashMap<K, A>, k: K): Maybe<readonly [A, HashMap<K, A>]>;

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

@@ -0,0 +1,44 @@
+import { HKT } from "@fncts/typelevel/HKT";
+import { Hashable } from "@fncts/base/typeclass/Hashable";
+import { Equatable } from "@fncts/base/typeclass/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";
+export interface HashMapF extends HKT {
+    readonly type: HashMap<this["K"], this["A"]>;
+    readonly variance: {
+        K: "_";
+        A: "+";
+    };
+}
+/**
+ * @tsplus type fncts.HashMap
+ * @tsplus companion fncts.HashMapOps
+ */
+export declare class HashMap<K, V> implements Iterable<readonly [K, V]>, Hashable, Equatable {
+    editable: boolean;
+    edit: number;
+    readonly config: HashEq<K>;
+    root: Node<K, V>;
+    size: number;
+    readonly _K: () => K;
+    readonly _V: () => 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;
+}
+export declare class HashMapIterator<K, V, T> implements IterableIterator<T> {
+    readonly map: HashMap<K, V>;
+    readonly f: (node: readonly [K, V]) => T;
+    v: Maybe<VisitResult<K, V, T>>;
+    constructor(map: HashMap<K, V>, f: (node: readonly [K, V]) => T);
+    next(): IteratorResult<T>;
+    [Symbol.iterator](): IterableIterator<T>;
+}
+declare type Cont<K, V, A> = [len: number, children: Node<K, V>[], i: number, f: (node: readonly [K, V]) => A, cont: Cont<K, V, A>] | undefined;
+interface VisitResult<K, V, A> {
+    value: A;
+    cont: Cont<K, V, A>;
+}
+export {};