Merge branch 'master' into updated-flake-lock

Author: szg251

Cargo.lock

@@ -17,6 +17,7 @@ true = { version = "0.1.0", optional = true }
 data-encoding = { version = "2.4.0", optional = true }
 thiserror = "1.0.50"
 linked-hash-map = "0.5.6"
+num-traits = "0.2.17"
 
 [features]
 serde = ["dep:serde", "num-bigint/serde"]

Cargo.toml

@@ -7,4 +7,4 @@ pub mod v1;
 pub mod v2;
 #[cfg(feature = "lbf")]
 pub use lbr_prelude::json;
-pub(crate) mod utils;
+pub mod utils;

src/lib.rs

@@ -0,0 +1,39 @@
+use std::{
+    collections::BTreeMap,
+    iter::{empty, once},
+};
+
+pub mod value;
+
+/// Create a container C from one element.
+pub fn singleton<T, C>(value: T) -> C
+where
+    C: FromIterator<T>,
+{
+    once(value).collect()
+}
+
+/// Create an empty container.
+pub fn none<T, C>() -> C
+where
+    C: FromIterator<T>,
+{
+    empty::<T>().collect()
+}
+
+/// Union two BTreeMaps, call f to resolve conflicts if duplicate keys are encountered.
+pub fn union_btree_maps_with<K: Clone + Ord, V: Clone, F: Fn(V, V) -> V>(
+    f: F,
+    l: BTreeMap<K, V>,
+    r: BTreeMap<K, V>,
+) -> BTreeMap<K, V> {
+    r.into_iter().fold(l.clone(), |mut acc, (k, vr)| {
+        let v = if let Some((_, vl)) = acc.remove_entry(&k) {
+            f(vl, vr)
+        } else {
+            vr
+        };
+        acc.insert(k, v);
+        acc
+    })
+}

src/utils.rs

@@ -0,0 +1,144 @@
+#![allow(unused_macros)]
+
+macro_rules! forward_val_val_binop {
+    (impl $imp:ident for $res:ty, $method:ident) => {
+        impl $imp<$res> for $res {
+            type Output = $res;
+
+            #[inline]
+            fn $method(self, other: $res) -> $res {
+                // forward to val-ref
+                $imp::$method(self, &other)
+            }
+        }
+    };
+}
+
+macro_rules! forward_ref_val_binop {
+    (impl $imp:ident for $res:ty, $method:ident) => {
+        impl $imp<$res> for &$res {
+            type Output = $res;
+
+            #[inline]
+            fn $method(self, other: $res) -> $res {
+                // forward to ref-ref
+                $imp::$method(self, &other)
+            }
+        }
+    };
+}
+
+macro_rules! forward_val_ref_binop {
+    (impl $imp:ident for $res:ty, $method:ident) => {
+        impl $imp<&$res> for $res {
+            type Output = $res;
+
+            #[inline]
+            fn $method(self, other: &$res) -> $res {
+                // forward to ref-ref
+                $imp::$method(&self, other)
+            }
+        }
+    };
+}
+
+macro_rules! forward_scalar_val_val_binop_to_ref_val {
+    (impl $imp:ident<$scalar:ty> for $res:ty, $method:ident) => {
+        impl $imp<$scalar> for $res {
+            type Output = $res;
+
+            #[inline]
+            fn $method(self, other: $scalar) -> $res {
+                $imp::$method(&self, other)
+            }
+        }
+
+        impl $imp<$res> for $scalar {
+            type Output = $res;
+
+            #[inline]
+            fn $method(self, other: $res) -> $res {
+                $imp::$method(self, &other)
+            }
+        }
+    };
+}
+
+macro_rules! forward_scalar_ref_val_binop_to_ref_ref {
+    (impl $imp:ident<$scalar:ty> for $res:ty, $method:ident) => {
+        impl $imp<$scalar> for &$res {
+            type Output = $res;
+
+            #[inline]
+            fn $method(self, other: $scalar) -> $res {
+                $imp::$method(self, &other)
+            }
+        }
+
+        impl $imp<$res> for &$scalar {
+            type Output = $res;
+
+            #[inline]
+            fn $method(self, other: $res) -> $res {
+                $imp::$method(self, &other)
+            }
+        }
+    };
+}
+
+macro_rules! forward_scalar_val_ref_binop_to_ref_val {
+    (impl $imp:ident<$scalar:ty> for $res:ty, $method:ident) => {
+        impl $imp<&$scalar> for $res {
+            type Output = $res;
+
+            #[inline]
+            fn $method(self, other: &$scalar) -> $res {
+                $imp::$method(&self, other)
+            }
+        }
+
+        impl $imp<&$res> for $scalar {
+            type Output = $res;
+
+            #[inline]
+            fn $method(self, other: &$res) -> $res {
+                $imp::$method(&self, other)
+            }
+        }
+    };
+}
+
+macro_rules! forward_scalar_ref_ref_binop_commutative {
+    (impl $imp:ident<$scalar:ty> for $res:ty, $method:ident) => {
+        impl $imp<&$res> for &$scalar {
+            type Output = $res;
+
+            #[inline]
+            fn $method(self, other: &$res) -> $res {
+                $imp::$method(other, self)
+            }
+        }
+    };
+}
+
+macro_rules! forward_into_bigint_scalar_ref_val_binop_to_ref_ref {
+    (impl $imp:ident<$scalar:ty> for $res:ty, $method:ident) => {
+        impl $imp<$scalar> for &$res {
+            type Output = $res;
+
+            #[inline]
+            fn $method(self, other: $scalar) -> $res {
+                $imp::$method(self, &BigInt::from(other))
+            }
+        }
+
+        impl $imp<&$res> for $scalar {
+            type Output = $res;
+
+            #[inline]
+            fn $method(self, other: &$res) -> $res {
+                $imp::$method(&BigInt::from(self), other)
+            }
+        }
+    };
+}

src/utils/mod.rs

@@ -0,0 +1,3 @@
+#[macro_use]
+pub mod macros;
+pub mod value_utils;