@fncts/base 0.0.1

package/_src/typeclass/Hashable/hash.ts

@@ -0,0 +1,208 @@
+import { isHashable } from "@fncts/base/typeclass/Hashable/definition";
+import { PCGRandom } from "@fncts/base/util/PCGRandom";
+import { isArray, isDefined, isIterable, isPlain } from "@fncts/base/util/predicates";
+
+const CACHE  = new WeakMap<any, number>();
+const RANDOM = new PCGRandom((Math.random() * 4294967296) >>> 0);
+
+let _current = 0;
+
+/**
+ * @tsplus static fncts.HashableOps string
+ */
+export function hashString(str: string) {
+  return optimize(_hashString(str));
+}
+
+function _hashString(str: string) {
+  let h = 5381;
+  let i = str.length;
+  while (i) h = (h * 33) ^ str.charCodeAt(--i);
+  return h;
+}
+
+/**
+ * @tsplus static fncts.HashableOps number
+ */
+export function hashNumber(n: number): number {
+  return optimize(_hashNumber(n));
+}
+
+function _hashNumber(n: number): number {
+  if (n !== n || n === Infinity) return 0;
+  let h = n | 0;
+  if (h !== n) h ^= n * 0xffffffff;
+  // eslint-disable-next-line no-param-reassign
+  while (n > 0xffffffff) h ^= n /= 0xffffffff;
+  return n;
+}
+
+/**
+ * @tsplus static fncts.HashableOps object
+ */
+export function hashObject(value: object): number {
+  return optimize(_hashObject(value));
+}
+
+function _hashObject(value: object): number {
+  let h = CACHE.get(value);
+  if (isDefined(h)) return h;
+  if (isHashable(value)) {
+    h = value[Symbol.hash];
+  } else if (isArray(value)) {
+    h = _hashArray(value);
+  } else if (isIterable(value)) {
+    h = _hashIterator(value[Symbol.iterator]());
+  } else if (isPlain(value)) {
+    h = _hashPlainObject(value);
+  } else {
+    h = _current++;
+  }
+  CACHE.set(value, h);
+  return h;
+}
+
+/**
+ * @tsplus static fncts.HashableOps plainObject
+ */
+export function hashPlainObject(o: any) {
+  return optimize(_hashPlainObject(o));
+}
+
+function _hashPlainObject(o: any): number {
+  CACHE.set(o, randomInt());
+  const keys = Object.keys(o);
+  let h      = 12289;
+  for (let i = 0; i < keys.length; i++) {
+    h       = _combineHash(h, _hashString(keys[i]!));
+    const c = CACHE.get(o[keys[i]!]);
+    h       = c ? _combineHash(h, c) : _combineHash(h, _hash((o as any)[keys[i]!]));
+  }
+  return h;
+}
+
+/**
+ * @tsplus static fncts.HashableOps miscRef
+ */
+export function hashMiscRef(o: any) {
+  return optimize(_hashMiscRef(o));
+}
+
+function _hashMiscRef(o: any): number {
+  let h = CACHE.get(o);
+  if (isDefined(h)) return h;
+  h = randomInt();
+  CACHE.set(o, h);
+  return h;
+}
+
+/**
+ * @tsplus static fncts.HashableOps array
+ */
+export function hashArray(arr: Array<any> | ReadonlyArray<any>): number {
+  return optimize(_hashArray(arr));
+}
+
+function _hashArray(arr: Array<any> | ReadonlyArray<any>): number {
+  let h = 6151;
+  for (let i = 0; i < arr.length; i++) {
+    h = _combineHash(_hashNumber(i), _hash(arr[i]));
+  }
+  return h;
+}
+
+/**
+ * @tsplus static fncts.HashableOps iterator
+ */
+export function hashIterator(it: Iterator<any>): number {
+  return optimize(_hashIterator(it));
+}
+
+function _hashIterator(it: Iterator<any>): number {
+  let res: IteratorResult<any>;
+  let h = 6151;
+  while (!(res = it.next()).done) {
+    h = _combineHash(h, hashUnknown(res.value));
+  }
+  return h;
+}
+
+/**
+ * @tsplus static fncts.HashableOps unknown
+ */
+export function hashUnknown(value: unknown): number {
+  return optimize(_hash(value));
+}
+
+function isZero(value: unknown): boolean {
+  return value === null || value === void 0 || value === false;
+}
+
+function _hash(arg: any): number {
+  let x = arg;
+  if (isZero(x)) return 0;
+  if (typeof x.valueOf === "function" && x.valueOf !== Object.prototype.valueOf) {
+    x = x.valueOf();
+    if (isZero(x)) return 0;
+  }
+  switch (typeof x) {
+    case "number":
+      return _hashNumber(x);
+    case "string":
+      return _hashString(x);
+    case "function":
+      return _hashMiscRef(x);
+    case "object":
+      return _hashObject(x);
+    case "boolean":
+      return x === true ? 1 : 0;
+    case "symbol":
+      return _hashUniqueSymbol(x);
+    case "bigint":
+      return _hashString(x.toString(10));
+    case "undefined": {
+      return 0;
+    }
+  }
+}
+
+/**
+ * @tsplus static fncts.HashableOps combine
+ */
+export function combineHash(x: number, y: number): number {
+  return optimize(_combineHash(x, y));
+}
+
+function _combineHash(x: number, y: number): number {
+  return (x * 53) ^ y;
+}
+
+/**
+ * @tsplus static fncts.HashableOps symbol
+ */
+export function hashUniqueSymbol(sym: symbol): number {
+  return optimize(_hashUniqueSymbol(sym));
+}
+
+const SYMBOL_CACHE = new Map<symbol, number>();
+
+function _hashUniqueSymbol(sym: symbol): number {
+  let h = SYMBOL_CACHE.get(sym);
+  if (isDefined(h)) {
+    return h;
+  }
+  h = randomInt();
+  SYMBOL_CACHE.set(sym, h);
+  return h;
+}
+
+/**
+ * @tsplus static fncts.HashableOps optimize
+ */
+export function optimize(n: number): number {
+  return (n & 0xbfffffff) | ((n >>> 1) & 0x40000000);
+}
+
+function randomInt(): number {
+  return RANDOM.integer(0x7fffffff);
+}

package/_src/typeclass/Hashable.ts

@@ -0,0 +1,4 @@
+// codegen:start { preset: barrel, include: Hashable/*.ts }
+export * from "./Hashable/definition.js";
+export * from "./Hashable/hash.js";
+// codegen:end

package/_src/typeclass/Monad.ts

@@ -0,0 +1,26 @@
+import type { ApplicativeMin } from "@fncts/base/typeclass/Applicative";
+import type { ChainMin } from "@fncts/base/typeclass/Chain";
+
+import { Applicative } from "@fncts/base/typeclass/Applicative";
+import { FlatMap } from "@fncts/base/typeclass/Chain";
+
+export interface Monad<F extends HKT, FC = HKT.None> extends Applicative<F, FC>, FlatMap<F, FC> {}
+
+/**
+ * @tsplus type fncts.MonadOps
+ */
+export interface MonadOps {}
+
+export const Monad: MonadOps = {};
+
+export type MonadMin<F extends HKT, FC = HKT.None> = ApplicativeMin<F, FC> & ChainMin<F, FC>;
+
+/**
+ * @tsplus static fncts.MonadOps __call
+ */
+export function mkMonad<F extends HKT, FC = HKT.None>(F: MonadMin<F, FC>): Monad<F, FC> {
+  return HKT.instance<Monad<F, FC>>({
+    ...Applicative(F),
+    ...FlatMap(F),
+  });
+}

package/_src/typeclass/MonadExcept.ts

@@ -0,0 +1,47 @@
+import type { ApplicativeExceptMin } from "@fncts/base/typeclass/ApplicativeExcept";
+import type { MonadMin } from "@fncts/base/typeclass/Monad";
+
+import { ApplicativeExcept } from "@fncts/base/typeclass/ApplicativeExcept";
+import { Monad } from "@fncts/base/typeclass/Monad";
+
+/**
+ * @tsplus type fncts.MonadExcept
+ */
+export interface MonadExcept<F extends HKT.CovariantE, FC = HKT.None> extends Monad<F, FC>, ApplicativeExcept<F, FC> {
+  readonly absolve: absolve<F, FC>;
+}
+
+/**
+ * @tsplus type fncts.MonadExceptOps
+ */
+export interface MonadExceptOps {}
+
+export const MonadExcept: MonadExceptOps = {};
+
+export type MonadExceptMin<F extends HKT.CovariantE, FC = HKT.None> = MonadMin<F, FC> & ApplicativeExceptMin<F, FC>;
+
+/**
+ * @tsplus static fncts.MonadExceptOps __call
+ */
+export function mkMonadExcept<F extends HKT.CovariantE, FC = HKT.None>(F: MonadExceptMin<F, FC>): MonadExcept<F, FC>;
+export function mkMonadExcept<F>(F: MonadExceptMin<HKT.FCoE<F>>): MonadExcept<HKT.FCoE<F>> {
+  return HKT.instance<MonadExcept<HKT.FCoE<F>>>({
+    ...Monad(F),
+    ...ApplicativeExcept(F),
+    absolve: absolveF(F),
+  });
+}
+
+export interface absolve<F extends HKT, FC = HKT.None> {
+  <K, Q, W, X, I, S, R, E, E1, A>(
+    fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, Either<HKT.OrFix<FC, "E", E1>, A>>,
+  ): HKT.Kind<F, FC, K, Q, W, X, I, S, R, HKT.Mix<F, "E", [E, E1]>, A>;
+}
+
+/**
+ * @tsplus static fncts.MonadExceptOps absolveF
+ */
+export function absolveF<F extends HKT.CovariantE, FC = HKT.None>(F: MonadExceptMin<F, FC>): absolve<F, FC>;
+export function absolveF<F>(F: MonadExceptMin<HKT.FCoE<F>>): absolve<HKT.FCoE<F>> {
+  return (fa) => F.flatMap_(fa, (r) => r.match(F.fail, F.pure));
+}

package/_src/typeclass/Monoid.ts

@@ -0,0 +1,31 @@
+import type { SemigroupMin } from "@fncts/base/typeclass/Semigroup";
+
+import { Semigroup } from "@fncts/base/typeclass/Semigroup";
+
+/**
+ * @tsplus type fncts.Monoid
+ */
+export interface Monoid<A> extends Semigroup<A> {
+  readonly nat: A;
+}
+
+/**
+ * @tsplus type fncts.MonoidOps
+ */
+export interface MonoidOps {}
+
+export const Monoid: MonoidOps = {};
+
+export type MonoidMin<A> = SemigroupMin<A> & {
+  readonly nat: A;
+};
+
+/**
+ * @tsplus static fncts.MonoidOps __call
+ */
+export function mkMonoid<A>(F: MonoidMin<A>): Monoid<A> {
+  return {
+    ...Semigroup(F),
+    nat: F.nat,
+  };
+}

package/_src/typeclass/Nil.ts

@@ -0,0 +1,23 @@
+/**
+ * @tsplus type fncts.Nil
+ */
+export interface Nil<F extends HKT, FC = HKT.None> extends HKT.Typeclass<F, FC> {
+  readonly nil: nil<F, FC>;
+}
+
+export type NilMin<F extends HKT, FC = HKT.None> = {
+  readonly nil: nil<F, FC>;
+};
+
+export interface nil<F extends HKT, FC = HKT.None> {
+  <
+    K = HKT.Low<F, "K">,
+    Q = HKT.Low<F, "Q">,
+    W = HKT.Low<F, "W">,
+    X = HKT.Low<F, "X">,
+    I = HKT.Low<F, "I">,
+    S = HKT.Low<F, "S">,
+    R = HKT.Low<F, "R">,
+    E = HKT.Low<F, "E">,
+  >(): HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, never>;
+}

package/_src/typeclass/Ord/api/contramap.ts

@@ -0,0 +1,13 @@
+import type { Ord } from "@fncts/base/typeclass/Ord/definition";
+
+/**
+ * @tsplus fluent fncts.Ord contramap
+ */
+export function contramap<A, B>(self: Ord<A>, f: (b: B) => A): Ord<B> {
+  return {
+    compare_: (x, y) => self.compare_(f(x), f(y)),
+    compare: (y) => (x) => self.compare_(f(x), f(y)),
+    equals_: (x, y) => self.equals_(f(x), f(y)),
+    equals: (y) => (x) => self.equals_(f(x), f(y)),
+  };
+}

package/_src/typeclass/Ord/api/max.ts

@@ -0,0 +1,9 @@
+import type { Ord } from "@fncts/base/typeclass/Ord/definition";
+
+/**
+ * @tsplus static fncts.OrdOps max
+ * @tsplus getter fncts.Ord max
+ */
+export function max_<A>(O: Ord<A>): (x: A, y: A) => A {
+  return (x, y) => (x === y || O.compare_(x, y) > -1 ? x : y);
+}

package/_src/typeclass/Ord/api/min.ts

@@ -0,0 +1,9 @@
+import type { Ord } from "@fncts/base/typeclass/Ord/definition";
+
+/**
+ * @tsplus static fncts.OrdOps min
+ * @tsplus getter fncts.Ord min
+ */
+export function min_<A>(O: Ord<A>): (x: A, y: A) => A {
+  return (x, y) => (x === y || O.compare_(x, y) < 1 ? x : y);
+}

package/_src/typeclass/Ord/api.ts

@@ -0,0 +1,5 @@
+// codegen:start { preset: barrel, include: api/*.ts }
+export * from "./api/contramap.js";
+export * from "./api/max.js";
+export * from "./api/min.js";
+// codegen:end

package/_src/typeclass/Ord/definition.ts

@@ -0,0 +1,43 @@
+import type { equals_ } from "@fncts/base/typeclass/Eq";
+import type { Ordering } from "@fncts/base/typeclass/Ordering";
+
+import { Eq } from "@fncts/base/typeclass/Eq";
+
+/**
+ * @tsplus type fncts.Ord
+ */
+export interface Ord<A> extends Eq<A> {
+  readonly compare_: compare_<A>;
+  readonly compare: compare<A>;
+}
+
+/**
+ * @tsplus type fncts.OrdOps
+ */
+export interface OrdOps {}
+
+export const Ord: OrdOps = {};
+
+export type OrdMin<A> = {
+  compare_: compare_<A>;
+  equals_: equals_<A>;
+};
+
+/**
+ * @tsplus static fncts.OrdOps __call
+ */
+export function mkOrd<A>(O: OrdMin<A>): Ord<A> {
+  return {
+    ...Eq(O),
+    compare_: O.compare_,
+    compare: (y) => (x) => O.compare_(x, y),
+  };
+}
+
+export interface compare_<A> {
+  (x: A, y: A): Ordering;
+}
+
+export interface compare<A> {
+  (y: A): (x: A) => Ordering;
+}

package/_src/typeclass/Ord/instances.ts

@@ -0,0 +1,30 @@
+import { Monoid } from "@fncts/base/typeclass/Monoid";
+import { Ord } from "@fncts/base/typeclass/Ord/definition";
+import { Ordering } from "@fncts/base/typeclass/Ordering";
+import { Semigroup } from "@fncts/base/typeclass/Semigroup";
+
+/**
+ * @tsplus static fncts.OrdOps getSemigroup
+ */
+export function getSemigroup<A = never>(): Semigroup<Ord<A>> {
+  return Semigroup({
+    combine_: (x, y) =>
+      Ord({
+        compare_: (a1, a2) => {
+          const ox = x.compare_(a1, a2);
+          return ox !== 0 ? ox : y.compare_(a1, a2);
+        },
+        equals_: (a1, a2) => x.equals_(a1, a2) && y.equals_(a1, a2),
+      }),
+  });
+}
+
+/**
+ * @tsplus static fncts.OrdOps getMonoid
+ */
+export function getMonoid<A = never>(): Monoid<Ord<A>> {
+  return Monoid({
+    ...Ord.getSemigroup<A>(),
+    nat: Ord({ compare_: () => Ordering.EQ, equals_: () => true }),
+  });
+}

package/_src/typeclass/Ord.ts

@@ -0,0 +1,5 @@
+// codegen:start { preset: barrel, include: Ord/*.ts }
+export * from "./Ord/api.js";
+export * from "./Ord/definition.js";
+export * from "./Ord/instances.js";
+// codegen:end

package/_src/typeclass/Ordering.ts

@@ -0,0 +1,42 @@
+export type Ordering = -1 | 0 | 1;
+
+/**
+ * @tsplus static fncts.Ordering LT
+ */
+export const LT = -1;
+/**
+ * @tsplus static fncts.Ordering EQ
+ */
+export const EQ = 0;
+/**
+ * @tsplus static fncts.Ordering GT
+ */
+export const GT = 1;
+
+/**
+ * @tsplus type fncts.Ordering
+ */
+export interface OrderingOps {}
+
+export const Ordering: OrderingOps = {};
+
+/**
+ * @tsplus static fncts.Ordering sign
+ */
+export function sign(n: number): Ordering {
+  return n <= -1 ? Ordering.LT : n >= 1 ? Ordering.GT : Ordering.EQ;
+}
+
+/**
+ * @tsplus static fncts.Ordering invert
+ */
+export function invert(O: Ordering): Ordering {
+  switch (O) {
+    case Ordering.LT:
+      return Ordering.GT;
+    case Ordering.GT:
+      return Ordering.LT;
+    case Ordering.EQ:
+      return Ordering.EQ;
+  }
+}

package/_src/typeclass/Pointed.ts

@@ -0,0 +1,37 @@
+export interface Pointed<F extends HKT, FC = HKT.None> extends HKT.Typeclass<F, FC> {
+  readonly pure: pure<F, FC>;
+}
+
+export type PointedMin<F extends HKT, FC = HKT.None> = {
+  readonly pure: pure<F, FC>;
+};
+
+/**
+ * @tsplus type fncts.PointedOps
+ */
+export interface PointedOps {}
+
+export const Pointed: PointedOps = {};
+
+/**
+ * @tsplus static fncts.PointedOps __call
+ */
+export function mkPointed<F extends HKT, FC = HKT.None>(F: PointedMin<F, FC>): Pointed<F, FC> {
+  return HKT.instance<Pointed<F, FC>>(F);
+}
+
+export interface pure<F extends HKT, C = HKT.None> {
+  <
+    A,
+    K = HKT.Low<F, "K">,
+    Q = HKT.Low<F, "Q">,
+    W = HKT.Low<F, "W">,
+    X = HKT.Low<F, "X">,
+    I = HKT.Low<F, "I">,
+    S = HKT.Low<F, "S">,
+    R = HKT.Low<F, "R">,
+    E = HKT.Low<F, "E">,
+  >(
+    a: A,
+  ): HKT.Kind<F, C, K, Q, W, X, I, S, R, E, A>;
+}