clippy: use try_fold in place of fold in several places

Author: apoelstra

src/descriptor/key.rs

@@ -852,8 +852,7 @@ fn parse_xkey_deriv<K: InnerXKey>(
         // step all the vectors of indexes contain a single element. If it did though, one of the
         // vectors contains more than one element.
         // Now transform this list of vectors of steps into distinct derivation paths.
-        .fold(Ok(Vec::new()), |paths, index_list| {
-            let mut paths = paths?;
+        .try_fold(Vec::new(), |mut paths, index_list| {
             let mut index_list = index_list?.into_iter();
             let first_index = index_list
                 .next()

src/miniscript/types/extra_props.rs

@@ -792,11 +792,11 @@ impl Property for ExtData {
                 .iter()
                 .rev()
                 .enumerate()
-                .fold(Some(0), |acc, (i, &(x, y))| {
+                .try_fold(0, |acc, (i, &(x, y))| {
                     if i <= k {
-                        opt_add(acc, x)
+                        x.map(|x| acc + x)
                     } else {
-                        opt_add(acc, y)
+                        y.map(|y| acc + y)
                     }
                 });
 
@@ -805,11 +805,11 @@ impl Property for ExtData {
             .iter()
             .rev()
             .enumerate()
-            .fold(Some(0), |acc, (i, &(x, y))| {
+            .try_fold(0, |acc, (i, &(x, y))| {
                 if i <= k {
-                    opt_max(acc, x)
+                    x.map(|x| acc + x)
                 } else {
-                    opt_max(acc, y)
+                    y.map(|y| acc + y)
                 }
             });
 
@@ -819,11 +819,11 @@ impl Property for ExtData {
             max_sat_size_vec
                 .iter()
                 .enumerate()
-                .fold(Some((0, 0)), |acc, (i, &(x, y))| {
+                .try_fold((0, 0), |acc, (i, &(x, y))| {
                     if i <= k {
-                        opt_tuple_add(acc, x)
+                        x.map(|(x0, x1)| (acc.0 + x0, acc.1 + x1))
                     } else {
-                        opt_tuple_add(acc, y)
+                        y.map(|(y0, y1)| (acc.0 + y0, acc.1 + y1))
                     }
                 });
 
@@ -832,11 +832,11 @@ impl Property for ExtData {
             ops_count_sat_vec
                 .iter()
                 .enumerate()
-                .fold(Some(0), |acc, (i, &(x, y))| {
+                .try_fold(0, |acc, (i, &(x, y))| {
                     if i <= k {
-                        opt_add(acc, x)
+                        x.map(|x| acc + x)
                     } else {
-                        opt_add(acc, Some(y))
+                        Some(acc + y)
                     }
                 });
 
@@ -1049,11 +1049,6 @@ fn opt_max<T: Ord>(a: Option<T>, b: Option<T>) -> Option<T> {
 /// Returns Some(x+y) is both x and y are Some. Otherwise, returns `None`.
 fn opt_add(a: Option<usize>, b: Option<usize>) -> Option<usize> { a.and_then(|x| b.map(|y| x + y)) }
 
-/// Returns Some((x0+y0, x1+y1)) is both x and y are Some. Otherwise, returns `None`.
-fn opt_tuple_add(a: Option<(usize, usize)>, b: Option<(usize, usize)>) -> Option<(usize, usize)> {
-    a.and_then(|x| b.map(|(w, s)| (w + x.0, s + x.1)))
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;