@fncts/base 0.0.1

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

@@ -0,0 +1,67 @@
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import type { Eq } from "@fncts/base/typeclass";
+export declare const SIZE = 5;
+export declare const BUCKET_SIZE: number;
+export declare const MASK: number;
+export declare const MAX_INDEX_NODE: number;
+export declare const MIN_ARRAY_NODE: number;
+export declare function arrayUpdate<A>(mutate: boolean, at: number, v: A, arr: A[]): A[];
+export declare function arraySpliceOut<A>(mutate: boolean, at: number, arr: A[]): A[];
+export declare function arraySpliceIn<A>(mutate: boolean, at: number, v: A, arr: A[]): A[];
+/**
+ * Hamming weight.
+ *
+ * Taken from: http://jsperf.com/hamming-weight
+ */
+export declare function popcount(x: number): number;
+export declare function hashFragment(shift: number, h: number): number;
+export declare function toBitmap(x: number): number;
+export declare function fromBitmap(bitmap: number, bit: number): number;
+export declare type Node<K, V> = LeafNode<K, V> | CollisionNode<K, V> | IndexedNode<K, V> | ArrayNode<K, V> | EmptyNode<K, V>;
+export interface SizeRef {
+    value: number;
+}
+export declare class EmptyNode<K, V> {
+    readonly _tag = "EmptyNode";
+    modify(edit: number, keyEq: KeyEq<K>, shift: number, f: UpdateFn<V>, hash: number, key: K, size: SizeRef): EmptyNode<never, never> | LeafNode<K, V>;
+}
+export declare const _EmptyNode: EmptyNode<never, never>;
+export declare function isEmptyNode(a: unknown): a is EmptyNode<unknown, unknown>;
+export declare function isLeaf<K, V>(node: Node<K, V>): node is EmptyNode<K, V> | LeafNode<K, V> | CollisionNode<K, V>;
+export declare function canEditNode<K, V>(edit: number, node: Node<K, V>): boolean;
+export declare type KeyEq<K> = Eq<K>["equals_"];
+export declare type UpdateFn<V> = (v: Maybe<V>) => Maybe<V>;
+export declare class LeafNode<K, V> {
+    readonly edit: number;
+    readonly hash: number;
+    readonly key: K;
+    value: Maybe<V>;
+    readonly _tag = "LeafNode";
+    constructor(edit: number, hash: number, key: K, value: Maybe<V>);
+    modify(edit: number, keyEq: KeyEq<K>, shift: number, f: UpdateFn<V>, hash: number, key: K, size: SizeRef): Node<K, V>;
+}
+export declare class CollisionNode<K, V> {
+    edit: number;
+    hash: number;
+    children: Array<Node<K, V>>;
+    readonly _tag = "CollisionNode";
+    constructor(edit: number, hash: number, children: Array<Node<K, V>>);
+    modify(edit: number, keyEq: KeyEq<K>, shift: number, f: UpdateFn<V>, hash: number, key: K, size: SizeRef): Node<K, V>;
+}
+declare class IndexedNode<K, V> {
+    edit: number;
+    mask: number;
+    children: Array<Node<K, V>>;
+    readonly _tag = "IndexedNode";
+    constructor(edit: number, mask: number, children: Array<Node<K, V>>);
+    modify(edit: number, keyEq: KeyEq<K>, shift: number, f: UpdateFn<V>, hash: number, key: K, size: SizeRef): Node<K, V>;
+}
+export declare class ArrayNode<K, V> {
+    edit: number;
+    size: number;
+    children: Array<Node<K, V>>;
+    readonly _tag = "ArrayNode";
+    constructor(edit: number, size: number, children: Array<Node<K, V>>);
+    modify(edit: number, keyEq: KeyEq<K>, shift: number, f: UpdateFn<V>, hash: number, key: K, size: SizeRef): Node<K, V>;
+}
+export {};

package/collection/immutable/HashMap.d.ts

@@ -0,0 +1,2 @@
+export * from "./HashMap/api.js";
+export * from "./HashMap/definition.js";

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

@@ -0,0 +1,170 @@
+import { Refinement } from "@fncts/base/data/Refinement/definition";
+import { Predicate } from "@fncts/base/data/Predicate/definition";
+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";
+/**
+ * @tsplus fluent fncts.HashSet add
+ * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
+ */
+export declare function add_<A>(set: HashSet<A>, value: 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>;
+/**
+ * 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>;
+/**
+ * Appy f to each element
+ * @tsplus fluent 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;
+/**
+ * @tsplus fluent fncts.HashSet has
+ * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
+ */
+export declare function has_<A>(set: HashSet<A>, value: A): boolean;
+/**
+ * @tsplus static fncts.HashSetOps make
+ * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
+ */
+export declare function make<A>(config: P.Hash<A> & P.Eq<A>): HashSet<A>;
+/**
+ * @tsplus static fncts.HashSetOps makeDefault
+ * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
+ */
+export declare function makeDefault<A>(): HashSet<A>;
+/**
+ * @tsplus static fncts.HashSetOps fromDefault
+ * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
+ */
+export declare function fromDefault<A>(...values: ReadonlyArray<A>): HashSet<A>;
+/**
+ * Mutate `set` within the context of `f`.
+ * @tsplus fluent 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>;
+/**
+ * @tsplus fluent fncts.HashSet remove
+ * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
+ */
+export declare function remove_<A>(set: HashSet<A>, value: 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;
+/**
+ * If element is present remove it, if not add it
+ * @tsplus fluent fncts.HashSet toggle
+ * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
+ */
+export declare function toggle_<A>(set: HashSet<A>, a: 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>;
+/**
+ * Projects a Set through a function
+ * @tsplus fluent 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>;
+/**
+ * Map + Flatten
+ */
+export declare function flatMap_<B>(C: P.HashEq<B>): <A>(set: HashSet<A>, f: (x: A) => Iterable<B>) => HashSet<B>;
+/**
+ * @tsplus fluent 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>;
+/**
+ * Creates an equal for a set
+ * @tsplus static fncts.HashSetOps getEq
+ * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
+ */
+export declare function getEq<A>(): P.Eq<HashSet<A>>;
+/**
+ * Filter set values using predicate
+ * @tsplus fluent fncts.HashSet filter
+ * @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>;
+/**
+ * Partition set values using predicate
+ * @tsplus fluent 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>];
+/**
+ * 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>];
+/**
+ * Reduce a state over the set elements
+ * @tsplus fluent 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;
+/**
+ * @tsplus fluent fncts.HashSet join
+ * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
+ */
+export declare function join_(self: HashSet<string>, separator: string): string;
+/**
+ * Form the set difference
+ * @tsplus fluent fncts.HashSet difference
+ * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
+ */
+export declare function difference_<A>(x: HashSet<A>, y: Iterable<A>): HashSet<A>;
+/**
+ * true if all elements match predicate
+ * @tsplus fluent fncts.HashSet every
+ * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
+ */
+export declare function every_<A>(self: HashSet<A>, predicate: Predicate<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
+ */
+export declare function intersection_<A>(self: HashSet<A>, that: Iterable<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
+ */
+export declare function isSubset_<A>(x: HashSet<A>, y: HashSet<A>): boolean;
+/**
+ * true if one or more elements match predicate
+ * @tsplus fluent fncts.HashSet exists
+ * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
+ */
+export declare function exists_<A>(set: HashSet<A>, predicate: Predicate<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 location "@fncts/base/collection/immutable/HashSet/api"
+ */
+export declare function union_<A>(l: HashSet<A>, r: Iterable<A>): HashSet<A>;
+/**
+ * @tsplus static 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>;

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

@@ -0,0 +1,97 @@
+import * as P from "@fncts/base/typeclass";
+/**
+ * @tsplus type fncts.HashSet
+ * @tsplus companion fncts.HashSetOps
+ */
+export declare class HashSet<A> implements Iterable<A>, P.Hashable, P.Equatable {
+    /**
+     * @internal
+     */
+    _editable: boolean;
+    /**
+     * @internal
+     */
+    _edit: number;
+    /**
+     * @internal
+     */
+    readonly config: P.HashEq<A>;
+    /**
+     * @internal
+     */
+    _root: Node<A>;
+    /**
+     * @internal
+     */
+    _size: number;
+    constructor(
+    /**
+     * @internal
+     */
+    _editable: boolean, 
+    /**
+     * @internal
+     */
+    _edit: number, 
+    /**
+     * @internal
+     */
+    config: P.HashEq<A>, 
+    /**
+     * @internal
+     */
+    _root: Node<A>, 
+    /**
+     * @internal
+     */
+    _size: number);
+    get size(): number;
+    [Symbol.iterator](): Iterator<A>;
+    get [Symbol.hash](): number;
+    [Symbol.equals](other: unknown): boolean;
+}
+interface SizeRef {
+    value: number;
+}
+export declare function canEditNode<A>(edit: number, node: Node<A>): boolean;
+export declare 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>;
+}
+export declare const _EmptyNode: EmptyNode<never>;
+export declare function isEmptyNode<A>(n: Node<A>): n is EmptyNode<A>;
+export declare class LeafNode<A> {
+    edit: number;
+    hash: number;
+    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>;
+}
+export declare class CollisionNode<A> {
+    edit: number;
+    hash: number;
+    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>;
+}
+export declare function isLeaf<A>(node: Node<A>): node is EmptyNode<A> | LeafNode<A> | CollisionNode<A>;
+export declare class IndexedNode<A> {
+    edit: number;
+    mask: number;
+    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>;
+}
+export declare class ArrayNode<A> {
+    edit: number;
+    size: number;
+    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>;
+}
+export {};

package/collection/immutable/HashSet.d.ts

@@ -0,0 +1,2 @@
+export * from "./HashSet/api.js";
+export * from "./HashSet/definition.js";