types: replace closure with iterator

Simplifies the API and reduces copying.

Author: apoelstra

src/miniscript/types/correctness.rs

@@ -467,13 +467,12 @@ impl Correctness {
 
     /// Constructor for the correctness properties of the `thresh` fragment
     // Cannot be constfn because it takes a closure.
-    pub fn threshold<S>(_k: usize, n: usize, mut sub_ck: S) -> Result<Self, ErrorKind>
+    pub fn threshold<'a, I>(_k: usize, subs: I) -> Result<Self, ErrorKind>
     where
-        S: FnMut(usize) -> Self,
+        I: Iterator<Item = &'a Self>,
     {
         let mut num_args = 0;
-        for i in 0..n {
-            let subtype = sub_ck(i);
+        for (i, subtype) in subs.enumerate() {
             num_args += match subtype.input {
                 Input::Zero => 0,
                 Input::One | Input::OneNonZero => 1,

src/miniscript/types/malleability.rs

@@ -278,19 +278,20 @@ impl Malleability {
 
     /// Constructor for the malleabilitiy properties of the `thresh` fragment.
     // Cannot be constfn because it takes a closure.
-    pub fn threshold<S>(k: usize, n: usize, mut sub_ck: S) -> Self
+    pub fn threshold<'a, I>(k: usize, subs: I) -> Self
     where
-        S: FnMut(usize) -> Self,
+        I: ExactSizeIterator<Item = &'a Self>,
     {
+        let n = subs.len();
         let mut safe_count = 0;
         let mut all_are_dissat_unique = true;
         let mut all_are_non_malleable = true;
-        for i in 0..n {
-            let subtype = sub_ck(i);
+        for subtype in subs {
             safe_count += usize::from(subtype.safe);
             all_are_dissat_unique &= subtype.dissat == Dissat::Unique;
             all_are_non_malleable &= subtype.non_malleable;
         }
+
         Malleability {
             dissat: if all_are_dissat_unique && safe_count == n {
                 Dissat::Unique

src/miniscript/types/mod.rs

@@ -464,13 +464,13 @@ impl Type {
 
     /// Constructor for the type of the `thresh` fragment.
     // Cannot be a constfn because it takes a closure.
-    pub fn threshold<S>(k: usize, n: usize, mut sub_ck: S) -> Result<Self, ErrorKind>
+    pub fn threshold<'a, I>(k: usize, subs: I) -> Result<Self, ErrorKind>
     where
-        S: FnMut(usize) -> Self,
+        I: Clone + ExactSizeIterator<Item = &'a Self>,
     {
         Ok(Type {
-            corr: Correctness::threshold(k, n, |n| sub_ck(n).corr)?,
-            mall: Malleability::threshold(k, n, |n| sub_ck(n).mall),
+            corr: Correctness::threshold(k, subs.clone().map(|s| &s.corr))?,
+            mall: Malleability::threshold(k, subs.map(|s| &s.mall)),
         })
     }
 }
@@ -593,7 +593,7 @@ impl Type {
                     });
                 }
 
-                let res = Self::threshold(k, subs.len(), |n| subs[n].ty);
+                let res = Self::threshold(k, subs.iter().map(|ms| &ms.ty));
 
                 res.map_err(|kind| Error { fragment_string: fragment.to_string(), error: kind })
             }