@fncts/base 0.0.1 → 0.0.4

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,278 @@
+/**
+ * @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

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

@@ -19,7 +19,7 @@ export function find_<K, V>(m: SortedMap<K, V>, key: K, direction: 0 | 1 = 0): S
   return {
     ord: m.ord,
     [Symbol.iterator]() {
-      const cmp = m.ord.compare_;
+      const cmp = m.ord.compare;
       let n     = m.root;
       const stack: Array<Node<K, V>> = [];
       while (n) {
@@ -124,7 +124,7 @@ export function forEachGt_<K, V>(m: SortedMap<K, V>, min: K, visit: (k: K, v: V)
  * @tsplus fluent fncts.SortedMap get
  */
 export function get_<K, V>(m: SortedMap<K, V>, key: K): Maybe<V> {
-  const cmp = m.ord.compare_;
+  const cmp = m.ord.compare;
   let n     = m.root;
   while (n) {
     const d = cmp(key, n.key);
@@ -151,7 +151,7 @@ export function get_<K, V>(m: SortedMap<K, V>, key: K): Maybe<V> {
  * @tsplus fluent fncts.SortedMap getGt
  */
 export function getGt_<K, V>(m: SortedMap<K, V>, key: K): Maybe<V> {
-  const cmp     = m.ord.compare_;
+  const cmp     = m.ord.compare;
   let n         = m.root;
   let lastValue = Nothing<V>();
   while (n) {
@@ -175,7 +175,7 @@ export function getGt_<K, V>(m: SortedMap<K, V>, key: K): Maybe<V> {
  * @tsplus fluent fncts.SortedMap getLt
  */
 export function getLt_<K, V>(m: SortedMap<K, V>, key: K): Maybe<V> {
-  const cmp     = m.ord.compare_;
+  const cmp     = m.ord.compare;
   let n         = m.root;
   let lastValue = Nothing<V>();
   while (n) {
@@ -198,7 +198,7 @@ export function getLt_<K, V>(m: SortedMap<K, V>, key: K): Maybe<V> {
  * @tsplus fluent fncts.SortedMap getLte
  */
 export function getLte_<K, V>(m: SortedMap<K, V>, key: K): Maybe<V> {
-  const cmp     = m.ord.compare_;
+  const cmp     = m.ord.compare;
   let n         = m.root;
   let lastValue = Nothing<V>();
   while (n) {
@@ -222,7 +222,7 @@ export function getLte_<K, V>(m: SortedMap<K, V>, key: K): Maybe<V> {
  * @tsplus fluent fncts.SortedMap getGte
  */
 export function getGte_<K, V>(m: SortedMap<K, V>, key: K): Maybe<V> {
-  const cmp     = m.ord.compare_;
+  const cmp     = m.ord.compare;
   let n         = m.root;
   let lastValue = Nothing<V>();
   while (n) {
@@ -251,7 +251,7 @@ export function insert_<K, V>(m: SortedMap<K, V>, key: K, value: V): SortedMap<K
   if (isEmptyNode(m.root)) {
     return new SortedMap(m.ord, new Node(Color.R, Leaf, key, value, Leaf, 1));
   }
-  const cmp = m.ord.compare_;
+  const cmp = m.ord.compare;
   const nodeStack: Array<Node<K, V>> = [];
   const orderStack: Array<Ordering>  = [];
   let n: RBNode<K, V>                = m.root;
@@ -277,49 +277,52 @@ export function insert_<K, V>(m: SortedMap<K, V>, key: K, value: V): SortedMap<K
  * Inserts an element into the correct position in the map, combining the values of keys of equal ordering
  * with a `Semigroup` instance
  */
-export function insertWith_<V>(S: Semigroup<V>) {
-  return <K>(m: SortedMap<K, V>, key: K, value: V) => {
-    if (isEmptyNode(m.root)) {
-      return new SortedMap(m.ord, new Node(Color.R, Leaf, key, value, Leaf, 1));
-    }
-    const com = S.combine_;
-    const cmp = m.ord.compare_;
-    const nodeStack: Array<Node<K, V>> = [];
-    const orderStack: Array<1 | -1>    = [];
-    let n: RBNode<K, V>                = m.root;
-    let cv: V | null                   = null;
-    while (n && !cv) {
-      const d = cmp(key, n.key);
-      nodeStack.push(n);
-      switch (d) {
-        case -1: {
-          orderStack.push(d);
-          n = n.left;
-          break;
-        }
-        case 1: {
-          orderStack.push(d);
-          n = n.right;
-          break;
-        }
-        case 0: {
-          cv = com(n.value, value);
-          break;
-        }
+export function insertWith_<K, V>(
+  m: SortedMap<K, V>,
+  key: K,
+  value: V,
+  /** @tsplus auto */ S: Semigroup<V>,
+): SortedMap<K, V> {
+  if (isEmptyNode(m.root)) {
+    return new SortedMap(m.ord, new Node(Color.R, Leaf, key, value, Leaf, 1));
+  }
+  const com = S.combine;
+  const cmp = m.ord.compare;
+  const nodeStack: Array<Node<K, V>> = [];
+  const orderStack: Array<1 | -1>    = [];
+  let n: RBNode<K, V>                = m.root;
+  let cv: V | null                   = null;
+  while (n && !cv) {
+    const d = cmp(key, n.key);
+    nodeStack.push(n);
+    switch (d) {
+      case -1: {
+        orderStack.push(d);
+        n = n.left;
+        break;
+      }
+      case 1: {
+        orderStack.push(d);
+        n = n.right;
+        break;
+      }
+      case 0: {
+        cv = com(n.value, value);
+        break;
       }
     }
-    if (cv) {
-      const u                         = nodeStack[nodeStack.length - 1]!;
-      const updated                   = new Node(u.color, u.left, u.key, cv, u.right, u.count);
-      nodeStack[nodeStack.length - 1] = updated;
-      rebuildModifiedPath(nodeStack, orderStack, 0);
-    } else {
-      nodeStack.push(new Node(Color.R, Leaf, key, value, Leaf, 1));
-      rebuildModifiedPath(nodeStack, orderStack);
-      balanceModifiedPath(nodeStack);
-    }
-    return new SortedMap(m.ord, nodeStack[0]!);
-  };
+  }
+  if (cv) {
+    const u                         = nodeStack[nodeStack.length - 1]!;
+    const updated                   = new Node(u.color, u.left, u.key, cv, u.right, u.count);
+    nodeStack[nodeStack.length - 1] = updated;
+    rebuildModifiedPath(nodeStack, orderStack, 0);
+  } else {
+    nodeStack.push(new Node(Color.R, Leaf, key, value, Leaf, 1));
+    rebuildModifiedPath(nodeStack, orderStack);
+    balanceModifiedPath(nodeStack);
+  }
+  return new SortedMap(m.ord, nodeStack[0]!);
 }
 
 /**
@@ -386,7 +389,7 @@ export function visitLte<K, V, A>(m: SortedMap<K, V>, max: K, visit: (k: K, v: V
   let current: RBNode<K, V>      = m.root;
   const stack: Stack<Node<K, V>> = Stack();
   let done  = false;
-  const cmp = m.ord.compare_;
+  const cmp = m.ord.compare;
 
   while (!done) {
     if (current) {
@@ -416,7 +419,7 @@ export function visitLt<K, V, A>(m: SortedMap<K, V>, max: K, visit: (k: K, v: V)
   let current: RBNode<K, V>      = m.root;
   const stack: Stack<Node<K, V>> = Stack();
   let done  = false;
-  const cmp = m.ord.compare_;
+  const cmp = m.ord.compare;
 
   while (!done) {
     if (current) {
@@ -446,7 +449,7 @@ export function visitGte<K, V, A>(m: SortedMap<K, V>, min: K, visit: (k: K, v: V
   let current: RBNode<K, V>      = m.root;
   const stack: Stack<Node<K, V>> = Stack();
   let done  = false;
-  const cmp = m.ord.compare_;
+  const cmp = m.ord.compare;
 
   while (!done) {
     if (current) {
@@ -479,7 +482,7 @@ export function visitGt<K, V, A>(m: SortedMap<K, V>, min: K, visit: (k: K, v: V)
   let current: RBNode<K, V>      = m.root;
   const stack: Stack<Node<K, V>> = Stack();
   let done  = false;
-  const cmp = m.ord.compare_;
+  const cmp = m.ord.compare;
 
   while (!done) {
     if (current) {
@@ -512,7 +515,7 @@ export function visitBetween<K, V, A>(m: SortedMap<K, V>, min: K, max: K, visit:
   let current: RBNode<K, V>      = m.root;
   const stack: Stack<Node<K, V>> = Stack();
   let done  = false;
-  const cmp = m.ord.compare_;
+  const cmp = m.ord.compare;
 
   while (!done) {
     if (current) {