@fncts/base 0.0.20 → 0.0.22

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

@@ -13,531 +13,562 @@ import { Color, Leaf, Node } from "@fncts/base/collection/immutable/SortedMap/no
 import { Stack } from "@fncts/base/internal/Stack";
 
 /**
- * @tsplus fluent fncts.SortedMap find
+ * @tsplus pipeable fncts.SortedMap find
  */
-export function find_<K, V>(m: SortedMap<K, V>, key: K, direction: 0 | 1 = 0): SortedMapIterable<K, V> {
-  return {
-    ord: m.ord,
-    [Symbol.iterator]() {
-      const cmp = m.ord.compare;
-      let n     = m.root;
-      const stack: Array<Node<K, V>> = [];
-      while (n) {
-        const d = cmp(key, n.key);
-        stack.push(n);
-        switch (d) {
-          case 0: {
-            return new SortedMapIterator(m, stack, direction);
-          }
-          case -1: {
-            n = n.left;
-            break;
-          }
-          case 1: {
-            n = n!.right;
-            break;
+export function find<K>(key: K, direction: 0 | 1 = 0) {
+  return <V>(m: SortedMap<K, V>): SortedMapIterable<K, V> => {
+    return {
+      ord: m.ord,
+      [Symbol.iterator]() {
+        const cmp = m.ord.compare;
+        let n     = m.root;
+        const stack: Array<Node<K, V>> = [];
+        while (n) {
+          const d = cmp(n.key)(key);
+          stack.push(n);
+          switch (d) {
+            case 0: {
+              return new SortedMapIterator(m, stack, direction);
+            }
+            case -1: {
+              n = n.left;
+              break;
+            }
+            case 1: {
+              n = n!.right;
+              break;
+            }
           }
         }
-      }
-      return new SortedMapIterator(m, [], direction);
-    },
+        return new SortedMapIterator(m, [], direction);
+      },
+    };
   };
 }
 
 /**
  * Iterates through the elements of the map inorder, performing the given function for each element
  *
- * @tsplus fluent fncts.SortedMap forEach
+ * @tsplus pipeable fncts.SortedMap forEach
  */
-export function forEach_<K, V>(m: SortedMap<K, V>, visit: (key: K, value: V) => void) {
-  if (m.root) {
-    m.visitFull((k, v) => {
-      visit(k, v);
-      return Nothing();
-    });
-  }
+export function forEach<K, V>(visit: (key: K, value: V) => void) {
+  return (self: SortedMap<K, V>): void => {
+    if (self.root) {
+      self.visitFull((k, v) => {
+        visit(k, v);
+        return Nothing();
+      });
+    }
+  };
 }
 
 /**
- * @tsplus fluent fncts.SortedMap forEachBetween
+ * @tsplus pipeable fncts.SortedMap forEachBetween
  */
-export function forEachBetween_<K, V>(m: SortedMap<K, V>, min: K, max: K, visit: (k: K, v: V) => void): void {
-  if (m.root) {
-    m.visitBetween(min, max, (k, v) => {
-      visit(k, v);
-      return Nothing();
-    });
-  }
+export function forEachBetween<K, V>(min: K, max: K, visit: (k: K, v: V) => void) {
+  return (self: SortedMap<K, V>): void => {
+    if (self.root) {
+      self.visitBetween(min, max, (k, v) => {
+        visit(k, v);
+        return Nothing();
+      });
+    }
+  };
 }
 
 /**
- * @tsplus fluent fncts.SortedMap forEachLte
+ * @tsplus pipeable fncts.SortedMap forEachLte
  */
-export function forEachLte_<K, V>(m: SortedMap<K, V>, max: K, visit: (k: K, v: V) => void): void {
-  if (m.root) {
-    m.visitLte(max, (k, v) => {
-      visit(k, v);
-      return Nothing();
-    });
-  }
+export function forEachLte<K, V>(max: K, visit: (k: K, v: V) => void) {
+  return (self: SortedMap<K, V>): void => {
+    if (self.root) {
+      self.visitLte(max, (k, v) => {
+        visit(k, v);
+        return Nothing();
+      });
+    }
+  };
 }
 
 /**
- * @tsplus fluent fncts.SortedMap forEachLt
+ * @tsplus pipeable fncts.SortedMap forEachLt
  */
-export function forEachLt_<K, V>(m: SortedMap<K, V>, max: K, visit: (k: K, v: V) => void): void {
-  if (m.root) {
-    m.visitLt(max, (k, v) => {
-      visit(k, v);
-      return Nothing();
-    });
-  }
+export function forEachLt<K, V>(max: K, visit: (k: K, v: V) => void) {
+  return (self: SortedMap<K, V>): void => {
+    if (self.root) {
+      self.visitLt(max, (k, v) => {
+        visit(k, v);
+        return Nothing();
+      });
+    }
+  };
 }
 
 /**
- * @tsplus fluent fncts.SortedMap forEachGte
+ * @tsplus pipeable fncts.SortedMap forEachGte
  */
-export function forEachGte_<K, V>(m: SortedMap<K, V>, min: K, visit: (k: K, v: V) => void): void {
-  if (m.root) {
-    m.visitGte(min, (k, v) => {
-      visit(k, v);
-      return Nothing();
-    });
-  }
+export function forEachGte<K, V>(min: K, visit: (k: K, v: V) => void) {
+  return (self: SortedMap<K, V>): void => {
+    if (self.root) {
+      self.visitGte(min, (k, v) => {
+        visit(k, v);
+        return Nothing();
+      });
+    }
+  };
 }
 
 /**
- * @tsplus fluent fncts.SortedMap forEachGt
+ * @tsplus pipeable fncts.SortedMap forEachGt
  */
-export function forEachGt_<K, V>(m: SortedMap<K, V>, min: K, visit: (k: K, v: V) => void): void {
-  if (m.root) {
-    m.visitGt(min, (k, v) => {
-      visit(k, v);
-      return Nothing();
-    });
-  }
+export function forEachGt<K, V>(min: K, visit: (k: K, v: V) => void) {
+  return (self: SortedMap<K, V>): void => {
+    if (self.root) {
+      self.visitGt(min, (k, v) => {
+        visit(k, v);
+        return Nothing();
+      });
+    }
+  };
 }
 
 /**
  * Searches the map for a given key, returning it's value, if it exists
  *
- * @tsplus fluent fncts.SortedMap get
+ * @tsplus pipeable fncts.SortedMap get
  */
-export function get_<K, V>(m: SortedMap<K, V>, key: K): Maybe<V> {
-  const cmp = m.ord.compare;
-  let n     = m.root;
-  while (n) {
-    const d = cmp(key, n.key);
-    switch (d) {
-      case 0: {
-        return Just(n.value);
-      }
-      case -1: {
-        n = n.left;
-        break;
-      }
-      case 1: {
-        n = n.right;
-        break;
+export function get<K>(key: K) {
+  return <V>(self: SortedMap<K, V>): Maybe<V> => {
+    const cmp = self.ord.compare;
+    let n     = self.root;
+    while (n) {
+      const d = cmp(n.key)(key);
+      switch (d) {
+        case 0: {
+          return Just(n.value);
+        }
+        case -1: {
+          n = n.left;
+          break;
+        }
+        case 1: {
+          n = n.right;
+          break;
+        }
       }
     }
-  }
-  return Nothing();
+    return Nothing();
+  };
 }
 
 /**
  * Searches the map and returns the first value in sorted order that is > key, if it exists
  *
- * @tsplus fluent fncts.SortedMap getGt
+ * @tsplus pipeable fncts.SortedMap getGt
  */
-export function getGt_<K, V>(m: SortedMap<K, V>, key: K): Maybe<V> {
-  const cmp     = m.ord.compare;
-  let n         = m.root;
-  let lastValue = Nothing<V>();
-  while (n) {
-    const d = cmp(key, n.key);
-    if (d < 0) {
-      lastValue = Just(n.value);
-      n         = n.left;
-    } else {
-      if (lastValue.isJust()) {
-        break;
+export function getGt<K>(key: K) {
+  return <V>(self: SortedMap<K, V>): Maybe<V> => {
+    const cmp     = self.ord.compare;
+    let n         = self.root;
+    let lastValue = Nothing<V>();
+    while (n) {
+      const d = cmp(n.key)(key);
+      if (d < 0) {
+        lastValue = Just(n.value);
+        n         = n.left;
+      } else {
+        if (lastValue.isJust()) {
+          break;
+        }
+        n = n.right;
       }
-      n = n.right;
     }
-  }
-  return lastValue;
+    return lastValue;
+  };
 }
 
 /**
  * Searches the map and returns the first value in sorted order that is < key, if it exists
  *
- * @tsplus fluent fncts.SortedMap getLt
+ * @tsplus pipeable fncts.SortedMap getLt
  */
-export function getLt_<K, V>(m: SortedMap<K, V>, key: K): Maybe<V> {
-  const cmp     = m.ord.compare;
-  let n         = m.root;
-  let lastValue = Nothing<V>();
-  while (n) {
-    const d = cmp(key, n.key);
-    if (d > 0) {
-      lastValue = Just(n.value);
-    }
-    if (d <= 0) {
-      n = n.left;
-    } else {
-      n = n.right;
+export function getLt<K>(key: K) {
+  return <V>(self: SortedMap<K, V>): Maybe<V> => {
+    const cmp     = self.ord.compare;
+    let n         = self.root;
+    let lastValue = Nothing<V>();
+    while (n) {
+      const d = cmp(n.key)(key);
+      if (d > 0) {
+        lastValue = Just(n.value);
+      }
+      if (d <= 0) {
+        n = n.left;
+      } else {
+        n = n.right;
+      }
     }
-  }
-  return lastValue;
+    return lastValue;
+  };
 }
 
 /**
  * Searches the map and returns the first value in sorted order that is <= key, if it exists
  *
- * @tsplus fluent fncts.SortedMap getLte
+ * @tsplus pipeable fncts.SortedMap getLte
  */
-export function getLte_<K, V>(m: SortedMap<K, V>, key: K): Maybe<V> {
-  const cmp     = m.ord.compare;
-  let n         = m.root;
-  let lastValue = Nothing<V>();
-  while (n) {
-    const d = cmp(key, n.key);
-    if (d > 0) {
-      if (lastValue.isJust()) {
-        break;
+export function getLte<K>(key: K) {
+  return <V>(self: SortedMap<K, V>): Maybe<V> => {
+    const cmp     = self.ord.compare;
+    let n         = self.root;
+    let lastValue = Nothing<V>();
+    while (n) {
+      const d = cmp(n.key)(key);
+      if (d > 0) {
+        if (lastValue.isJust()) {
+          break;
+        }
+        n = n.right;
+      } else {
+        lastValue = Just(n.value);
+        n         = n.left;
       }
-      n = n.right;
-    } else {
-      lastValue = Just(n.value);
-      n         = n.left;
     }
-  }
-  return lastValue;
+    return lastValue;
+  };
 }
 
 /**
  * Searches the map and returns the first value in sorted order that is >= key, if it exists
  *
- * @tsplus fluent fncts.SortedMap getGte
+ * @tsplus pipeable fncts.SortedMap getGte
  */
-export function getGte_<K, V>(m: SortedMap<K, V>, key: K): Maybe<V> {
-  const cmp     = m.ord.compare;
-  let n         = m.root;
-  let lastValue = Nothing<V>();
-  while (n) {
-    const d = cmp(key, n.key);
-    if (d <= 0) {
-      lastValue = Just(n.value);
-      n         = n.left;
-    } else {
-      if (lastValue.isJust()) {
-        break;
+export function getGte<K>(key: K) {
+  return <V>(self: SortedMap<K, V>): Maybe<V> => {
+    const cmp     = self.ord.compare;
+    let n         = self.root;
+    let lastValue = Nothing<V>();
+    while (n) {
+      const d = cmp(n.key)(key);
+      if (d <= 0) {
+        lastValue = Just(n.value);
+        n         = n.left;
+      } else {
+        if (lastValue.isJust()) {
+          break;
+        }
+        n = n.right;
       }
-      n = n.right;
     }
-  }
-  return lastValue;
+    return lastValue;
+  };
 }
 
 /**
  * Inserts an element into the correct position in the map.
  * This function inserts duplicate keys. For one that combines duplicate key's values,
- * see `insertWith_`
+ * see `insertWith`
  *
- * @tsplus fluent fncts.SortedMap insert
+ * @tsplus pipeable fncts.SortedMap set
  */
-export function insert_<K, V>(m: SortedMap<K, V>, key: K, value: V): SortedMap<K, V> {
-  if (isEmptyNode(m.root)) {
-    return new SortedMap(m.ord, new Node(Color.R, Leaf, key, value, Leaf, 1));
-  }
-  const cmp = m.ord.compare;
-  const nodeStack: Array<Node<K, V>> = [];
-  const orderStack: Array<Ordering>  = [];
-  let n: RBNode<K, V>                = m.root;
-  while (n) {
-    const d = cmp(key, n.key);
-    nodeStack.push(n);
-    orderStack.push(d);
-    if (d <= 0) {
-      n = n.left;
-    } else {
-      n = n.right;
+export function set<K, V>(key: K, value: V) {
+  return (self: SortedMap<K, V>): SortedMap<K, V> => {
+    if (isEmptyNode(self.root)) {
+      return new SortedMap(self.ord, new Node(Color.R, Leaf, key, value, Leaf, 1));
     }
-  }
-
-  nodeStack.push(new Node(Color.R, Leaf, key, value, Leaf, 1));
-  rebuildModifiedPath(nodeStack, orderStack);
-  balanceModifiedPath(nodeStack);
-
-  return new SortedMap(m.ord, nodeStack[0]!);
+    const cmp = self.ord.compare;
+    const nodeStack: Array<Node<K, V>> = [];
+    const orderStack: Array<Ordering>  = [];
+    let n: RBNode<K, V>                = self.root;
+    while (n) {
+      const d = cmp(n.key)(key);
+      nodeStack.push(n);
+      orderStack.push(d);
+      if (d <= 0) {
+        n = n.left;
+      } else {
+        n = n.right;
+      }
+    }
+    nodeStack.push(new Node(Color.R, Leaf, key, value, Leaf, 1));
+    rebuildModifiedPath(nodeStack, orderStack);
+    balanceModifiedPath(nodeStack);
+    return new SortedMap(self.ord, nodeStack[0]!);
+  };
 }
 
 /**
  * Inserts an element into the correct position in the map, combining the values of keys of equal ordering
  * with a `Semigroup` instance
+ *
+ * @tsplus pipeable fncts.SortedMap setWith
  */
-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;
+export function setWith<K, V>(key: K, value: V, /** @tsplus auto */ S: Semigroup<V>) {
+  return (self: SortedMap<K, V>): SortedMap<K, V> => {
+    if (isEmptyNode(self.root)) {
+      return new SortedMap(self.ord, new Node(Color.R, Leaf, key, value, Leaf, 1));
+    }
+    const com = S.combine;
+    const cmp = self.ord.compare;
+    const nodeStack: Array<Node<K, V>> = [];
+    const orderStack: Array<1 | -1>    = [];
+    let n: RBNode<K, V>                = self.root;
+    let cv: V | null                   = null;
+    while (n && !cv) {
+      const d = cmp(n.key)(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(value)(n.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(self.ord, nodeStack[0]!);
+  };
 }
 
 /**
  * @tsplus getter fncts.SortedMap isEmpty
  */
-export function isEmpty<K, V>(m: SortedMap<K, V>): boolean {
-  return m.root === Leaf;
+export function isEmpty<K, V>(self: SortedMap<K, V>): boolean {
+  return self.root === Leaf;
 }
 
 /**
  * @tsplus getter fncts.SortedMap isNonEmpty
  */
-export function isNonEmpty<K, V>(m: SortedMap<K, V>): boolean {
-  return m.root !== Leaf;
+export function isNonEmpty<K, V>(self: SortedMap<K, V>): boolean {
+  return self.root !== Leaf;
 }
 
 /**
  * @tsplus static fncts.SortedMapOps make
  */
-export function make<K, V>(ord: Ord<K>) {
+export function make<K, V>(/** @tsplus auto */ ord: Ord<K>) {
   return new SortedMap<K, V>(ord, null);
 }
 
 /**
  * Removes an element from the map
  *
- * @tsplus fluent fncts.SortedMap remove
+ * @tsplus pipeable fncts.SortedMap remove
  */
-export function remove_<K, V>(m: SortedMap<K, V>, key: K): SortedMap<K, V> {
-  const iter = m.find(key)[Symbol.iterator]();
-  return iter.isEmpty ? m : iter.remove();
-}
-
-/**
- * @tsplus fluent fncts.SortedMap visitFull
- */
-export function visitFull<K, V, A>(m: SortedMap<K, V>, visit: (key: K, value: V) => Maybe<A>): Maybe<A> {
-  let current: RBNode<K, V>      = m.root;
-  const stack: Stack<Node<K, V>> = Stack();
-  let done = false;
-
-  while (!done) {
-    if (current) {
-      stack.push(current);
-      current = current.left;
-    } else if (stack.hasNext) {
-      const value = stack.pop()!;
-      const v     = visit(value.key, value.value);
-      if (v.isJust()) {
-        return v;
-      }
-      current = value.right;
-    } else {
-      done = true;
-    }
-  }
-  return Nothing();
+export function remove<K>(key: K) {
+  return <V>(self: SortedMap<K, V>): SortedMap<K, V> => {
+    const iter = self.find(key)[Symbol.iterator]();
+    return iter.isEmpty ? self : iter.remove();
+  };
 }
 
 /**
- * @tsplus fluent fncts.SortedMap visitLte
+ * @tsplus pipeable fncts.SortedMap visitFull
  */
-export function visitLte<K, V, A>(m: SortedMap<K, V>, max: K, visit: (k: K, v: V) => Maybe<A>): Maybe<A> {
-  let current: RBNode<K, V>      = m.root;
-  const stack: Stack<Node<K, V>> = Stack();
-  let done  = false;
-  const cmp = m.ord.compare;
-
-  while (!done) {
-    if (current) {
-      stack.push(current);
-      current = current.left;
-    } else if (stack.hasNext) {
-      const next = stack.pop()!;
-      if (cmp(next.key, max) > 0) {
-        break;
-      }
-      const v = visit(next.key, next.value);
-      if (v.isJust()) {
-        return v;
+export function visitFull<K, V, A>(visit: (key: K, value: V) => Maybe<A>) {
+  return (self: SortedMap<K, V>): Maybe<A> => {
+    let current: RBNode<K, V>      = self.root;
+    const stack: Stack<Node<K, V>> = Stack();
+    let done = false;
+    while (!done) {
+      if (current) {
+        stack.push(current);
+        current = current.left;
+      } else if (stack.hasNext) {
+        const value = stack.pop()!;
+        const v     = visit(value.key, value.value);
+        if (v.isJust()) {
+          return v;
+        }
+        current = value.right;
+      } else {
+        done = true;
       }
-      current = next.right;
-    } else {
-      done = true;
     }
-  }
-  return Nothing();
+    return Nothing();
+  };
 }
 
 /**
- * @tsplus fluent fncts.SortedMap visitLt
+ * @tsplus pipeable fncts.SortedMap visitLte
  */
-export function visitLt<K, V, A>(m: SortedMap<K, V>, max: K, visit: (k: K, v: V) => Maybe<A>): Maybe<A> {
-  let current: RBNode<K, V>      = m.root;
-  const stack: Stack<Node<K, V>> = Stack();
-  let done  = false;
-  const cmp = m.ord.compare;
-
-  while (!done) {
-    if (current) {
-      stack.push(current);
-      current = current.left;
-    } else if (stack.hasNext) {
-      const next = stack.pop()!;
-      if (cmp(next.key, max) >= 0) {
-        break;
-      }
-      const v = visit(next.key, next.value);
-      if (v.isJust()) {
-        return v;
+export function visitLte<K, V, A>(max: K, visit: (k: K, v: V) => Maybe<A>) {
+  return (self: SortedMap<K, V>): Maybe<A> => {
+    let current: RBNode<K, V>      = self.root;
+    const stack: Stack<Node<K, V>> = Stack();
+    let done  = false;
+    const cmp = self.ord.compare;
+    while (!done) {
+      if (current) {
+        stack.push(current);
+        current = current.left;
+      } else if (stack.hasNext) {
+        const next = stack.pop()!;
+        if (cmp(max)(next.key) > 0) {
+          break;
+        }
+        const v = visit(next.key, next.value);
+        if (v.isJust()) {
+          return v;
+        }
+        current = next.right;
+      } else {
+        done = true;
       }
-      current = next.right;
-    } else {
-      done = true;
     }
-  }
-  return Nothing();
+    return Nothing();
+  };
 }
 
 /**
- * @tsplus fluent fncts.SortedMap visitGte
+ * @tsplus pipeable fncts.SortedMap visitLt
  */
-export function visitGte<K, V, A>(m: SortedMap<K, V>, min: K, visit: (k: K, v: V) => Maybe<A>): Maybe<A> {
-  let current: RBNode<K, V>      = m.root;
-  const stack: Stack<Node<K, V>> = Stack();
-  let done  = false;
-  const cmp = m.ord.compare;
-
-  while (!done) {
-    if (current) {
-      stack.push(current);
-      if (cmp(current.key, min) >= 0) {
+export function visitLt<K, V, A>(max: K, visit: (k: K, v: V) => Maybe<A>) {
+  return (self: SortedMap<K, V>): Maybe<A> => {
+    let current: RBNode<K, V>      = self.root;
+    const stack: Stack<Node<K, V>> = Stack();
+    let done  = false;
+    const cmp = self.ord.compare;
+    while (!done) {
+      if (current) {
+        stack.push(current);
         current = current.left;
-      } else {
-        current = null;
-      }
-    } else if (stack.hasNext) {
-      const next = stack.pop()!;
-      if (cmp(next.key, min) >= 0) {
+      } else if (stack.hasNext) {
+        const next = stack.pop()!;
+        if (cmp(max)(next.key) >= 0) {
+          break;
+        }
         const v = visit(next.key, next.value);
         if (v.isJust()) {
           return v;
         }
+        current = next.right;
+      } else {
+        done = true;
       }
-      current = next.right;
-    } else {
-      done = true;
     }
-  }
-  return Nothing();
+    return Nothing();
+  };
 }
 
 /**
- * @tsplus fluent fncts.SortedMap visitGt
+ * @tsplus pipeable fncts.SortedMap visitGte
  */
-export function visitGt<K, V, A>(m: SortedMap<K, V>, min: K, visit: (k: K, v: V) => Maybe<A>): Maybe<A> {
-  let current: RBNode<K, V>      = m.root;
-  const stack: Stack<Node<K, V>> = Stack();
-  let done  = false;
-  const cmp = m.ord.compare;
-
-  while (!done) {
-    if (current) {
-      stack.push(current);
-      if (cmp(current.key, min) > 0) {
-        current = current.left;
+export function visitGte<K, V, A>(min: K, visit: (k: K, v: V) => Maybe<A>) {
+  return (self: SortedMap<K, V>): Maybe<A> => {
+    let current: RBNode<K, V>      = self.root;
+    const stack: Stack<Node<K, V>> = Stack();
+    let done  = false;
+    const cmp = self.ord.compare;
+    while (!done) {
+      if (current) {
+        stack.push(current);
+        if (cmp(min)(current.key) >= 0) {
+          current = current.left;
+        } else {
+          current = null;
+        }
+      } else if (stack.hasNext) {
+        const next = stack.pop()!;
+        if (cmp(min)(next.key) >= 0) {
+          const v = visit(next.key, next.value);
+          if (v.isJust()) {
+            return v;
+          }
+        }
+        current = next.right;
       } else {
-        current = null;
+        done = true;
       }
-    } else if (stack.hasNext) {
-      const next = stack.pop()!;
-      if (cmp(next.key, min) > 0) {
-        const v = visit(next.key, next.value);
-        if (v.isJust()) {
-          return v;
+    }
+    return Nothing();
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.SortedMap visitGt
+ */
+export function visitGt<K, V, A>(min: K, visit: (k: K, v: V) => Maybe<A>) {
+  return (self: SortedMap<K, V>): Maybe<A> => {
+    let current: RBNode<K, V>      = self.root;
+    const stack: Stack<Node<K, V>> = Stack();
+    let done  = false;
+    const cmp = self.ord.compare;
+    while (!done) {
+      if (current) {
+        stack.push(current);
+        if (cmp(min)(current.key) > 0) {
+          current = current.left;
+        } else {
+          current = null;
         }
+      } else if (stack.hasNext) {
+        const next = stack.pop()!;
+        if (cmp(min)(next.key) > 0) {
+          const v = visit(next.key, next.value);
+          if (v.isJust()) {
+            return v;
+          }
+        }
+        current = next.right;
+      } else {
+        done = true;
       }
-      current = next.right;
-    } else {
-      done = true;
     }
-  }
-  return Nothing();
+    return Nothing();
+  };
 }
 
 /**
- * @tsplus fluent fncts.SortedMap visitBetween
+ * @tsplus pipeable fncts.SortedMap visitBetween
  */
-export function visitBetween<K, V, A>(m: SortedMap<K, V>, min: K, max: K, visit: (k: K, v: V) => Maybe<A>): Maybe<A> {
-  let current: RBNode<K, V>      = m.root;
-  const stack: Stack<Node<K, V>> = Stack();
-  let done  = false;
-  const cmp = m.ord.compare;
-
-  while (!done) {
-    if (current) {
-      stack.push(current);
-      if (cmp(current.key, min) > 0) {
-        current = current.left;
+export function visitBetween<K, V, A>(min: K, max: K, visit: (k: K, v: V) => Maybe<A>) {
+  return (self: SortedMap<K, V>): Maybe<A> => {
+    let current: RBNode<K, V>      = self.root;
+    const stack: Stack<Node<K, V>> = Stack();
+    let done  = false;
+    const cmp = self.ord.compare;
+    while (!done) {
+      if (current) {
+        stack.push(current);
+        if (cmp(min)(current.key) > 0) {
+          current = current.left;
+        } else {
+          current = null;
+        }
+      } else if (stack.hasNext) {
+        const next = stack.pop()!;
+        if (cmp(max)(next.key) >= 0) {
+          break;
+        }
+        const v = visit(next.key, next.value);
+        if (v.isJust()) {
+          return v;
+        }
+        current = next.right;
       } else {
-        current = null;
+        done = true;
       }
-    } else if (stack.hasNext) {
-      const next = stack.pop()!;
-      if (cmp(next.key, max) >= 0) {
-        break;
-      }
-      const v = visit(next.key, next.value);
-      if (v.isJust()) {
-        return v;
-      }
-      current = next.right;
-    } else {
-      done = true;
     }
-  }
-  return Nothing();
+    return Nothing();
+  };
 }