introduce type-alias and simplify the API.

Author: KtorZ

lib/aiken/collection/dict.ak

@@ -13,6 +13,7 @@
 //// > [`dict.from_ascending_list`](#from_ascending_list).
 
 use aiken/builtin
+use aiken/collection/dict/union.{UnionStrategy}
 
 /// An opaque `Dict`. The type is opaque because the module maintains some
 /// invariant, namely: there's only one occurrence of a given key in the dictionary.
@@ -755,16 +756,14 @@ 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>,
+  with: UnionStrategy<ByteArray, value>,
 ) -> Dict<key, value> {
   Dict {
     inner: do_insert_with_alt(
       self.inner,
       k,
       v,
-      fn(k, v1, v2) { with(k, v2, v1) },
+      fn(k, v1, v2, some, none) { with(k, v2, v1, some, none) },
     ),
   }
 }
@@ -783,13 +782,10 @@ test insert_with_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)
+      |> insert_with_alt(key: "foo", value: 1, with: union.sum())
+      |> insert_with_alt(key: "bar", value: 2, with: union.sum())
       |> to_pairs()
 
   result == [Pair("bar", 2), Pair("foo", 1)]
@@ -1050,9 +1046,7 @@ pub fn union_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>,
+  with: UnionStrategy<ByteArray, value>,
 ) -> Dict<key, value> {
   Dict { inner: do_union_with_alt(left.inner, right.inner, with) }
 }
@@ -1072,9 +1066,7 @@ 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>,
+  with: UnionStrategy<ByteArray, value>,
 ) -> Pairs<ByteArray, value> {
   when left is {
     [] -> right
@@ -1111,9 +1103,7 @@ 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>,
+  with: UnionStrategy<ByteArray, value>,
 ) -> Pairs<ByteArray, value> {
   when self is {
     [] -> [Pair(k, v)]
@@ -1122,7 +1112,10 @@ fn do_insert_with_alt(
         [Pair(k, v), ..self]
       } else {
         if k == k2 {
-          with(k, v, v2)(
+          with(
+            k,
+            v,
+            v2,
             fn(combined) { [Pair(k, combined), ..rest] },
             fn() { rest },
           )

lib/aiken/collection/dict/union.ak

@@ -0,0 +1,47 @@
+/// A strategy for combining two values in a dictionnary that belong to the same key.
+pub type UnionStrategy<key, value> =
+  fn(key, value, value, KeepValue<key, value>, DiscardValue<key, value>) ->
+    Pairs<key, value>
+
+/// A callback to keep a combined valueat a given key
+pub type KeepValue<key, value> =
+  fn(value) -> Pairs<key, value>
+
+/// A callback to discard a value at a given key
+pub type DiscardValue<key, value> =
+  fn() -> Pairs<key, value>
+
+/// A strategy which always fail, enforcing the dict contains no duplicate.
+pub fn expect_no_duplicate() -> UnionStrategy<key, value> {
+  fn(_, _, _, _, _) {
+    fail @"unexpected duplicate key found in dict."
+  }
+}
+
+/// Combine values by keeping the values present in the left-most dict.
+pub fn keep_left() -> UnionStrategy<key, value> {
+  fn(_key, left, _right, keep, _discard) { keep(left) }
+}
+
+/// Combine values by keeping the values present in the left-most dict.
+pub fn keep_right() -> UnionStrategy<key, value> {
+  fn(_key, _left, right, keep, _discard) { keep(right) }
+}
+
+/// Combine values by taking their sum.
+pub fn sum() -> UnionStrategy<key, Int> {
+  fn(_key, left, right, keep, _discard) { keep(left + right) }
+}
+
+/// Combine values by taking their sum, only if it is non-null. Otherwise,
+/// discard the key/value entirely.
+pub fn sum_if_non_zero() -> UnionStrategy<key, Int> {
+  fn(_key, left, right, keep, discard) {
+    let value = left + right
+    if value == 0 {
+      discard()
+    } else {
+      keep(value)
+    }
+  }
+}

lib/cardano/assets.ak

@@ -1,5 +1,6 @@
 use aiken/builtin
 use aiken/collection/dict.{Dict, from_ascending_pairs_with}
+use aiken/collection/dict/union
 use aiken/collection/list
 use aiken/crypto.{Blake2b_224, Hash, Script}
 use aiken/option
@@ -77,14 +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,
-                _,
-                fn(_, _, _) {
-                  fail @"Duplicate policy in the asset list."
-                },
-              )
+            |> dict.insert_with_alt(acc, p, _, union.expect_no_duplicate())
         },
       )
     |> Value
@@ -555,30 +549,19 @@ pub fn add(
     self
   } else {
     let helper =
-      fn(_, left, _right) {
-        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)
-          }
+      fn(_, left, _right, keep, discard) {
+        let inner_result =
+          dict.insert_with_alt(
+            left,
+            asset_name,
+            quantity,
+            union.sum_if_non_zero(),
+          )
+
+        if dict.is_empty(inner_result) {
+          discard()
+        } else {
+          keep(inner_result)
         }
       }
 
@@ -638,28 +621,12 @@ pub fn merge(left v0: Value, right v1: Value) -> Value {
     dict.union_with_alt(
       v0.inner,
       v1.inner,
-      fn(_, a0, a1) {
-        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)
-          }
+      fn(_, a0, a1, keep, discard) {
+        let result = dict.union_with_alt(a0, a1, union.sum_if_non_zero())
+        if dict.is_empty(result) {
+          discard()
+        } else {
+          keep(result)
         }
       },
     ),