rename transient functions

Author: yoshie

src/dict.mjs

@@ -8,7 +8,9 @@ import { isEqual, Result$Error, Result$Ok } from "./gleam.mjs";
 // -- HASH --------------------------------------------------------------------
 
 const referenceMap = /* @__PURE__ */ new WeakMap();
-const tempDataView = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(8));
+const tempDataView = /* @__PURE__ */ new DataView(
+  /* @__PURE__ */ new ArrayBuffer(8),
+);
 let referenceUID = 0;
 /**
  * hash the object by reference using a weak map and incrementing uid
@@ -299,7 +301,7 @@ export function make() {
 export function from(iterable) {
   let transient = toTransient(emptyDict);
   for (const [key, value] of iterable) {
-    transient = put(key, value, transient);
+    transient = transientInsert(key, value, transient);
   }
   return fromTransient(transient);
 }
@@ -432,7 +434,7 @@ export function insert(dict, key, value) {
   globalTransient.generation = nextGeneration(dict);
   globalTransient.size = dict.size;
 
-  const root = doPut(globalTransient, dict.root, key, value, getHash(key), 0);
+  const root = doInsert(globalTransient, dict.root, key, value, getHash(key), 0);
   if (root === dict.root) {
     return dict;
   }
@@ -446,13 +448,30 @@ export function insert(dict, key, value) {
  *
  * Returns a new transient.
  */
-export function put(key, value, transient) {
+export function transientInsert(key, value, transient) {
   const hash = getHash(key);
-  transient.root = doPut(transient, transient.root, key, value, hash, 0);
+  transient.root = doInsert(transient, transient.root, key, value, hash, 0);
   return transient;
 }
 
-function doPut(transient, node, key, value, hash, shift) {
+/**
+ * Consume a transient, writing a new key/value pair if the key doesn't exist or updating
+ * the existing value with a function if it does.
+ *
+ * Returns a new transient.
+ */
+export function transientUpdateWith(key, fun, value, transient) {
+  const hash = getHash(key);
+
+  const existing = lookup(transient.root, key, hash);
+  if (existing !== noElementMarker) {
+    value = fun(existing);
+  }
+  transient.root = doInsert(transient, transient.root, key, value, hash, 0);
+  return transient;
+}
+
+function doInsert(transient, node, key, value, hash, shift) {
   const data = node.data;
   const generation = transient.generation;
 
@@ -476,7 +495,7 @@ function doPut(transient, node, key, value, hash, shift) {
   if (node.nodemap & bit) {
     const nodeidx = data.length - 1 - index(node.nodemap, bit);
     const child = data[nodeidx];
-    const newChild = doPut(transient, child, key, value, hash, shift + bits);
+    const newChild = doInsert(transient, child, key, value, hash, shift + bits);
     return copyAndSet(node, generation, nodeidx, newChild);
   }
 
@@ -503,8 +522,8 @@ function doPut(transient, node, key, value, hash, shift) {
   const childShift = shift + bits;
 
   let child = emptyNode;
-  child = doPut(transient, child, key, value, hash, childShift);
-  child = doPut(transient, child, otherKey, otherVal, otherHash, childShift);
+  child = doInsert(transient, child, key, value, hash, childShift);
+  child = doInsert(transient, child, otherKey, otherVal, otherHash, childShift);
 
   // we inserted 2 elements, but implicitely deleted the one we pushed down from the datamap.
   transient.size -= 1;
@@ -529,16 +548,17 @@ function doPut(transient, node, key, value, hash, shift) {
 
   return makeNode(generation, node.datamap ^ bit, node.nodemap | bit, newData);
 }
+
 /**
  * Consume a transient, removing a key if it exists.
  * Returns a new transient.
  */
-export function remove(key, transient) {
-  transient.root = doRemove(transient, transient.root, key, getHash(key), 0);
+export function transientDelete(key, transient) {
+  transient.root = doDelete(transient, transient.root, key, getHash(key), 0);
   return transient;
 }
 
-function doRemove(transient, node, key, hash, shift) {
+function doDelete(transient, node, key, hash, shift) {
   const data = node.data;
   const generation = transient.generation;
 
@@ -564,7 +584,7 @@ function doRemove(transient, node, key, hash, shift) {
     const nodeidx = data.length - 1 - index(node.nodemap, bit);
 
     const oldChild = data[nodeidx];
-    const newChild = doRemove(transient, oldChild, key, hash, shift + bits);
+    const newChild = doDelete(transient, oldChild, key, hash, shift + bits);
 
     // the node did change, so let's copy to incorporate that change.
     if (newChild.nodemap !== 0 || newChild.data.length > 2) {
@@ -602,18 +622,6 @@ function doRemove(transient, node, key, hash, shift) {
   return copyAndRemovePair(node, generation, bit, dataidx);
 }
 
-export function update_with(key, fun, value, transient) {
-  const hash = getHash(key);
-
-  const existing = lookup(transient.root, key, hash);
-  if (existing !== noElementMarker) {
-    value = fun(existing);
-  }
-
-  transient.root = doPut(transient, transient.root, key, value, hash, 0);
-  return transient;
-}
-
 export function map(dict, fun) {
   // map can never modify the structure, so we can walk the dictionary directly,
   // but still move to a new generation to make sure we get a new copy of every node.

src/gleam/dict.gleam

@@ -115,7 +115,8 @@ fn from_list_loop(
 ) -> Dict(k, v) {
   case list {
     [] -> from_transient(transient)
-    [#(key, value), ..rest] -> from_list_loop(put(key, value, transient), rest)
+    [#(key, value), ..rest] ->
+      from_list_loop(transient_insert(key, value, transient), rest)
   }
 }
 
@@ -194,8 +195,12 @@ pub fn insert(into dict: Dict(k, v), for key: k, insert value: v) -> Dict(k, v)
 fn do_insert(key: k, value: v, dict: Dict(k, v)) -> Dict(k, v)
 
 @external(erlang, "maps", "put")
-@external(javascript, "../dict.mjs", "put")
-fn put(key: k, value: v, transient: TransientDict(k, v)) -> TransientDict(k, v)
+@external(javascript, "../dict.mjs", "transientInsert")
+fn transient_insert(
+  key: k,
+  value: v,
+  transient: TransientDict(k, v),
+) -> TransientDict(k, v)
 
 /// Updates all values in a given dict by calling a given function on each key
 /// and value.
@@ -281,7 +286,7 @@ fn do_filter(f: fn(k, v) -> Bool, dict: Dict(k, v)) -> Dict(k, v) {
   to_transient(new())
   |> fold(over: dict, with: fn(transient, key, value) {
     case f(key, value) {
-      True -> put(key, value, transient)
+      True -> transient_insert(key, value, transient)
       False -> transient
     }
   })
@@ -323,7 +328,7 @@ fn do_take_loop(
     [] -> from_transient(acc)
     [key, ..rest] ->
       case get(dict, key) {
-        Ok(value) -> do_take_loop(dict, rest, put(key, value, acc))
+        Ok(value) -> do_take_loop(dict, rest, transient_insert(key, value, acc))
         Error(_) -> do_take_loop(dict, rest, acc)
       }
   }
@@ -364,12 +369,12 @@ pub fn merge(into dict: Dict(k, v), from new_entries: Dict(k, v)) -> Dict(k, v)
 /// ```
 ///
 pub fn delete(from dict: Dict(k, v), delete key: k) -> Dict(k, v) {
-  to_transient(dict) |> remove(key, _) |> from_transient
+  to_transient(dict) |> transient_delete(key, _) |> from_transient
 }
 
 @external(erlang, "maps", "remove")
-@external(javascript, "../dict.mjs", "remove")
-fn remove(a: k, b: TransientDict(k, v)) -> TransientDict(k, v)
+@external(javascript, "../dict.mjs", "transientDelete")
+fn transient_delete(a: k, b: TransientDict(k, v)) -> TransientDict(k, v)
 
 /// Creates a new dict from a given dict with all the same entries except any with
 /// keys found in a given list.
@@ -406,7 +411,7 @@ fn drop_loop(
 ) -> Dict(k, v) {
   case disallowed_keys {
     [] -> from_transient(transient)
-    [key, ..rest] -> drop_loop(remove(key, transient), rest)
+    [key, ..rest] -> drop_loop(transient_delete(key, transient), rest)
   }
 }
 
@@ -547,14 +552,14 @@ fn do_combine(
   to_transient(big)
   |> fold(over: small, with: fn(transient, key, value) {
     let update = fn(existing) { combine(key, existing, value) }
-    update_with(key, update, value, transient)
+    transient_update_with(key, update, value, transient)
   })
   |> from_transient
 }
 
 @external(erlang, "maps", "update_with")
-@external(javascript, "../dict.mjs", "update_with")
-fn update_with(
+@external(javascript, "../dict.mjs", "transientUpdateWith")
+fn transient_update_with(
   key: k,
   fun: fn(v) -> v,
   init: v,
@@ -578,7 +583,7 @@ fn group_loop(
       let update = fn(existing) { [value, ..existing] }
 
       transient
-      |> update_with(key, update, [value], _)
+      |> transient_update_with(key, update, [value], _)
       |> group_loop(to_key, rest)
     }
   }