Merge rust-bitcoin#4557: Move CheckedSum and add Weight

9dac4d6 Implement CheckedSum for Weight iterator (yancy)
0dbcd09 Move CheckedSum trait to crate root (yancy)

Pull request description:

  * Move CheckedSum to the crate root so that other types can be added
  * Add Weight to CheckedSum

ACKs for top commit:
  tcharding:
    ACK 9dac4d6
  apoelstra:
    ACK 9dac4d6; successfully ran local tests

Tree-SHA512: 3e4b7f79074e23493ccd17a026542081f0d7a811f4f35edb7994ada95bf414a166531f142ad4986d27fcec448209b2ffa56813b495b5df6b6e8fcd589392e0c1

Author: apoelstra

bitcoin/src/lib.rs

@@ -204,14 +204,15 @@ pub mod amount {
 
     #[rustfmt::skip]            // Keep public re-exports separate.
     #[doc(inline)]
+    pub use units::CheckedSum;
+    #[cfg(feature = "serde")]
+    pub use units::amount::serde;
     pub use units::amount::{
-        Amount, CheckedSum, Denomination, Display, InvalidCharacterError, MissingDenominationError,
+        Amount, Denomination, Display, InvalidCharacterError, MissingDenominationError,
         MissingDigitsError, OutOfRangeError, ParseAmountError, ParseDenominationError, ParseError,
         PossiblyConfusingDenominationError, SignedAmount, TooPreciseError,
         UnknownDenominationError,
     };
-    #[cfg(feature = "serde")]
-    pub use units::amount::serde;
 
     impl Decodable for Amount {
         #[inline]

units/src/amount/mod.rs

@@ -26,6 +26,7 @@ use core::str::FromStr;
 use arbitrary::{Arbitrary, Unstructured};
 
 use self::error::{MissingDigitsKind, ParseAmountErrorInner, ParseErrorInner};
+use crate::CheckedSum;
 
 #[rustfmt::skip]                // Keep public re-exports separate.
 #[doc(inline)]
@@ -593,13 +594,6 @@ enum DisplayStyle {
     DynamicDenomination,
 }
 
-/// Calculates the sum over the iterator using checked arithmetic.
-pub trait CheckedSum<R>: sealed::Sealed<R> {
-    /// Calculates the sum over the iterator using checked arithmetic. If an
-    /// overflow happens it returns [`None`].
-    fn checked_sum(self) -> Option<R>;
-}
-
 impl<T> CheckedSum<Amount> for T
 where
     T: Iterator<Item = Amount>,
@@ -616,16 +610,6 @@ where
     }
 }
 
-mod sealed {
-    use super::{Amount, SignedAmount};
-
-    /// Used to seal the `CheckedSum` trait
-    pub trait Sealed<A> {}
-
-    impl<T> Sealed<Amount> for T where T: Iterator<Item = Amount> {}
-    impl<T> Sealed<SignedAmount> for T where T: Iterator<Item = SignedAmount> {}
-}
-
 #[cfg(feature = "arbitrary")]
 impl<'a> Arbitrary<'a> for Denomination {
     fn arbitrary(u: &mut Unstructured<'a>) -> arbitrary::Result<Self> {

units/src/lib.rs

@@ -69,3 +69,21 @@ pub(crate) use self::result::OptionExt;
 #[deprecated(since = "TBD", note = "use `BlockHeightInterval` instead")]
 #[doc(hidden)]
 pub type BlockInterval = BlockHeightInterval;
+
+/// Calculates the sum over the iterator using checked arithmetic.
+pub trait CheckedSum<R>: sealed::Sealed<R> {
+    /// Calculates the sum over the iterator using checked arithmetic. If an
+    /// overflow happens it returns [`None`].
+    fn checked_sum(self) -> Option<R>;
+}
+
+mod sealed {
+    use super::{Amount, SignedAmount, Weight};
+
+    /// Used to seal the `CheckedSum` trait
+    pub trait Sealed<A> {}
+
+    impl<T> Sealed<Amount> for T where T: Iterator<Item = Amount> {}
+    impl<T> Sealed<SignedAmount> for T where T: Iterator<Item = SignedAmount> {}
+    impl<T> Sealed<Weight> for T where T: Iterator<Item = Weight> {}
+}

units/src/weight.rs

@@ -10,6 +10,8 @@ use arbitrary::{Arbitrary, Unstructured};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
+use crate::CheckedSum;
+
 /// The factor that non-witness serialization data is multiplied by during weight calculation.
 pub const WITNESS_SCALE_FACTOR: usize = 4;
 
@@ -241,6 +243,13 @@ impl ops::RemAssign<u64> for Weight {
     fn rem_assign(&mut self, rhs: u64) { *self = Weight::from_wu(self.to_wu() % rhs); }
 }
 
+impl<T> CheckedSum<Weight> for T
+where
+    T: Iterator<Item = Weight>,
+{
+    fn checked_sum(mut self) -> Option<Weight> { self.try_fold(Weight::ZERO, Weight::checked_add) }
+}
+
 impl core::iter::Sum for Weight {
     fn sum<I>(iter: I) -> Self
     where
@@ -524,4 +533,16 @@ mod tests {
         weight %= 3;
         assert_eq!(weight, Weight::from_wu(1));
     }
+
+    #[test]
+    #[cfg(feature = "alloc")]
+    fn checked_sum_weights() {
+        assert_eq!([].into_iter().checked_sum(), Some(Weight::ZERO));
+
+        let sum = alloc::vec![0, 1, 2].iter().map(|&w| Weight::from_wu(w)).checked_sum().unwrap();
+        assert_eq!(sum, Weight::from_wu(3));
+
+        let sum = alloc::vec![1, u64::MAX].iter().map(|&w| Weight::from_wu(w)).checked_sum();
+        assert!(sum.is_none());
+    }
 }

units/tests/api.rs

@@ -15,7 +15,7 @@ use arbitrary::{Arbitrary, Unstructured};
 use bitcoin_units::locktime::{absolute, relative}; // Typical usage is `absolute::Height`.
 use bitcoin_units::{
     amount, block, fee_rate, locktime, parse, weight, Amount, BlockHeight, BlockInterval, BlockMtp,
-    BlockMtpInterval, BlockTime, FeeRate, SignedAmount, Weight,
+    BlockMtpInterval, BlockTime, CheckedSum, FeeRate, SignedAmount, Weight,
 };
 
 /// A struct that includes all public non-error enums.
@@ -272,7 +272,8 @@ fn regression_default() {
 fn dyn_compatible() {
     // If this builds then traits are dyn compatible.
     struct Traits {
-        a: Box<dyn amount::CheckedSum<Amount>>,
+        a: Box<dyn CheckedSum<Amount>>,
+        b: Box<dyn CheckedSum<Weight>>,
         // These traits are explicitly not dyn compatible.
         // b: Box<dyn amount::serde::SerdeAmount>,
         // c: Box<dyn amount::serde::SerdeAmountForOpt>,