@fncts/base 0.0.19 → 0.0.21

package/_mjs/collection/immutable/SortedMap/api.mjs

@@ -1,7 +1,7 @@
 import * as tsplus_module_1 from "@fncts/base/data/Maybe/constructors";
 import * as tsplus_module_2 from "@fncts/base/data/Maybe/definition";
 import * as tsplus_module_3 from "@fncts/base/internal/Stack";
-export const find_ = find_1;
+export const find = find_1;
 export const visitFull = visitFull_1;
 export const visitLte = visitLte_1;
 export const visitLt = visitLt_1;
@@ -14,313 +14,339 @@ import { SortedMapIterator } from "@fncts/base/collection/immutable/SortedMap/it
 import { Leaf, Node } from "@fncts/base/collection/immutable/SortedMap/node";
 import { Stack } from "@fncts/base/internal/Stack";
 /**
- * @tsplus fluent fncts.SortedMap find
+ * @tsplus pipeable fncts.SortedMap find
  */
 
-function find_1(m, key, direction = 0) {
-  return {
-    ord: m.ord,
-
-    [Symbol.iterator]() {
-      const cmp = m.ord.compare;
-      let n = m.root;
-      const stack = [];
-
-      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;
-            }
+function find_1(key, direction = 0) {
+  return m => {
+    return {
+      ord: m.ord,
+
+      [Symbol.iterator]() {
+        const cmp = m.ord.compare;
+        let n = m.root;
+        const stack = [];
+
+        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;
+              }
+          }
         }
-      }
 
-      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_(m, visit) {
-  if (m.root) {
-    visitFull_1(m, (k, v) => {
-      visit(k, v);
-      return tsplus_module_1.nothing();
-    });
-  }
+export function forEach(visit) {
+  return m => {
+    if (m.root) {
+      visitFull_1((k, v) => {
+        visit(k, v);
+        return tsplus_module_1.nothing();
+      })(m);
+    }
+  };
 }
 /**
- * @tsplus fluent fncts.SortedMap forEachBetween
+ * @tsplus pipeable fncts.SortedMap forEachBetween
  */
 
-export function forEachBetween_(m, min, max, visit) {
-  if (m.root) {
-    visitBetween_1(m, min, max, (k, v) => {
-      visit(k, v);
-      return tsplus_module_1.nothing();
-    });
-  }
+export function forEachBetween(min, max, visit) {
+  return m => {
+    if (m.root) {
+      visitBetween_1(min, max, (k, v) => {
+        visit(k, v);
+        return tsplus_module_1.nothing();
+      })(m);
+    }
+  };
 }
 /**
- * @tsplus fluent fncts.SortedMap forEachLte
+ * @tsplus pipeable fncts.SortedMap forEachLte
  */
 
-export function forEachLte_(m, max, visit) {
-  if (m.root) {
-    visitLte_1(m, max, (k, v) => {
-      visit(k, v);
-      return tsplus_module_1.nothing();
-    });
-  }
+export function forEachLte(max, visit) {
+  return m => {
+    if (m.root) {
+      visitLte_1(max, (k, v) => {
+        visit(k, v);
+        return tsplus_module_1.nothing();
+      })(m);
+    }
+  };
 }
 /**
- * @tsplus fluent fncts.SortedMap forEachLt
+ * @tsplus pipeable fncts.SortedMap forEachLt
  */
 
-export function forEachLt_(m, max, visit) {
-  if (m.root) {
-    visitLt_1(m, max, (k, v) => {
-      visit(k, v);
-      return tsplus_module_1.nothing();
-    });
-  }
+export function forEachLt(max, visit) {
+  return m => {
+    if (m.root) {
+      visitLt_1(max, (k, v) => {
+        visit(k, v);
+        return tsplus_module_1.nothing();
+      })(m);
+    }
+  };
 }
 /**
- * @tsplus fluent fncts.SortedMap forEachGte
+ * @tsplus pipeable fncts.SortedMap forEachGte
  */
 
-export function forEachGte_(m, min, visit) {
-  if (m.root) {
-    visitGte_1(m, min, (k, v) => {
-      visit(k, v);
-      return tsplus_module_1.nothing();
-    });
-  }
+export function forEachGte(min, visit) {
+  return m => {
+    if (m.root) {
+      visitGte_1(min, (k, v) => {
+        visit(k, v);
+        return tsplus_module_1.nothing();
+      })(m);
+    }
+  };
 }
 /**
- * @tsplus fluent fncts.SortedMap forEachGt
+ * @tsplus pipeable fncts.SortedMap forEachGt
  */
 
-export function forEachGt_(m, min, visit) {
-  if (m.root) {
-    visitGt_1(m, min, (k, v) => {
-      visit(k, v);
-      return tsplus_module_1.nothing();
-    });
-  }
+export function forEachGt(min, visit) {
+  return m => {
+    if (m.root) {
+      visitGt_1(min, (k, v) => {
+        visit(k, v);
+        return tsplus_module_1.nothing();
+      })(m);
+    }
+  };
 }
 /**
  * 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_(m, key) {
-  const cmp = m.ord.compare;
-  let n = m.root;
-
-  while (n) {
-    const d = cmp(key, n.key);
-
-    switch (d) {
-      case 0:
-        {
-          return tsplus_module_1.just(n.value);
-        }
-
-      case -1:
-        {
-          n = n.left;
-          break;
-        }
-
-      case 1:
-        {
-          n = n.right;
-          break;
-        }
+export function get(key) {
+  return m => {
+    const cmp = m.ord.compare;
+    let n = m.root;
+
+    while (n) {
+      const d = cmp(key, n.key);
+
+      switch (d) {
+        case 0:
+          {
+            return tsplus_module_1.just(n.value);
+          }
+
+        case -1:
+          {
+            n = n.left;
+            break;
+          }
+
+        case 1:
+          {
+            n = n.right;
+            break;
+          }
+      }
     }
-  }
 
-  return tsplus_module_1.nothing();
+    return tsplus_module_1.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_(m, key) {
-  const cmp = m.ord.compare;
-  let n = m.root;
-  let lastValue = tsplus_module_1.nothing();
+export function getGt(key) {
+  return m => {
+    const cmp = m.ord.compare;
+    let n = m.root;
+    let lastValue = tsplus_module_1.nothing();
 
-  while (n) {
-    const d = cmp(key, n.key);
+    while (n) {
+      const d = cmp(key, n.key);
 
-    if (d < 0) {
-      lastValue = tsplus_module_1.just(n.value);
-      n = n.left;
-    } else {
-      if (tsplus_module_2.isJust(lastValue)) {
-        break;
-      }
+      if (d < 0) {
+        lastValue = tsplus_module_1.just(n.value);
+        n = n.left;
+      } else {
+        if (tsplus_module_2.isJust(lastValue)) {
+          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_(m, key) {
-  const cmp = m.ord.compare;
-  let n = m.root;
-  let lastValue = tsplus_module_1.nothing();
+export function getLt(key) {
+  return m => {
+    const cmp = m.ord.compare;
+    let n = m.root;
+    let lastValue = tsplus_module_1.nothing();
 
-  while (n) {
-    const d = cmp(key, n.key);
+    while (n) {
+      const d = cmp(key, n.key);
 
-    if (d > 0) {
-      lastValue = tsplus_module_1.just(n.value);
-    }
+      if (d > 0) {
+        lastValue = tsplus_module_1.just(n.value);
+      }
 
-    if (d <= 0) {
-      n = n.left;
-    } else {
-      n = n.right;
+      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_(m, key) {
-  const cmp = m.ord.compare;
-  let n = m.root;
-  let lastValue = tsplus_module_1.nothing();
+export function getLte(key) {
+  return m => {
+    const cmp = m.ord.compare;
+    let n = m.root;
+    let lastValue = tsplus_module_1.nothing();
 
-  while (n) {
-    const d = cmp(key, n.key);
+    while (n) {
+      const d = cmp(key, n.key);
 
-    if (d > 0) {
-      if (tsplus_module_2.isJust(lastValue)) {
-        break;
-      }
+      if (d > 0) {
+        if (tsplus_module_2.isJust(lastValue)) {
+          break;
+        }
 
-      n = n.right;
-    } else {
-      lastValue = tsplus_module_1.just(n.value);
-      n = n.left;
+        n = n.right;
+      } else {
+        lastValue = tsplus_module_1.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_(m, key) {
-  const cmp = m.ord.compare;
-  let n = m.root;
-  let lastValue = tsplus_module_1.nothing();
+export function getGte(key) {
+  return m => {
+    const cmp = m.ord.compare;
+    let n = m.root;
+    let lastValue = tsplus_module_1.nothing();
 
-  while (n) {
-    const d = cmp(key, n.key);
+    while (n) {
+      const d = cmp(key, n.key);
 
-    if (d <= 0) {
-      lastValue = tsplus_module_1.just(n.value);
-      n = n.left;
-    } else {
-      if (tsplus_module_2.isJust(lastValue)) {
-        break;
-      }
+      if (d <= 0) {
+        lastValue = tsplus_module_1.just(n.value);
+        n = n.left;
+      } else {
+        if (tsplus_module_2.isJust(lastValue)) {
+          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_`
  *
- * @tsplus fluent fncts.SortedMap insert
+ * @tsplus pipeable fncts.SortedMap insert
  */
 
-export function insert_(m, key, value) {
-  if (isEmptyNode(m.root)) {
-    return new SortedMap(m.ord, new Node(0
-    /* Color.R */
-    , Leaf, key, value, Leaf, 1));
-  }
+export function insert(key, value) {
+  return m => {
+    if (isEmptyNode(m.root)) {
+      return new SortedMap(m.ord, new Node(0
+      /* Color.R */
+      , Leaf, key, value, Leaf, 1));
+    }
 
-  const cmp = m.ord.compare;
-  const nodeStack = [];
-  const orderStack = [];
-  let n = m.root;
+    const cmp = m.ord.compare;
+    const nodeStack = [];
+    const orderStack = [];
+    let n = m.root;
 
-  while (n) {
-    const d = cmp(key, n.key);
-    nodeStack.push(n);
-    orderStack.push(d);
+    while (n) {
+      const d = cmp(key, n.key);
+      nodeStack.push(n);
+      orderStack.push(d);
 
-    if (d <= 0) {
-      n = n.left;
-    } else {
-      n = n.right;
+      if (d <= 0) {
+        n = n.left;
+      } else {
+        n = n.right;
+      }
     }
-  }
 
-  nodeStack.push(new Node(0
-  /* Color.R */
-  , Leaf, key, value, Leaf, 1));
-  rebuildModifiedPath(nodeStack, orderStack);
-  balanceModifiedPath(nodeStack);
-  return new SortedMap(m.ord, nodeStack[0]);
+    nodeStack.push(new Node(0
+    /* Color.R */
+    , Leaf, key, value, Leaf, 1));
+    rebuildModifiedPath(nodeStack, orderStack);
+    balanceModifiedPath(nodeStack);
+    return new SortedMap(m.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
  */
 
-export function insertWith_(m, key, value,
+export function insertWith(m, key, value,
 /** @tsplus auto */
 S) {
   if (isEmptyNode(m.root)) {
@@ -402,231 +428,245 @@ export function make(ord) {
 /**
  * Removes an element from the map
  *
- * @tsplus fluent fncts.SortedMap remove
+ * @tsplus pipeable fncts.SortedMap remove
  */
 
-export function remove_(m, key) {
-  const iter = find_1(m, key)[Symbol.iterator]();
-  return iter.isEmpty ? m : iter.remove();
+export function remove(key) {
+  return m => {
+    const iter = find_1(key)(m)[Symbol.iterator]();
+    return iter.isEmpty ? m : iter.remove();
+  };
 }
 /**
- * @tsplus fluent fncts.SortedMap visitFull
+ * @tsplus pipeable fncts.SortedMap visitFull
  */
 
-function visitFull_1(m, visit) {
-  let current = m.root;
-  const stack = tsplus_module_3.mkStack();
-  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 (tsplus_module_2.isJust(v)) {
-        return v;
-      }
+function visitFull_1(visit) {
+  return m => {
+    let current = m.root;
+    const stack = tsplus_module_3.makeStack();
+    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 (tsplus_module_2.isJust(v)) {
+          return v;
+        }
 
-      current = value.right;
-    } else {
-      done = true;
+        current = value.right;
+      } else {
+        done = true;
+      }
     }
-  }
 
-  return tsplus_module_1.nothing();
+    return tsplus_module_1.nothing();
+  };
 }
 /**
- * @tsplus fluent fncts.SortedMap visitLte
+ * @tsplus pipeable fncts.SortedMap visitLte
  */
 
 
-function visitLte_1(m, max, visit) {
-  let current = m.root;
-  const stack = tsplus_module_3.mkStack();
-  let done = false;
-  const cmp = m.ord.compare;
+function visitLte_1(max, visit) {
+  return m => {
+    let current = m.root;
+    const stack = tsplus_module_3.makeStack();
+    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();
+    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;
-      }
+        if (cmp(next.key, max) > 0) {
+          break;
+        }
 
-      const v = visit(next.key, next.value);
+        const v = visit(next.key, next.value);
 
-      if (tsplus_module_2.isJust(v)) {
-        return v;
-      }
+        if (tsplus_module_2.isJust(v)) {
+          return v;
+        }
 
-      current = next.right;
-    } else {
-      done = true;
+        current = next.right;
+      } else {
+        done = true;
+      }
     }
-  }
 
-  return tsplus_module_1.nothing();
+    return tsplus_module_1.nothing();
+  };
 }
 /**
- * @tsplus fluent fncts.SortedMap visitLt
+ * @tsplus pipeable fncts.SortedMap visitLt
  */
 
 
-function visitLt_1(m, max, visit) {
-  let current = m.root;
-  const stack = tsplus_module_3.mkStack();
-  let done = false;
-  const cmp = m.ord.compare;
+function visitLt_1(max, visit) {
+  return m => {
+    let current = m.root;
+    const stack = tsplus_module_3.makeStack();
+    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();
+    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;
-      }
+        if (cmp(next.key, max) >= 0) {
+          break;
+        }
 
-      const v = visit(next.key, next.value);
+        const v = visit(next.key, next.value);
 
-      if (tsplus_module_2.isJust(v)) {
-        return v;
-      }
+        if (tsplus_module_2.isJust(v)) {
+          return v;
+        }
 
-      current = next.right;
-    } else {
-      done = true;
+        current = next.right;
+      } else {
+        done = true;
+      }
     }
-  }
 
-  return tsplus_module_1.nothing();
+    return tsplus_module_1.nothing();
+  };
 }
 /**
- * @tsplus fluent fncts.SortedMap visitGte
+ * @tsplus pipeable fncts.SortedMap visitGte
  */
 
 
-function visitGte_1(m, min, visit) {
-  let current = m.root;
-  const stack = tsplus_module_3.mkStack();
-  let done = false;
-  const cmp = m.ord.compare;
+function visitGte_1(min, visit) {
+  return m => {
+    let current = m.root;
+    const stack = tsplus_module_3.makeStack();
+    let done = false;
+    const cmp = m.ord.compare;
 
-  while (!done) {
-    if (current) {
-      stack.push(current);
+    while (!done) {
+      if (current) {
+        stack.push(current);
 
-      if (cmp(current.key, min) >= 0) {
-        current = current.left;
-      } else {
-        current = null;
-      }
-    } else if (stack.hasNext) {
-      const next = stack.pop();
+        if (cmp(current.key, min) >= 0) {
+          current = current.left;
+        } else {
+          current = null;
+        }
+      } else if (stack.hasNext) {
+        const next = stack.pop();
 
-      if (cmp(next.key, min) >= 0) {
-        const v = visit(next.key, next.value);
+        if (cmp(next.key, min) >= 0) {
+          const v = visit(next.key, next.value);
 
-        if (tsplus_module_2.isJust(v)) {
-          return v;
+          if (tsplus_module_2.isJust(v)) {
+            return v;
+          }
         }
-      }
 
-      current = next.right;
-    } else {
-      done = true;
+        current = next.right;
+      } else {
+        done = true;
+      }
     }
-  }
 
-  return tsplus_module_1.nothing();
+    return tsplus_module_1.nothing();
+  };
 }
 /**
- * @tsplus fluent fncts.SortedMap visitGt
+ * @tsplus pipeable fncts.SortedMap visitGt
  */
 
 
-function visitGt_1(m, min, visit) {
-  let current = m.root;
-  const stack = tsplus_module_3.mkStack();
-  let done = false;
-  const cmp = m.ord.compare;
+function visitGt_1(min, visit) {
+  return m => {
+    let current = m.root;
+    const stack = tsplus_module_3.makeStack();
+    let done = false;
+    const cmp = m.ord.compare;
 
-  while (!done) {
-    if (current) {
-      stack.push(current);
+    while (!done) {
+      if (current) {
+        stack.push(current);
 
-      if (cmp(current.key, min) > 0) {
-        current = current.left;
-      } else {
-        current = null;
-      }
-    } else if (stack.hasNext) {
-      const next = stack.pop();
+        if (cmp(current.key, min) > 0) {
+          current = current.left;
+        } else {
+          current = null;
+        }
+      } else if (stack.hasNext) {
+        const next = stack.pop();
 
-      if (cmp(next.key, min) > 0) {
-        const v = visit(next.key, next.value);
+        if (cmp(next.key, min) > 0) {
+          const v = visit(next.key, next.value);
 
-        if (tsplus_module_2.isJust(v)) {
-          return v;
+          if (tsplus_module_2.isJust(v)) {
+            return v;
+          }
         }
-      }
 
-      current = next.right;
-    } else {
-      done = true;
+        current = next.right;
+      } else {
+        done = true;
+      }
     }
-  }
 
-  return tsplus_module_1.nothing();
+    return tsplus_module_1.nothing();
+  };
 }
 /**
- * @tsplus fluent fncts.SortedMap visitBetween
+ * @tsplus pipeable fncts.SortedMap visitBetween
  */
 
 
-function visitBetween_1(m, min, max, visit) {
-  let current = m.root;
-  const stack = tsplus_module_3.mkStack();
-  let done = false;
-  const cmp = m.ord.compare;
+function visitBetween_1(min, max, visit) {
+  return m => {
+    let current = m.root;
+    const stack = tsplus_module_3.makeStack();
+    let done = false;
+    const cmp = m.ord.compare;
 
-  while (!done) {
-    if (current) {
-      stack.push(current);
+    while (!done) {
+      if (current) {
+        stack.push(current);
 
-      if (cmp(current.key, min) > 0) {
-        current = current.left;
-      } else {
-        current = null;
-      }
-    } else if (stack.hasNext) {
-      const next = stack.pop();
+        if (cmp(current.key, min) > 0) {
+          current = current.left;
+        } else {
+          current = null;
+        }
+      } else if (stack.hasNext) {
+        const next = stack.pop();
 
-      if (cmp(next.key, max) >= 0) {
-        break;
-      }
+        if (cmp(next.key, max) >= 0) {
+          break;
+        }
 
-      const v = visit(next.key, next.value);
+        const v = visit(next.key, next.value);
 
-      if (tsplus_module_2.isJust(v)) {
-        return v;
-      }
+        if (tsplus_module_2.isJust(v)) {
+          return v;
+        }
 
-      current = next.right;
-    } else {
-      done = true;
+        current = next.right;
+      } else {
+        done = true;
+      }
     }
-  }
 
-  return tsplus_module_1.nothing();
+    return tsplus_module_1.nothing();
+  };
 }
 //# sourceMappingURL=api.mjs.map