types: remove error path from sub-fragment parameter to threshold()

This was one last set of unused error paths that was hard to remove
until I'd removed the Property trait from Type. But now that's done so I
can do it.

Author: apoelstra

src/miniscript/types/correctness.rs

@@ -469,11 +469,11 @@ impl Correctness {
     // Cannot be constfn because it takes a closure.
     pub fn threshold<S>(_k: usize, n: usize, mut sub_ck: S) -> Result<Self, ErrorKind>
     where
-        S: FnMut(usize) -> Result<Self, ErrorKind>,
+        S: FnMut(usize) -> Self,
     {
         let mut num_args = 0;
         for i in 0..n {
-            let subtype = sub_ck(i)?;
+            let subtype = sub_ck(i);
             num_args += match subtype.input {
                 Input::Zero => 0,
                 Input::One | Input::OneNonZero => 1,

src/miniscript/types/malleability.rs

@@ -280,27 +280,27 @@ 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) -> Result<Self, ErrorKind>
+    pub fn threshold<S>(k: usize, n: usize, mut sub_ck: S) -> Self
     where
-        S: FnMut(usize) -> Result<Self, ErrorKind>,
+        S: FnMut(usize) -> Self,
     {
         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)?;
+            let subtype = sub_ck(i);
             safe_count += usize::from(subtype.safe);
             all_are_dissat_unique &= subtype.dissat == Dissat::Unique;
             all_are_non_malleable &= subtype.non_malleable;
         }
-        Ok(Malleability {
+        Malleability {
             dissat: if all_are_dissat_unique && safe_count == n {
                 Dissat::Unique
             } else {
                 Dissat::Unknown
             },
             safe: safe_count > n - k,
             non_malleable: all_are_non_malleable && safe_count >= n - k && all_are_dissat_unique,
-        })
+        }
     }
 }

src/miniscript/types/mod.rs

@@ -466,11 +466,11 @@ impl Type {
     // Cannot be a constfn because it takes a closure.
     pub fn threshold<S>(k: usize, n: usize, mut sub_ck: S) -> Result<Self, ErrorKind>
     where
-        S: FnMut(usize) -> Result<Self, ErrorKind>,
+        S: FnMut(usize) -> Self,
     {
         Ok(Type {
-            corr: Correctness::threshold(k, n, |n| Ok(sub_ck(n)?.corr))?,
-            mall: Malleability::threshold(k, n, |n| Ok(sub_ck(n)?.mall))?,
+            corr: Correctness::threshold(k, n, |n| sub_ck(n).corr)?,
+            mall: Malleability::threshold(k, n, |n| sub_ck(n).mall),
         })
     }
 }
@@ -593,7 +593,7 @@ impl Type {
                     });
                 }
 
-                let res = Self::threshold(k, subs.len(), |n| Ok(subs[n].ty));
+                let res = Self::threshold(k, subs.len(), |n| subs[n].ty);
 
                 res.map_err(|kind| Error { fragment_string: fragment.to_string(), error: kind })
             }