policy: rename Threshold variant to Thresh

This matches the same variant in Terminal, matches the string
serialization "thresh", and will avoid weird compiler errors related to
collisions with the upcoming `Threshold` type.

This will be an annoying API-breaking change, but fortunately(?) this PR
is already breaking the API for thresholds in an annoying way.

Author: apoelstra

src/descriptor/sortedmulti.rs

@@ -198,7 +198,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> SortedMultiVec<Pk, Ctx> {
 
 impl<Pk: MiniscriptKey, Ctx: ScriptContext> policy::Liftable<Pk> for SortedMultiVec<Pk, Ctx> {
     fn lift(&self) -> Result<policy::semantic::Policy<Pk>, Error> {
-        let ret = policy::semantic::Policy::Threshold(
+        let ret = policy::semantic::Policy::Thresh(
             self.k,
             self.pks
                 .iter()

src/descriptor/tr.rs

@@ -616,7 +616,7 @@ impl<Pk: MiniscriptKey> Liftable<Pk> for TapTree<Pk> {
     fn lift(&self) -> Result<Policy<Pk>, Error> {
         fn lift_helper<Pk: MiniscriptKey>(s: &TapTree<Pk>) -> Result<Policy<Pk>, Error> {
             match *s {
-                TapTree::Tree { ref left, ref right, height: _ } => Ok(Policy::Threshold(
+                TapTree::Tree { ref left, ref right, height: _ } => Ok(Policy::Thresh(
                     1,
                     vec![Arc::new(lift_helper(left)?), Arc::new(lift_helper(right)?)],
                 )),
@@ -632,7 +632,7 @@ impl<Pk: MiniscriptKey> Liftable<Pk> for TapTree<Pk> {
 impl<Pk: MiniscriptKey> Liftable<Pk> for Tr<Pk> {
     fn lift(&self) -> Result<Policy<Pk>, Error> {
         match &self.tree {
-            Some(root) => Ok(Policy::Threshold(
+            Some(root) => Ok(Policy::Thresh(
                 1,
                 vec![
                     Arc::new(Policy::Key(self.internal_key.clone())),

src/policy/compiler.rs

@@ -1008,7 +1008,7 @@ where
             compile_binary!(&mut l_comp[3], &mut r_comp[2], [lw, rw], Terminal::OrI);
             compile_binary!(&mut r_comp[3], &mut l_comp[2], [rw, lw], Terminal::OrI);
         }
-        Concrete::Threshold(k, ref subs) => {
+        Concrete::Thresh(k, ref subs) => {
             let n = subs.len();
             let k_over_n = k as f64 / n as f64;
 
@@ -1389,7 +1389,7 @@ mod tests {
         let policy: BPolicy = Concrete::Or(vec![
             (
                 127,
-                Arc::new(Concrete::Threshold(
+                Arc::new(Concrete::Thresh(
                     3,
                     key_pol[0..5].iter().map(|p| (p.clone()).into()).collect(),
                 )),
@@ -1398,7 +1398,7 @@ mod tests {
                 1,
                 Arc::new(Concrete::And(vec![
                     Arc::new(Concrete::Older(RelLockTime::from_height(10000))),
-                    Arc::new(Concrete::Threshold(
+                    Arc::new(Concrete::Thresh(
                         2,
                         key_pol[5..8].iter().map(|p| (p.clone()).into()).collect(),
                     )),
@@ -1519,7 +1519,7 @@ mod tests {
                 .iter()
                 .map(|pubkey| Arc::new(Concrete::Key(*pubkey)))
                 .collect();
-            let big_thresh = Concrete::Threshold(*k, pubkeys);
+            let big_thresh = Concrete::Thresh(*k, pubkeys);
             let big_thresh_ms: SegwitMiniScript = big_thresh.compile().unwrap();
             if *k == 21 {
                 // N * (PUSH + pubkey + CHECKSIGVERIFY)
@@ -1555,8 +1555,8 @@ mod tests {
             .collect();
 
         let thresh_res: Result<SegwitMiniScript, _> = Concrete::Or(vec![
-            (1, Arc::new(Concrete::Threshold(keys_a.len(), keys_a))),
-            (1, Arc::new(Concrete::Threshold(keys_b.len(), keys_b))),
+            (1, Arc::new(Concrete::Thresh(keys_a.len(), keys_a))),
+            (1, Arc::new(Concrete::Thresh(keys_b.len(), keys_b))),
         ])
         .compile();
         let script_size = thresh_res.clone().and_then(|m| Ok(m.script_size()));
@@ -1573,8 +1573,7 @@ mod tests {
             .iter()
             .map(|pubkey| Arc::new(Concrete::Key(*pubkey)))
             .collect();
-        let thresh_res: Result<SegwitMiniScript, _> =
-            Concrete::Threshold(keys.len(), keys).compile();
+        let thresh_res: Result<SegwitMiniScript, _> = Concrete::Thresh(keys.len(), keys).compile();
         let n_elements = thresh_res
             .clone()
             .and_then(|m| Ok(m.max_satisfaction_witness_elements()));
@@ -1595,7 +1594,7 @@ mod tests {
             .map(|pubkey| Arc::new(Concrete::Key(*pubkey)))
             .collect();
         let thresh_res: Result<SegwitMiniScript, _> =
-            Concrete::Threshold(keys.len() - 1, keys).compile();
+            Concrete::Thresh(keys.len() - 1, keys).compile();
         let ops_count = thresh_res.clone().and_then(|m| Ok(m.ext.ops.op_count()));
         assert_eq!(
             thresh_res,
@@ -1609,7 +1608,7 @@ mod tests {
             .iter()
             .map(|pubkey| Arc::new(Concrete::Key(*pubkey)))
             .collect();
-        let thresh_res = Concrete::Threshold(keys.len() - 1, keys).compile::<Legacy>();
+        let thresh_res = Concrete::Thresh(keys.len() - 1, keys).compile::<Legacy>();
         let ops_count = thresh_res.clone().and_then(|m| Ok(m.ext.ops.op_count()));
         assert_eq!(
             thresh_res,

src/policy/concrete.rs

@@ -69,7 +69,7 @@ pub enum Policy<Pk: MiniscriptKey> {
     /// relative probabilities for each one.
     Or(Vec<(usize, Arc<Policy<Pk>>)>),
     /// A set of descriptors, satisfactions must be provided for `k` of them.
-    Threshold(usize, Vec<Arc<Policy<Pk>>>),
+    Thresh(usize, Vec<Arc<Policy<Pk>>>),
 }
 
 /// Detailed error type for concrete policies.
@@ -187,7 +187,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
                     })
                     .collect::<Vec<_>>()
             }
-            Policy::Threshold(k, ref subs) if *k == 1 => {
+            Policy::Thresh(k, ref subs) if *k == 1 => {
                 let total_odds = subs.len();
                 subs.iter()
                     .flat_map(|policy| policy.to_tapleaf_prob_vec(prob / total_odds as f64))
@@ -242,7 +242,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
     /// ### TapTree compilation
     ///
     /// The policy tree constructed by root-level disjunctions over [`Policy::Or`] and
-    /// [`Policy::Threshold`](1, ..) which is flattened into a vector (with respective
+    /// [`Policy::Thresh`](1, ..) which is flattened into a vector (with respective
     /// probabilities derived from odds) of policies.
     ///
     /// For example, the policy `thresh(1,or(pk(A),pk(B)),and(or(pk(C),pk(D)),pk(E)))` gives the
@@ -294,7 +294,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
     /// ### TapTree compilation
     ///
     /// The policy tree constructed by root-level disjunctions over [`Policy::Or`] and
-    /// [`Policy::Threshold`](k, ..n..) which is flattened into a vector (with respective
+    /// [`Policy::Thresh`](k, ..n..) which is flattened into a vector (with respective
     /// probabilities derived from odds) of policies. For example, the policy
     /// `thresh(1,or(pk(A),pk(B)),and(or(pk(C),pk(D)),pk(E)))` gives the vector
     /// `[pk(A),pk(B),and(or(pk(C),pk(D)),pk(E)))]`.
@@ -407,13 +407,13 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
                     .map(|(odds, pol)| (prob * *odds as f64 / total_odds as f64, pol.clone()))
                     .collect::<Vec<_>>()
             }
-            Policy::Threshold(k, subs) if *k == 1 => {
+            Policy::Thresh(k, subs) if *k == 1 => {
                 let total_odds = subs.len();
                 subs.iter()
                     .map(|pol| (prob / total_odds as f64, pol.clone()))
                     .collect::<Vec<_>>()
             }
-            Policy::Threshold(k, subs) if *k != subs.len() => generate_combination(subs, prob, *k),
+            Policy::Thresh(k, subs) if *k != subs.len() => generate_combination(subs, prob, *k),
             pol => vec![(prob, Arc::new(pol.clone()))],
         }
     }
@@ -562,7 +562,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
                     .enumerate()
                     .map(|(i, (prob, _))| (*prob, child_n(i)))
                     .collect()),
-                Threshold(ref k, ref subs) => Threshold(*k, (0..subs.len()).map(child_n).collect()),
+                Thresh(ref k, ref subs) => Thresh(*k, (0..subs.len()).map(child_n).collect()),
             };
             translated.push(Arc::new(new_policy));
         }
@@ -588,9 +588,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
                     .enumerate()
                     .map(|(i, (prob, _))| (*prob, child_n(i)))
                     .collect())),
-                Threshold(k, ref subs) => {
-                    Some(Threshold(*k, (0..subs.len()).map(child_n).collect()))
-                }
+                Thresh(k, ref subs) => Some(Thresh(*k, (0..subs.len()).map(child_n).collect())),
                 _ => None,
             };
             match new_policy {
@@ -615,7 +613,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
     }
 
     /// Gets the number of [TapLeaf](`TapTree::Leaf`)s considering exhaustive root-level [`Policy::Or`]
-    /// and [`Policy::Threshold`] disjunctions for the `TapTree`.
+    /// and [`Policy::Thresh`] disjunctions for the `TapTree`.
     #[cfg(feature = "compiler")]
     fn num_tap_leaves(&self) -> usize {
         use Policy::*;
@@ -626,7 +624,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
 
             let num = match data.node {
                 Or(subs) => (0..subs.len()).map(num_for_child_n).sum(),
-                Threshold(k, subs) if *k == 1 => (0..subs.len()).map(num_for_child_n).sum(),
+                Thresh(k, subs) if *k == 1 => (0..subs.len()).map(num_for_child_n).sum(),
                 _ => 1,
             };
             nums.push(num);
@@ -709,7 +707,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
                     let iter = (0..subs.len()).map(info_for_child_n);
                     TimelockInfo::combine_threshold(1, iter)
                 }
-                Threshold(ref k, subs) => {
+                Thresh(ref k, subs) => {
                     let iter = (0..subs.len()).map(info_for_child_n);
                     TimelockInfo::combine_threshold(*k, iter)
                 }
@@ -745,7 +743,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
                         return Err(PolicyError::NonBinaryArgOr);
                     }
                 }
-                Threshold(k, ref subs) => {
+                Thresh(k, ref subs) => {
                     if k == 0 || k > subs.len() {
                         return Err(PolicyError::IncorrectThresh);
                     }
@@ -789,7 +787,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
                         });
                     (all_safe, atleast_one_safe && all_non_mall)
                 }
-                Threshold(k, ref subs) => {
+                Thresh(k, ref subs) => {
                     let (safe_count, non_mall_count) = (0..subs.len()).map(acc_for_child_n).fold(
                         (0, 0),
                         |(safe_count, non_mall_count), (safe, non_mall)| {
@@ -841,7 +839,7 @@ impl<Pk: MiniscriptKey> fmt::Debug for Policy<Pk> {
                 }
                 f.write_str(")")
             }
-            Policy::Threshold(k, ref subs) => {
+            Policy::Thresh(k, ref subs) => {
                 write!(f, "thresh({}", k)?;
                 for sub in subs {
                     write!(f, ",{:?}", sub)?;
@@ -884,7 +882,7 @@ impl<Pk: MiniscriptKey> fmt::Display for Policy<Pk> {
                 }
                 f.write_str(")")
             }
-            Policy::Threshold(k, ref subs) => {
+            Policy::Thresh(k, ref subs) => {
                 write!(f, "thresh({}", k)?;
                 for sub in subs {
                     write!(f, ",{}", sub)?;
@@ -999,7 +997,7 @@ impl<Pk: FromStrKey> Policy<Pk> {
                 for arg in &top.args[1..] {
                     subs.push(Policy::from_tree(arg)?);
                 }
-                Ok(Policy::Threshold(thresh as usize, subs.into_iter().map(Arc::new).collect()))
+                Ok(Policy::Thresh(thresh as usize, subs.into_iter().map(Arc::new).collect()))
             }
             _ => Err(errstr(top.name)),
         }
@@ -1041,7 +1039,7 @@ fn with_huffman_tree<Pk: MiniscriptKey>(
     Ok(node)
 }
 
-/// Enumerates a [`Policy::Threshold(k, ..n..)`] into `n` different thresh's.
+/// Enumerates a [`Policy::Thresh(k, ..n..)`] into `n` different thresh's.
 ///
 /// ## Strategy
 ///
@@ -1063,7 +1061,7 @@ fn generate_combination<Pk: MiniscriptKey>(
             .enumerate()
             .filter_map(|(j, sub)| if j != i { Some(Arc::clone(sub)) } else { None })
             .collect();
-        ret.push((prob / policy_vec.len() as f64, Arc::new(Policy::Threshold(k, policies))));
+        ret.push((prob / policy_vec.len() as f64, Arc::new(Policy::Thresh(k, policies))));
     }
     ret
 }
@@ -1077,7 +1075,7 @@ impl<'a, Pk: MiniscriptKey> TreeLike for &'a Policy<Pk> {
             | Ripemd160(_) | Hash160(_) => Tree::Nullary,
             And(ref subs) => Tree::Nary(subs.iter().map(Arc::as_ref).collect()),
             Or(ref v) => Tree::Nary(v.iter().map(|(_, p)| p.as_ref()).collect()),
-            Threshold(_, ref subs) => Tree::Nary(subs.iter().map(Arc::as_ref).collect()),
+            Thresh(_, ref subs) => Tree::Nary(subs.iter().map(Arc::as_ref).collect()),
         }
     }
 }
@@ -1091,7 +1089,7 @@ impl<Pk: MiniscriptKey> TreeLike for Arc<Policy<Pk>> {
             | Ripemd160(_) | Hash160(_) => Tree::Nullary,
             And(ref subs) => Tree::Nary(subs.iter().map(Arc::clone).collect()),
             Or(ref v) => Tree::Nary(v.iter().map(|(_, p)| Arc::clone(p)).collect()),
-            Threshold(_, ref subs) => Tree::Nary(subs.iter().map(Arc::clone).collect()),
+            Thresh(_, ref subs) => Tree::Nary(subs.iter().map(Arc::clone).collect()),
         }
     }
 }
@@ -1137,10 +1135,7 @@ mod compiler_tests {
             .map(|sub_pol| {
                 (
                     0.25,
-                    Arc::new(Policy::Threshold(
-                        2,
-                        sub_pol.into_iter().map(|p| Arc::new(p)).collect(),
-                    )),
+                    Arc::new(Policy::Thresh(2, sub_pol.into_iter().map(|p| Arc::new(p)).collect())),
                 )
             })
             .collect::<Vec<_>>();

src/policy/mod.rs

@@ -138,15 +138,12 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Liftable<Pk> for Terminal<Pk, Ctx> {
             | Terminal::NonZero(ref sub)
             | Terminal::ZeroNotEqual(ref sub) => sub.node.lift()?,
             Terminal::AndV(ref left, ref right) | Terminal::AndB(ref left, ref right) => {
-                Semantic::Threshold(
-                    2,
-                    vec![Arc::new(left.node.lift()?), Arc::new(right.node.lift()?)],
-                )
+                Semantic::Thresh(2, vec![Arc::new(left.node.lift()?), Arc::new(right.node.lift()?)])
             }
-            Terminal::AndOr(ref a, ref b, ref c) => Semantic::Threshold(
+            Terminal::AndOr(ref a, ref b, ref c) => Semantic::Thresh(
                 1,
                 vec![
-                    Arc::new(Semantic::Threshold(
+                    Arc::new(Semantic::Thresh(
                         2,
                         vec![Arc::new(a.node.lift()?), Arc::new(b.node.lift()?)],
                     )),
@@ -156,17 +153,16 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Liftable<Pk> for Terminal<Pk, Ctx> {
             Terminal::OrB(ref left, ref right)
             | Terminal::OrD(ref left, ref right)
             | Terminal::OrC(ref left, ref right)
-            | Terminal::OrI(ref left, ref right) => Semantic::Threshold(
-                1,
-                vec![Arc::new(left.node.lift()?), Arc::new(right.node.lift()?)],
-            ),
+            | Terminal::OrI(ref left, ref right) => {
+                Semantic::Thresh(1, vec![Arc::new(left.node.lift()?), Arc::new(right.node.lift()?)])
+            }
             Terminal::Thresh(k, ref subs) => {
                 let semantic_subs: Result<Vec<Semantic<Pk>>, Error> =
                     subs.iter().map(|s| s.node.lift()).collect();
                 let semantic_subs = semantic_subs?.into_iter().map(Arc::new).collect();
-                Semantic::Threshold(k, semantic_subs)
+                Semantic::Thresh(k, semantic_subs)
             }
-            Terminal::Multi(k, ref keys) | Terminal::MultiA(k, ref keys) => Semantic::Threshold(
+            Terminal::Multi(k, ref keys) | Terminal::MultiA(k, ref keys) => Semantic::Thresh(
                 k,
                 keys.iter()
                     .map(|k| Arc::new(Semantic::Key(k.clone())))
@@ -214,19 +210,19 @@ impl<Pk: MiniscriptKey> Liftable<Pk> for Concrete<Pk> {
                 let semantic_subs: Result<Vec<Semantic<Pk>>, Error> =
                     subs.iter().map(Liftable::lift).collect();
                 let semantic_subs = semantic_subs?.into_iter().map(Arc::new).collect();
-                Semantic::Threshold(2, semantic_subs)
+                Semantic::Thresh(2, semantic_subs)
             }
             Concrete::Or(ref subs) => {
                 let semantic_subs: Result<Vec<Semantic<Pk>>, Error> =
                     subs.iter().map(|(_p, sub)| sub.lift()).collect();
                 let semantic_subs = semantic_subs?.into_iter().map(Arc::new).collect();
-                Semantic::Threshold(1, semantic_subs)
+                Semantic::Thresh(1, semantic_subs)
             }
-            Concrete::Threshold(k, ref subs) => {
+            Concrete::Thresh(k, ref subs) => {
                 let semantic_subs: Result<Vec<Semantic<Pk>>, Error> =
                     subs.iter().map(Liftable::lift).collect();
                 let semantic_subs = semantic_subs?.into_iter().map(Arc::new).collect();
-                Semantic::Threshold(k, semantic_subs)
+                Semantic::Thresh(k, semantic_subs)
             }
         }
         .normalized();
@@ -362,10 +358,10 @@ mod tests {
                 .parse()
                 .unwrap();
         assert_eq!(
-            Semantic::Threshold(
+            Semantic::Thresh(
                 1,
                 vec![
-                    Arc::new(Semantic::Threshold(
+                    Arc::new(Semantic::Thresh(
                         2,
                         vec![
                             Arc::new(Semantic::Key(key_a)),