Define insert & union in terms of union_with & insert_with

  Interestingly enough, this completely obliterate the performance we
  gained from the scott-encoding on union_with. Somehow, re-using
  union_with with a different combining function prevents some
  optimizations/specializations?

Author: KtorZ

lib/aiken/collection/dict.ak

@@ -161,7 +161,8 @@ pub fn from_pairs(self: Pairs<ByteArray, value>) -> Dict<key, value> {
 fn do_from_pairs(xs: Pairs<ByteArray, value>) -> Pairs<ByteArray, value> {
   when xs is {
     [] -> []
-    [Pair(k, v), ..rest] -> do_insert(do_from_pairs(rest), k, v)
+    [Pair(k, v), ..rest] ->
+      do_insert_with(do_from_pairs(rest), k, v, union.keep_left())
   }
 }
 
@@ -681,27 +682,7 @@ pub fn insert(
   key k: ByteArray,
   value v: value,
 ) -> Dict<key, value> {
-  Dict { inner: do_insert(self.inner, k, v) }
-}
-
-fn do_insert(
-  self: Pairs<ByteArray, value>,
-  key k: ByteArray,
-  value v: value,
-) -> Pairs<ByteArray, value> {
-  when self is {
-    [] -> [Pair(k, v)]
-    [Pair(k2, v2), ..rest] ->
-      if builtin.less_than_bytearray(k, k2) {
-        [Pair(k, v), ..self]
-      } else {
-        if k == k2 {
-          [Pair(k, v), ..rest]
-        } else {
-          [Pair(k2, v2), ..do_insert(rest, k, v)]
-        }
-      }
-  }
+  insert_with(self, k, v, union.keep_right())
 }
 
 test insert_1() {
@@ -729,37 +710,25 @@ test insert_2() {
 /// to the merge function, and the new value is passed as the third argument.
 ///
 /// ```aiken
-/// let sum =
-///   fn (_k, a, b) { Some(a + b) }
+/// use aiken/collection/dict/union
 ///
 /// let result =
 ///   dict.empty
-///     |> dict.insert_with(key: "a", value: 1, with: sum)
-///     |> dict.insert_with(key: "b", value: 2, with: sum)
-///     |> dict.insert_with(key: "a", value: 3, with: sum)
+///     |> dict.insert_with(key: "a", value: 1, with: union.sum)
+///     |> dict.insert_with(key: "b", value: 2, with: union.sum)
+///     |> dict.insert_with(key: "a", value: 3, with: union.sum)
 ///     |> dict.to_pairs()
 ///
 /// result == [Pair("a", 4), Pair("b", 2)]
 /// ```
 pub fn insert_with(
-  self: Dict<key, value>,
-  key k: ByteArray,
-  value v: value,
-  with: fn(ByteArray, value, value) -> Option<value>,
-) -> Dict<key, value> {
-  Dict {
-    inner: do_insert_with(self.inner, k, v, fn(k, v1, v2) { with(k, v2, v1) }),
-  }
-}
-
-pub fn insert_with_alt(
   self: Dict<key, value>,
   key k: ByteArray,
   value v: value,
   with: UnionStrategy<ByteArray, value>,
 ) -> Dict<key, value> {
   Dict {
-    inner: do_insert_with_alt(
+    inner: do_insert_with(
       self.inner,
       k,
       v,
@@ -769,49 +738,33 @@ pub fn insert_with_alt(
 }
 
 test insert_with_1() {
-  let sum =
-    fn(_k, a, b) { Some(a + b) }
-
-  let result =
-    empty
-      |> insert_with(key: "foo", value: 1, with: sum)
-      |> insert_with(key: "bar", value: 2, with: sum)
-      |> to_pairs()
-
-  result == [Pair("bar", 2), Pair("foo", 1)]
-}
-
-test insert_with_alt_1() {
   let result =
     empty
-      |> insert_with_alt(key: "foo", value: 1, with: union.sum())
-      |> insert_with_alt(key: "bar", value: 2, with: union.sum())
+      |> insert_with(key: "foo", value: 1, with: union.sum())
+      |> insert_with(key: "bar", value: 2, with: union.sum())
       |> to_pairs()
 
   result == [Pair("bar", 2), Pair("foo", 1)]
 }
 
 test insert_with_2() {
-  let sum =
-    fn(_k, a, b) { Some(a + b) }
-
   let result =
     empty
-      |> insert_with(key: "foo", value: 1, with: sum)
-      |> insert_with(key: "bar", value: 2, with: sum)
-      |> insert_with(key: "foo", value: 3, with: sum)
+      |> insert_with(key: "foo", value: 1, with: union.sum())
+      |> insert_with(key: "bar", value: 2, with: union.sum())
+      |> insert_with(key: "foo", value: 3, with: union.sum())
       |> to_pairs()
 
   result == [Pair("bar", 2), Pair("foo", 4)]
 }
 
 test insert_with_3() {
   let with =
-    fn(k, a, _b) {
+    fn(k, a, _b, keep, discard) {
       if k == "foo" {
-        Some(a)
+        keep(a)
       } else {
-        None
+        discard()
       }
     }
 
@@ -970,17 +923,7 @@ pub fn union(
   left: Dict<key, value>,
   right: Dict<key, value>,
 ) -> Dict<key, value> {
-  Dict { inner: do_union(left.inner, right.inner) }
-}
-
-fn do_union(
-  left: Pairs<ByteArray, value>,
-  right: Pairs<ByteArray, value>,
-) -> Pairs<ByteArray, value> {
-  when left is {
-    [] -> right
-    [Pair(k, v), ..rest] -> do_union(rest, do_insert(right, k, v))
-  }
+  Dict(do_union_with(left.inner, right.inner, union.keep_left()))
 }
 
 test union_1() {
@@ -1036,70 +979,26 @@ test union_4() {
 /// result == [Pair("a", 250), Pair("b", 200), Pair("c", 300)]
 /// ```
 pub fn union_with(
-  left: Dict<key, value>,
-  right: Dict<key, value>,
-  with: fn(ByteArray, value, value) -> Option<value>,
-) -> Dict<key, value> {
-  Dict { inner: do_union_with(left.inner, right.inner, with) }
-}
-
-pub fn union_with_alt(
   left: Dict<key, value>,
   right: Dict<key, value>,
   with: UnionStrategy<ByteArray, value>,
 ) -> Dict<key, value> {
-  Dict { inner: do_union_with_alt(left.inner, right.inner, with) }
+  Dict { inner: do_union_with(left.inner, right.inner, with) }
 }
 
 fn do_union_with(
-  left: Pairs<ByteArray, value>,
-  right: Pairs<ByteArray, value>,
-  with: fn(ByteArray, value, value) -> Option<value>,
-) -> Pairs<ByteArray, value> {
-  when left is {
-    [] -> right
-    [Pair(k, v), ..rest] ->
-      do_union_with(rest, do_insert_with(right, k, v, with), with)
-  }
-}
-
-fn do_union_with_alt(
   left: Pairs<ByteArray, value>,
   right: Pairs<ByteArray, value>,
   with: UnionStrategy<ByteArray, value>,
 ) -> Pairs<ByteArray, value> {
   when left is {
     [] -> right
     [Pair(k, v), ..rest] ->
-      do_union_with_alt(rest, do_insert_with_alt(right, k, v, with), with)
+      do_union_with(rest, do_insert_with(right, k, v, with), with)
   }
 }
 
 fn do_insert_with(
-  self: Pairs<ByteArray, value>,
-  key k: ByteArray,
-  value v: value,
-  with: fn(ByteArray, value, value) -> Option<value>,
-) -> Pairs<ByteArray, value> {
-  when self is {
-    [] -> [Pair(k, v)]
-    [Pair(k2, v2), ..rest] ->
-      if builtin.less_than_bytearray(k, k2) {
-        [Pair(k, v), ..self]
-      } else {
-        if k == k2 {
-          when with(k, v, v2) is {
-            Some(combined) -> [Pair(k, combined), ..rest]
-            None -> rest
-          }
-        } else {
-          [Pair(k2, v2), ..do_insert_with(rest, k, v, with)]
-        }
-      }
-  }
-}
-
-fn do_insert_with_alt(
   self: Pairs<ByteArray, value>,
   key k: ByteArray,
   value v: value,
@@ -1120,7 +1019,7 @@ fn do_insert_with_alt(
             fn() { rest },
           )
         } else {
-          [Pair(k2, v2), ..do_insert_with_alt(rest, k, v, with)]
+          [Pair(k2, v2), ..do_insert_with(rest, k, v, with)]
         }
       }
   }
@@ -1136,7 +1035,7 @@ test union_with_1() {
       |> insert(bar, 42)
       |> insert(foo, 1337)
 
-  let result = union_with(left, right, with: fn(_, l, r) { Some(l + r) })
+  let result = union_with(left, right, with: union.sum())
 
   result == from_pairs([Pair(foo, 1351), Pair(bar, 42)])
 }

lib/cardano/assets.ak

@@ -78,7 +78,7 @@ pub fn from_asset_list(xs: Pairs<PolicyId, Pairs<AssetName, Int>>) -> Value {
           expect Pair(p, [_, ..] as x) = inner
           x
             |> from_ascending_pairs_with(fn(v) { v != 0 })
-            |> dict.insert_with_alt(acc, p, _, union.expect_no_duplicate())
+            |> dict.insert_with(acc, p, _, union.expect_no_duplicate())
         },
       )
     |> Value
@@ -551,12 +551,7 @@ pub fn add(
     let helper =
       fn(_, left, _right, keep, discard) {
         let inner_result =
-          dict.insert_with_alt(
-            left,
-            asset_name,
-            quantity,
-            union.sum_if_non_zero(),
-          )
+          dict.insert_with(left, asset_name, quantity, union.sum_if_non_zero())
 
         if dict.is_empty(inner_result) {
           discard()
@@ -566,7 +561,7 @@ pub fn add(
       }
 
     Value(
-      dict.insert_with_alt(
+      dict.insert_with(
         self.inner,
         policy_id,
         dict.from_ascending_pairs([Pair(asset_name, quantity)]),
@@ -618,11 +613,11 @@ test add_5() {
 /// Combine two `Value` together.
 pub fn merge(left v0: Value, right v1: Value) -> Value {
   Value(
-    dict.union_with_alt(
+    dict.union_with(
       v0.inner,
       v1.inner,
       fn(_, a0, a1, keep, discard) {
-        let result = dict.union_with_alt(a0, a1, union.sum_if_non_zero())
+        let result = dict.union_with(a0, a1, union.sum_if_non_zero())
         if dict.is_empty(result) {
           discard()
         } else {