TLA  Line data    Source code

       1                 : /// A helper to "accumulate" a value similar to `Iterator::reduce`, but lets you
       2                 : /// feed the accumulated values by calling the 'accum' function, instead of having an
       3                 : /// iterator.
       4                 : ///
       5                 : /// For example, to calculate the smallest value among some integers:
       6                 : ///
       7                 : /// ```
       8                 : /// use utils::accum::Accum;
       9                 : ///
      10                 : /// let values = [1, 2, 3];
      11                 : ///
      12                 : /// let mut min_value: Accum<u32> = Accum(None);
      13                 : /// for new_value in &values {
      14                 : ///     min_value.accum(std::cmp::min, *new_value);
      15                 : /// }
      16                 : ///
      17                 : /// assert_eq!(min_value.0.unwrap(), 1);
      18                 : /// ```
      19                 : pub struct Accum<T>(pub Option<T>);
      20                 : impl<T: Copy> Accum<T> {
      21 UBC           0 :     pub fn accum<F>(&mut self, func: F, new_value: T)
      22               0 :     where
      23               0 :         F: FnOnce(T, T) -> T,
      24               0 :     {
      25                 :         // If there is no previous value, just store the new value.
      26                 :         // Otherwise call the function to decide which one to keep.
      27               0 :         self.0 = Some(if let Some(accum) = self.0 {
      28               0 :             func(accum, new_value)
      29                 :         } else {
      30               0 :             new_value
      31                 :         });
      32               0 :     }
      33                 : }