Add a few scott encoding instead of option functions to dict and try it out in assets

Author: MicroProofs

lib/aiken/collection/dict.ak

@@ -751,6 +751,24 @@ pub fn insert_with(
   }
 }
 
+pub fn insert_with_alt(
+  self: Dict<key, value>,
+  key k: ByteArray,
+  value v: value,
+  with: fn(ByteArray, value, value) ->
+    fn(fn(value) -> Pairs<ByteArray, value>, fn() -> Pairs<ByteArray, value>) ->
+      Pairs<ByteArray, value>,
+) -> Dict<key, value> {
+  Dict {
+    inner: do_insert_with_alt(
+      self.inner,
+      k,
+      v,
+      fn(k, v1, v2) { with(k, v2, v1) },
+    ),
+  }
+}
+
 test insert_with_1() {
   let sum =
     fn(_k, a, b) { Some(a + b) }
@@ -764,6 +782,19 @@ test insert_with_1() {
   result == [Pair("bar", 2), Pair("foo", 1)]
 }
 
+test insert_with_alt_1() {
+  let sum =
+    fn(_k, a, b) { fn(som, _non) { som(a + b) } }
+
+  let result =
+    empty
+      |> insert_with_alt(key: "foo", value: 1, with: sum)
+      |> insert_with_alt(key: "bar", value: 2, with: sum)
+      |> to_pairs()
+
+  result == [Pair("bar", 2), Pair("foo", 1)]
+}
+
 test insert_with_2() {
   let sum =
     fn(_k, a, b) { Some(a + b) }
@@ -1016,6 +1047,16 @@ pub fn union_with(
   Dict { inner: do_union_with(left.inner, right.inner, with) }
 }
 
+pub fn union_with_alt(
+  left: Dict<key, value>,
+  right: Dict<key, value>,
+  with: fn(ByteArray, value, value) ->
+    fn(fn(value) -> Pairs<ByteArray, value>, fn() -> Pairs<ByteArray, value>) ->
+      Pairs<ByteArray, value>,
+) -> Dict<key, value> {
+  Dict { inner: do_union_with_alt(left.inner, right.inner, with) }
+}
+
 fn do_union_with(
   left: Pairs<ByteArray, value>,
   right: Pairs<ByteArray, value>,
@@ -1028,6 +1069,20 @@ fn do_union_with(
   }
 }
 
+fn do_union_with_alt(
+  left: Pairs<ByteArray, value>,
+  right: Pairs<ByteArray, value>,
+  with: fn(ByteArray, value, value) ->
+    fn(fn(value) -> Pairs<ByteArray, value>, fn() -> Pairs<ByteArray, value>) ->
+      Pairs<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)
+  }
+}
+
 fn do_insert_with(
   self: Pairs<ByteArray, value>,
   key k: ByteArray,
@@ -1052,6 +1107,32 @@ fn do_insert_with(
   }
 }
 
+fn do_insert_with_alt(
+  self: Pairs<ByteArray, value>,
+  key k: ByteArray,
+  value v: value,
+  with: fn(ByteArray, value, value) ->
+    fn(fn(value) -> Pairs<ByteArray, value>, fn() -> Pairs<ByteArray, value>) ->
+      Pairs<ByteArray, 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 {
+          with(k, v, v2)(
+            fn(combined) { [Pair(k, combined), ..rest] },
+            fn() { rest },
+          )
+        } else {
+          [Pair(k2, v2), ..do_insert_with_alt(rest, k, v, with)]
+        }
+      }
+  }
+}
+
 test union_with_1() {
   let left =
     empty

lib/cardano/assets.ak

@@ -77,7 +77,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(
+            |> dict.insert_with_alt(
                 acc,
                 p,
                 _,
@@ -556,29 +556,34 @@ pub fn add(
   } else {
     let helper =
       fn(_, left, _right) {
-        let inner_result =
-          dict.insert_with(
-            left,
-            asset_name,
-            quantity,
-            fn(_k, ql, qr) {
-              let q = ql + qr
-              if q == 0 {
-                None
-              } else {
-                Some(q)
-              }
-            },
-          )
-        if dict.is_empty(inner_result) {
-          None
-        } else {
-          Some(inner_result)
+        fn(som, non) {
+          let inner_result =
+            dict.insert_with_alt(
+              left,
+              asset_name,
+              quantity,
+              fn(_k, ql, qr) {
+                fn(som, non) {
+                  let q = ql + qr
+                  if q == 0 {
+                    non()
+                  } else {
+                    som(q)
+                  }
+                }
+              },
+            )
+
+          if dict.is_empty(inner_result) {
+            non()
+          } else {
+            som(inner_result)
+          }
         }
       }
 
     Value(
-      dict.insert_with(
+      dict.insert_with_alt(
         self.inner,
         policy_id,
         dict.from_ascending_pairs([Pair(asset_name, quantity)]),
@@ -630,27 +635,31 @@ test add_5() {
 /// Combine two `Value` together.
 pub fn merge(left v0: Value, right v1: Value) -> Value {
   Value(
-    dict.union_with(
+    dict.union_with_alt(
       v0.inner,
       v1.inner,
       fn(_, a0, a1) {
-        let result =
-          dict.union_with(
-            a0,
-            a1,
-            fn(_, q0, q1) {
-              let q = q0 + q1
-              if q == 0 {
-                None
-              } else {
-                Some(q)
-              }
-            },
-          )
-        if dict.is_empty(result) {
-          None
-        } else {
-          Some(result)
+        fn(som, non) {
+          let result =
+            dict.union_with_alt(
+              a0,
+              a1,
+              fn(_, q0, q1) {
+                fn(som, non) {
+                  let q = q0 + q1
+                  if q == 0 {
+                    non()
+                  } else {
+                    som(q)
+                  }
+                }
+              },
+            )
+          if dict.is_empty(result) {
+            non()
+          } else {
+            som(result)
+          }
         }
       },
     ),