@fncts/base 0.0.1

package/_src/collection/mutable/internal.ts

@@ -0,0 +1,26 @@
+export function tableSizeFor(capacity: number) {
+  return Math.min(highestOneBit(Math.max(capacity - 1, 4) * 2), 1 << 30);
+}
+
+export function highestOneBit(i: number) {
+  /* eslint-disable no-param-reassign */
+  i |= i >> 1;
+  i |= i >> 2;
+  i |= i >> 4;
+  i |= i >> 8;
+  i |= i >> 16;
+  return i - (i >>> 1);
+  /* eslint-enable */
+}
+
+export function improveHash(originalHash: number): number {
+  return originalHash ^ (originalHash >>> 16);
+}
+
+export function copyOfArray<A>(arr: Array<A>, length: number) {
+  const out = new Array<A>(length);
+  for (let i = 0; i < arr.length; i++) {
+    out[i] = arr[i]!;
+  }
+  return arr;
+}

package/_src/control/Eval/api/sequenceArray.ts

@@ -0,0 +1,6 @@
+/**
+ * @tsplus static fncts.control.EvalOps sequenceArray
+ */
+export function sequenceArray<A>(evals: ReadonlyArray<Eval<A>>): Eval<ReadonlyArray<A>> {
+  return Eval.defer(Eval.now(evals.map((computation) => computation.run)));
+}

package/_src/control/Eval/api.ts

@@ -0,0 +1,93 @@
+import type { _A } from "@fncts/base/types";
+
+import { Chain } from "@fncts/base/control/Eval/definition";
+import { identity } from "@fncts/base/data/function";
+
+/**
+ * @tsplus fluent fncts.control.Eval and
+ */
+export function and_(self: Eval<boolean>, that: Eval<boolean>): Eval<boolean> {
+  return self.zipWith(that, (b0, b1) => b0 && b1);
+}
+
+/**
+ * @tsplus fluent fncts.control.Eval flatMap
+ */
+export function flatMap_<A, B>(self: Eval<A>, f: (a: A) => Eval<B>): Eval<B> {
+  return new Chain(self, f);
+}
+
+/**
+ * @tsplus getter fncts.control.Eval flatten
+ */
+export function flatten<A>(self: Eval<Eval<A>>): Eval<A> {
+  return self.flatMap(identity);
+}
+
+/**
+ * @tsplus fluent fncts.control.Eval map
+ */
+export function map_<A, B>(self: Eval<A>, f: (a: A) => B): Eval<B> {
+  return self.flatMap((a) => Eval.now(f(a)));
+}
+
+/**
+ * @tsplus fluent fncts.control.Eval zipWith
+ */
+export function zipWith_<A, B, C>(self: Eval<A>, fb: Eval<B>, f: (a: A, b: B) => C): Eval<C> {
+  return self.flatMap((a) => fb.map((b) => f(a, b)));
+}
+
+/**
+ * @tsplus fluent fncts.control.Eval ap
+ */
+export function ap_<A, B>(self: Eval<(a: A) => B>, fa: Eval<A>): Eval<B> {
+  return self.zipWith(fa, (f, a) => f(a));
+}
+
+/**
+ * @tsplus static fncts.control.EvalOps sequenceT
+ */
+export function sequenceT<A extends Array<Eval<any>>>(...computations: A): Eval<{ [K in keyof A]: _A<A[K]> }> {
+  return Eval.defer(Eval.now(computations.map((e) => e.run)) as Eval<any>);
+}
+
+class GenEval<A> {
+  readonly _A!: () => A;
+  *[Symbol.iterator](): Generator<GenEval<A>, A, any> {
+    return yield this;
+  }
+  constructor(readonly computation: Eval<A>) {}
+}
+
+const __adapter = (_: Eval<any>) => new GenEval(_);
+
+function runGenEval<T extends GenEval<A>, A>(
+  state: IteratorYieldResult<T> | IteratorReturnResult<A>,
+  iterator: Generator<T, A, any>,
+): Eval<A> {
+  if (state.done) {
+    return Eval.now(state.value);
+  }
+  return state.value.computation.flatMap((a) => {
+    const next = iterator.next(a);
+    return runGenEval(next, iterator);
+  });
+}
+
+/**
+ * @tsplus static fncts.control.EvalOps gen
+ */
+export function gen<T extends GenEval<any>, A>(
+  f: (i: { <A>(_: Eval<A>): GenEval<A> }) => Generator<T, A, any>,
+): Eval<A> {
+  return Eval.defer(() => {
+    const iterator = f(__adapter);
+    const state    = iterator.next();
+    return runGenEval(state, iterator);
+  });
+}
+
+// codegen:start { preset: barrel, include: api/*.ts }
+export * from "./api/sequenceArray.js";
+// codegen:end

package/_src/control/Eval/constructors.ts

@@ -0,0 +1,30 @@
+import { Defer, Value } from "@fncts/base/control/Eval/definition";
+
+/**
+ * @tsplus static fncts.control.EvalOps now
+ */
+export function now<A>(a: A): Eval<A> {
+  return new Value(a);
+}
+
+/**
+ * @tsplus static fncts.control.EvalOps defer
+ */
+export function defer<A>(make: Lazy<Eval<A>>): Eval<A> {
+  return new Defer(make);
+}
+
+/**
+ * @tsplus static fncts.control.EvalOps always
+ * @tsplus static fncts.control.EvalOps __call
+ */
+export function always<A>(make: Lazy<A>): Eval<A> {
+  return Eval.defer(Eval.now(make()));
+}
+
+const UNSET = Symbol.for("@tsplus/base/control/Eval/UNSET");
+
+export function later<A>(make: Lazy<A>): Eval<A> {
+  let v: A | typeof UNSET = UNSET;
+  return Eval(v === UNSET ? (((v = make()), (make = null!)), v) : v);
+}

package/_src/control/Eval/definition.ts

@@ -0,0 +1,67 @@
+export const EvalTypeId = Symbol.for("@fncts.base/control/Eval");
+export type EvalTypeId = typeof EvalTypeId;
+
+/**
+ * @tsplus type fncts.control.Eval
+ */
+export interface Eval<A> {
+  readonly _typeId: EvalTypeId;
+  readonly _A: () => A;
+}
+
+/**
+ * @tsplus type fncts.control.EvalOps
+ */
+export interface EvalOps {}
+
+export const Eval: EvalOps = {};
+
+export const enum EvalTag {
+  Value,
+  Defer,
+  Chain,
+}
+
+export class Value<A> implements Eval<A> {
+  readonly _tag                = EvalTag.Value;
+  readonly _typeId: EvalTypeId = EvalTypeId;
+  readonly _A!: () => A;
+  constructor(readonly value: A) {}
+}
+
+export class Defer<A> implements Eval<A> {
+  readonly _typeId: EvalTypeId = EvalTypeId;
+  readonly _tag                = EvalTag.Defer;
+  readonly _A!: () => A;
+  constructor(readonly make: () => Eval<A>) {}
+}
+
+export class Chain<A, B> implements Eval<B> {
+  readonly _typeId: EvalTypeId = EvalTypeId;
+  readonly _tag                = EvalTag.Chain;
+  readonly _A!: () => B;
+  constructor(readonly self: Eval<A>, readonly f: (a: A) => Eval<B>) {}
+}
+
+type Concrete = Value<any> | Defer<any> | Chain<any, any>;
+
+/**
+ * @tsplus smart:remove
+ */
+export function concrete(_: Eval<any>): asserts _ is Concrete {
+  //
+}
+
+/**
+ * @tsplus unify fncts.control.Eval
+ */
+export function unifyEval<X extends Eval<any>>(self: X): Eval<[X] extends [Eval<infer A>] ? A : never> {
+  return self;
+}
+
+export interface EvalF extends HKT {
+  readonly type: Eval<this["A"]>;
+  readonly variance: {
+    readonly A: "-";
+  };
+}

package/_src/control/Eval/instance.ts

@@ -0,0 +1,31 @@
+import type { EvalF } from "@fncts/base/control/Eval/definition";
+
+import { ap_, map_, zipWith_ } from "@fncts/base/control/Eval/api";
+import { now } from "@fncts/base/control/Eval/constructors";
+import * as P from "@fncts/base/typeclass";
+
+/**
+ * @tsplus static fncts.control.EvalOps Functor
+ */
+export const Functor: P.Functor<EvalF> = P.Functor({
+  map_,
+});
+
+/**
+ * @tsplus static fncts.control.EvalOps Apply
+ */
+export const Apply: P.Apply<EvalF> = P.Apply({
+  map_,
+  ap_,
+  zipWith_,
+});
+
+/**
+ * @tsplus static fncts.control.EvalOps Applicative
+ */
+export const Applicative: P.Applicative<EvalF> = P.Applicative({
+  map_,
+  ap_,
+  zipWith_,
+  pure: now,
+});

package/_src/control/Eval/run.ts

@@ -0,0 +1,41 @@
+import { concrete, EvalTag } from "@fncts/base/control/Eval/definition";
+import { Stack } from "@fncts/base/internal/Stack";
+
+/**
+ * @tsplus getter fncts.control.Eval run
+ * @tsplus static fncts.control.EvalOps run
+ */
+export function run<A>(computation: Eval<A>): A {
+  const frames = Stack<(a: any) => Eval<any>>();
+  let out      = undefined;
+  let cur      = computation;
+  while (cur !== null) {
+    concrete(cur);
+    switch (cur._tag) {
+      case EvalTag.Chain:
+        concrete(cur.self);
+        switch (cur.self._tag) {
+          case EvalTag.Value:
+            cur = cur.f(cur.self.value);
+            break;
+          default:
+            frames.push(cur.f);
+            cur = cur.self;
+            break;
+        }
+        break;
+      case EvalTag.Defer:
+        cur = cur.make();
+        break;
+      case EvalTag.Value:
+        out = cur.value;
+        if (frames.hasNext) {
+          cur = frames.pop()!(out);
+        } else {
+          cur = null!;
+        }
+        break;
+    }
+  }
+  return out;
+}

package/_src/control/Eval.ts

@@ -0,0 +1,7 @@
+// codegen:start { preset: barrel, include: Eval/*.ts }
+export * from "./Eval/api.js";
+export * from "./Eval/constructors.js";
+export * from "./Eval/definition.js";
+export * from "./Eval/instance.js";
+export * from "./Eval/run.js";
+// codegen:end

package/_src/control/LazyValue.ts

@@ -0,0 +1,24 @@
+import type { Lazy } from "@fncts/base/data/function";
+
+/**
+ * @tsplus type fncts.control.LazyValue
+ * @tsplus companion fncts.control.LazyValueOps
+ */
+export class LazyValue<A> {
+  constructor(private getValue: () => A) {}
+  get value() {
+    const computed = this.getValue();
+    Object.defineProperty(this, "value", {
+      value: computed,
+    });
+    this.getValue = null!;
+    return computed;
+  }
+}
+
+/**
+ * @tsplus static fncts.control.LazyValueOps __call
+ */
+export function lazy<A>(get: Lazy<A>): LazyValue<A> {
+  return new LazyValue(get);
+}