@fncts/base 0.0.3 → 0.0.6

package/_src/collection/immutable/ImmutableNonEmptyArray/definition.ts

@@ -1,8 +1,14 @@
+import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
+
+export interface ImmutableNonEmptyArrayF extends ImmutableNonEmptyArray<any> {}
+
 /**
  * @tsplus type fncts.ImmutableNonEmptyArray
  * @tsplus companion fncts.ImmutableNonEmptyArrayOps
  */
 export class ImmutableNonEmptyArray<A> extends ImmutableArray<A> {
+  [HKT.F]!: ImmutableNonEmptyArrayF;
+  [HKT.T]!: ImmutableNonEmptyArray<HKT._A<this>>;
   constructor(readonly _array: ReadonlyNonEmptyArray<A>) {
     super(_array);
   }
@@ -22,10 +28,16 @@ export interface ReadonlyNonEmptyArray<T> extends ReadonlyArray<T> {
   readonly 0: T;
 }
 
-export interface ImmutableNonEmptyArrayF extends HKT {
-  readonly type: ImmutableNonEmptyArray<this["A"]>;
-  readonly variance: {
-    readonly A: "+";
-  };
-  readonly index: number;
+/**
+ * @tsplus getter fncts.ImmutableArray length
+ */
+export function length<A>(self: ImmutableArray<A>): number {
+  return self._array.length;
+}
+
+/**
+ * @tsplus fluent fncts.ImmutableArray isNonEmpty
+ */
+export function isNonEmpty<A>(self: ImmutableArray<A>): self is ImmutableNonEmptyArray<A> {
+  return self.length > 0;
 }

package/_src/collection/immutable/ImmutableNonEmptyArray/instances.ts

@@ -1,9 +1,11 @@
 import type { ImmutableNonEmptyArrayF } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
+import type * as P from "@fncts/base/typeclass";
 
 import {
   align_,
   alignWith_,
   ap_,
+  cross_,
   crossWith_,
   flatMap_,
   foldLeft_,
@@ -16,100 +18,88 @@ import {
   traverseWithIndex_,
 } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api";
 import { make } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/constructors";
-import * as P from "@fncts/base/typeclass";
 
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Semialign
  */
-export const Semialign: P.Semialign<ImmutableNonEmptyArrayF> = P.Semialign({
-  map_,
-  alignWith_,
-  align_,
-});
+export const Semialign: P.Semialign<ImmutableNonEmptyArrayF> = {
+  map: map_,
+  alignWith: alignWith_,
+};
 
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Functor
  */
-export const Functor: P.Functor<ImmutableNonEmptyArrayF> = P.Functor({
-  map_,
-});
+export const Functor: P.Functor<ImmutableNonEmptyArrayF> = {
+  map: map_,
+};
 
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps FunctorWithIndex
  */
-export const FunctorWithIndex: P.FunctorWithIndex<ImmutableNonEmptyArrayF> = P.FunctorWithIndex({
-  map_,
-  mapWithIndex_,
-});
+export const FunctorWithIndex: P.FunctorWithIndex<ImmutableNonEmptyArrayF> = {
+  map: map_,
+  mapWithIndex: mapWithIndex_,
+};
 
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Apply
  */
-export const Apply: P.Apply<ImmutableNonEmptyArrayF> = P.Apply({
-  map_,
-  zipWith_: crossWith_,
-  ap_,
+export const Apply: P.Apply<ImmutableNonEmptyArrayF> = ({
+  ...Functor,
+  zip: cross_,
+  zipWith: crossWith_,
 });
 
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Applicative
  */
-export const Applicative: P.Applicative<ImmutableNonEmptyArrayF> = P.Applicative({
-  map_,
-  zipWith_: crossWith_,
-  ap_,
+export const Applicative: P.Applicative<ImmutableNonEmptyArrayF> = ({
+  ...Apply,
   pure: make,
 });
 
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Monad
  */
-export const Monad: P.Monad<ImmutableNonEmptyArrayF> = P.Monad({
-  map_,
-  zipWith_: crossWith_,
-  ap_,
-  pure: make,
-  flatMap_: flatMap_,
+export const Monad: P.Monad<ImmutableNonEmptyArrayF> = ({
+  ...Applicative,
+  flatMap: flatMap_,
 });
 
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Foldable
  */
-export const Foldable: P.Foldable<ImmutableNonEmptyArrayF> = P.Foldable({
-  foldLeft_,
-  foldRight_,
+export const Foldable: P.Foldable<ImmutableNonEmptyArrayF> = ({
+  foldLeft: foldLeft_,
+  foldRight: foldRight_,
 });
 
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps FoldableWithIndex
  */
-export const FoldableWithIndex: P.FoldableWithIndex<ImmutableNonEmptyArrayF> = P.FoldableWithIndex({
-  foldLeft_,
-  foldRight_,
-  foldLeftWithIndex_,
-  foldRightWithIndex_,
+export const FoldableWithIndex: P.FoldableWithIndex<ImmutableNonEmptyArrayF> = ({
+  ...Foldable,
+  foldLeftWithIndex: foldLeftWithIndex_,
+  foldRightWithIndex: foldRightWithIndex_,
 });
 
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Traversable
  */
-export const Traversable: P.Traversable<ImmutableNonEmptyArrayF> = P.Traversable({
-  map_,
-  foldLeft_,
-  foldRight_,
-  traverse_,
+export const Traversable: P.Traversable<ImmutableNonEmptyArrayF> = ({
+  ...Functor,
+  ...Foldable,
+  traverse: traverse_,
 });
 
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps TraversableWithIndex
  */
-export const TraversableWithIndex: P.TraversableWithIndex<ImmutableNonEmptyArrayF> = P.TraversableWithIndex({
-  map_,
-  foldLeft_,
-  foldRight_,
-  traverse_,
-  mapWithIndex_,
-  foldLeftWithIndex_,
-  foldRightWithIndex_,
-  traverseWithIndex_,
+export const TraversableWithIndex: P.TraversableWithIndex<ImmutableNonEmptyArrayF> = ({
+  ...Functor,
+  ...FunctorWithIndex,
+  ...FoldableWithIndex,
+  ...Traversable,
+  traverseWithIndex: traverseWithIndex_,
 });

package/_src/collection/immutable/List/api.ts

@@ -252,15 +252,11 @@ export function reverse<A>(self: List<A>): List<A> {
   return result;
 }
 
-export function sort<A>(O: P.Ord<A>) {
-  return (self: List<A>): List<A> => sortWith_(self, O.compare_);
-}
-
 /**
  * @tsplus fluent fncts.List sort
  */
-export function sortSelf<A>(self: List<A>, O: P.Ord<A>): List<A> {
-  return self.sortWith(O.compare_);
+export function sort<A>(self: List<A>, /** @tsplus auto */ O: P.Ord<A>): List<A> {
+  return sortWith_(self, O.compare);
 }
 
 /**

package/_src/collection/immutable/RoseTree/api.ts

@@ -0,0 +1,272 @@
+import { RoseTree } from "./definition.js";
+/**
+ * @tsplus static fncts.RoseTreeOps __call
+ */
+export function make<A>(value: A, forest: Vector<RoseTree<A>> = Vector.empty()): RoseTree<A> {
+  return new RoseTree(value, forest);
+}
+
+/**
+ * @tsplus fluent fncts.RoseTree foldLeft
+ */
+export function foldLeft<A, B>(self: RoseTree<A>, b: B, f: (b: B, a: A) => B): B {
+  return foldLeftLoop(f, b, Vector(self), Vector());
+}
+
+/**
+ * @tsplus fluent fncts.RoseTree foldRight
+ */
+export function foldRight<A, B>(self: RoseTree<A>, b: B, f: (a: A, b: B) => B): B {
+  return self.foldLeft(Vector<A>(), (b, a) => b.prepend(a)).foldLeft(b, (b, a) => f(a, b));
+}
+
+/**
+ * @tsplus tailRec
+ */
+function foldLeftLoop<A, B>(
+  f: (b: B, a: A) => B,
+  b: B,
+  trees: Vector<RoseTree<A>>,
+  nextSets: Vector<Vector<RoseTree<A>>>,
+): B {
+  if (trees.isEmpty()) {
+    if (nextSets.isEmpty()) {
+      return b;
+    } else {
+      return foldLeftLoop(f, b, nextSets.unsafeHead!, nextSets.tail);
+    }
+  } else {
+    const tree = trees.unsafeHead!;
+    if (tree.forest.isEmpty()) {
+      return foldLeftLoop(f, f(b, tree.value), trees.tail, nextSets);
+    } else {
+      return foldLeftLoop(f, f(b, tree.value), tree.forest, trees.tail + nextSets);
+    }
+  }
+}
+
+/**
+ * @tsplus fluent fncts.RoseTree map
+ */
+export function map<A, B>(self: RoseTree<A>, f: (a: A) => B): RoseTree<B> {
+  return self.mapAccum(undefined, (_, a) => [undefined, f(a)])[1];
+}
+
+/**
+ * @tsplus fluent fncts.RoseTree mapAccum
+ */
+export function mapAccum<A, S, B>(
+  self: RoseTree<A>,
+  s: S,
+  f: (s: S, a: A) => readonly [S, B],
+): readonly [S, RoseTree<B>] {
+  const [state, b] = f(s, self.value);
+  return mapAccumLoop(f, state, { todo: self.forest, done: Vector(), label: b }, List());
+}
+
+/**
+ * @tsplus fluent fncts.RoseTree mapWithIndex
+ */
+export function mapWithIndex<A, B>(self: RoseTree<A>, f: (i: number, a: A) => B): RoseTree<B> {
+  return self.mapAccum(0, (idx, elem) => [idx + 1, f(idx, elem)])[1];
+}
+
+interface MapAcc<A, B> {
+  readonly todo: Vector<RoseTree<A>>;
+  readonly done: Vector<RoseTree<B>>;
+  readonly label: B;
+}
+
+/**
+ * @tsplus tailRec
+ */
+function mapAccumLoop<S, A, B>(
+  f: (s: S, a: A) => readonly [S, B],
+  state: S,
+  acc: MapAcc<A, B>,
+  stack: List<MapAcc<A, B>>,
+): readonly [S, RoseTree<B>] {
+  if (acc.todo.isEmpty()) {
+    const node = RoseTree(acc.label, acc.done.reverse);
+    if (stack.isEmpty()) {
+      return [state, node];
+    }
+    const top = stack.head;
+    return mapAccumLoop(f, state, { label: top.label, todo: top.todo, done: node + top.done }, stack.tail);
+  } else {
+    const head             = acc.todo.unsafeHead!;
+    const [state_, label_] = f(state, head.value);
+    if (head.forest.isEmpty()) {
+      return mapAccumLoop(
+        f,
+        state_,
+        { label: acc.label, todo: acc.todo.tail, done: RoseTree(label_, Vector()) + acc.done },
+        stack,
+      );
+    }
+    return mapAccumLoop(
+      f,
+      state_,
+      { label: label_, todo: head.forest, done: Vector() },
+      Cons({ label: acc.label, done: acc.done, todo: acc.todo.tail }, stack),
+    );
+  }
+}
+
+/**
+ * @tsplus static fncts.RoseTreeOps unfold
+ */
+export function unfold<A, B>(b: B, f: (b: B) => readonly [A, Vector<B>]): RoseTree<A> {
+  const [label, todo] = f(b);
+  return unfoldLoop(f, { todo, label, done: Vector() }, Nil());
+}
+
+interface UnfoldAcc<A, B> {
+  readonly todo: Vector<B>;
+  readonly done: Vector<RoseTree<A>>;
+  readonly label: A;
+}
+
+/**
+ * @tsplus tailRec
+ */
+function unfoldLoop<A, B>(
+  f: (b: B) => readonly [A, Vector<B>],
+  acc: UnfoldAcc<A, B>,
+  stack: List<UnfoldAcc<A, B>>,
+): RoseTree<A> {
+  if (acc.todo.isEmpty()) {
+    const node = RoseTree(acc.label, acc.done.reverse);
+    if (stack.isEmpty()) {
+      return node;
+    }
+    const top = stack.head;
+    return unfoldLoop(f, { label: top.label, todo: top.todo, done: node + top.done }, stack.tail);
+  } else {
+    const [label, todo] = f(acc.todo.unsafeHead!);
+    if (todo.isEmpty()) {
+      return unfoldLoop(f, { label: acc.label, todo: acc.todo.tail, done: RoseTree(label) + acc.done }, stack);
+    }
+    return unfoldLoop(
+      f,
+      { todo, label, done: Vector() },
+      Cons({ done: acc.done, label: acc.label, todo: acc.todo.tail }, stack),
+    );
+  }
+}
+
+/**
+ * @tsplus fluent fncts.RoseTree zipWith
+ */
+export function zipWith<A, B, C>(self: RoseTree<A>, that: RoseTree<B>, f: (a: A, b: B) => C): RoseTree<C> {
+  return self.zipWithAccum(that, undefined, (s, a, b) => [s, f(a, b)])[1];
+}
+
+/**
+ * @tsplus fluent fncts.RoseTree zipWithAccum
+ */
+export function zipWithAccum<A, S, B, C>(
+  self: RoseTree<A>,
+  that: RoseTree<B>,
+  s: S,
+  f: (s: S, a: A, b: B) => readonly [S, C],
+): readonly [S, RoseTree<C>] {
+  const [state, c] = f(s, self.value, that.value);
+  return zipWithAccumLoop(f, state, { todoL: self.forest, todoR: that.forest, done: Vector(), label: c }, List());
+}
+
+export interface ZipWithAcc<A, B, C> {
+  readonly todoL: Vector<RoseTree<A>>;
+  readonly todoR: Vector<RoseTree<B>>;
+  readonly done: Vector<RoseTree<C>>;
+  readonly label: C;
+}
+
+/**
+ * @tsplus tailRec
+ */
+export function zipWithAccumLoop<S, A, B, C>(
+  f: (s: S, a: A, b: B) => readonly [S, C],
+  state: S,
+  acc: ZipWithAcc<A, B, C>,
+  stack: List<ZipWithAcc<A, B, C>>,
+): readonly [S, RoseTree<C>] {
+  if (acc.todoL.isEmpty()) {
+    const node = RoseTree(acc.label, acc.done.reverse);
+    if (stack.isEmpty()) {
+      return [state, node];
+    } else {
+      const top = stack.unsafeHead!;
+      return zipWithAccumLoop(
+        f,
+        state,
+        { todoL: top.todoL, todoR: top.todoR, label: top.label, done: node + top.done },
+        stack.tail,
+      );
+    }
+  }
+  if (acc.todoR.isEmpty()) {
+    const node = RoseTree(acc.label, acc.done.reverse);
+    if (stack.isEmpty()) {
+      return [state, node];
+    } else {
+      const top = stack.unsafeHead!;
+      return zipWithAccumLoop(
+        f,
+        state,
+        { todoL: top.todoL, todoR: top.todoR, label: top.label, done: node + top.done },
+        stack.tail,
+      );
+    }
+  }
+  const treeA            = acc.todoL.unsafeHead!;
+  const treeB            = acc.todoR.unsafeHead!;
+  const a                = treeA.value;
+  const b                = treeB.value;
+  const [state_, label_] = f(state, a, b);
+  return zipWithAccumLoop(
+    f,
+    state_,
+    { todoL: treeA.forest, todoR: treeB.forest, done: Vector(), label: label_ },
+    Cons({ todoL: acc.todoL.tail, todoR: acc.todoR.tail, label: acc.label, done: acc.done }, stack),
+  );
+}
+
+/**
+ * @tsplus getter fncts.RoseTree draw
+ */
+export function draw(tree: RoseTree<string>): string {
+  return tree.value + drawLoop(Vector("\n"), { todo: tree.forest, len: tree.forest.length, done: Vector() }, List());
+}
+
+interface DrawAcc {
+  len: number;
+  todo: Vector<RoseTree<string>>;
+  done: Vector<string>;
+}
+
+/**
+ * @tsplus tailRec
+ */
+function drawLoop(indentation: Vector<string>, acc: DrawAcc, stack: List<DrawAcc>): string {
+  if (acc.todo.isEmpty()) {
+    if (stack.isEmpty()) {
+      return acc.done.reverse.join("");
+    }
+    const top = stack.head;
+    return drawLoop(indentation.pop, { len: top.len, todo: top.todo, done: acc.done + top.done }, stack.tail);
+  } else {
+    const tree   = acc.todo.unsafeHead!;
+    const rest   = acc.todo.tail;
+    const isLast = rest.length === 0;
+    return drawLoop(
+      indentation + (acc.len > 1 && !isLast ? "│  " : "   "),
+      {
+        len: tree.forest.length,
+        todo: tree.forest,
+        done: Vector(indentation.join("") + (isLast ? "└" : "├") + "─ " + tree.value),
+      },
+      Cons({ len: acc.len, todo: rest, done: acc.done }, stack),
+    );
+  }
+}

package/_src/collection/immutable/RoseTree/definition.ts

@@ -0,0 +1,29 @@
+export const RoseTreeTypeId = Symbol.for("fncts.RoseTree");
+export type RoseTreeTypeId = typeof RoseTreeTypeId;
+
+export interface RoseTreeF extends RoseTree<any> {}
+
+/**
+ * @tsplus type fncts.RoseTree
+ * @tsplus companion fncts.RoseTreeOps
+ */
+export class RoseTree<A> implements Hashable, Equatable {
+  readonly _typeId: RoseTreeTypeId = RoseTreeTypeId;
+  readonly [HKT.F]!: RoseTreeF;
+  readonly [HKT.A]!: () => A;
+  readonly [HKT.T]!: RoseTree<HKT._A<this>>;
+  constructor(readonly value: A, readonly forest: Vector<RoseTree<A>>) {}
+  [Symbol.equals](that: unknown): boolean {
+    return isRoseTree(that) ? Equatable.strictEquals(this.value, that.value) && this.forest == that.forest : false;
+  }
+  get [Symbol.hash]() {
+    let h = Hashable.symbol(RoseTreeTypeId);
+    h    ^= Hashable.unknown(this.value);
+    h    ^= Hashable.unknown(this.forest);
+    return Hashable.optimize(h);
+  }
+}
+
+export function isRoseTree(u: unknown): u is RoseTree<unknown> {
+  return hasTypeId(u, RoseTreeTypeId);
+}

package/_src/collection/immutable/RoseTree.ts

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