Order arms as in enum definition

Currently there are a bunch of places where when matching on the
`Policy` enum variants are matched in different order to the enum.
During recent work this was maintained to make diffs easier to review
however since we just modified a lot of this file lets clean it up while
we are here.

Move the match arms around so that they are ordered in the same order as
the variants are defined in the `Policy` enum.

Refactor only, no logic changes.

Author: heap-coder

src/policy/concrete.rs

@@ -579,13 +579,13 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
                 Hash160(ref h) => t.hash160(h).map(Hash160)?,
                 Older(ref n) => Older(*n),
                 After(ref n) => After(*n),
-                Threshold(ref k, ref subs) => Threshold(*k, (0..subs.len()).map(child_n).collect()),
                 And(ref subs) => And((0..subs.len()).map(child_n).collect()),
                 Or(ref subs) => Or(subs
                     .iter()
                     .enumerate()
                     .map(|(i, (prob, _))| (*prob, child_n(i)))
                     .collect()),
+                Threshold(ref k, ref subs) => Threshold(*k, (0..subs.len()).map(child_n).collect()),
             };
             translated.push(Arc::new(new_policy));
         }
@@ -605,15 +605,15 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
 
             let new_policy = match data.node.as_ref() {
                 Policy::Key(ref k) if k.clone() == *key => Some(Policy::Unsatisfiable),
-                Threshold(k, ref subs) => {
-                    Some(Threshold(*k, (0..subs.len()).map(child_n).collect()))
-                }
                 And(ref subs) => Some(And((0..subs.len()).map(child_n).collect())),
                 Or(ref subs) => Some(Or(subs
                     .iter()
                     .enumerate()
                     .map(|(i, (prob, _))| (*prob, child_n(i)))
                     .collect())),
+                Threshold(k, ref subs) => {
+                    Some(Threshold(*k, (0..subs.len()).map(child_n).collect()))
+                }
                 _ => None,
             };
             match new_policy {
@@ -724,10 +724,6 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
                     cltv_with_time: false,
                     contains_combination: false,
                 },
-                Threshold(ref k, subs) => {
-                    let iter = (0..subs.len()).map(info_for_child_n);
-                    TimelockInfo::combine_threshold(*k, iter)
-                }
                 And(ref subs) => {
                     let iter = (0..subs.len()).map(info_for_child_n);
                     TimelockInfo::combine_threshold(subs.len(), iter)
@@ -736,6 +732,10 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
                     let iter = (0..subs.len()).map(info_for_child_n);
                     TimelockInfo::combine_threshold(1, iter)
                 }
+                Threshold(ref k, subs) => {
+                    let iter = (0..subs.len()).map(info_for_child_n);
+                    TimelockInfo::combine_threshold(*k, iter)
+                }
                 _ => TimelockInfo::default(),
             };
             infos.push(info);
@@ -756,6 +756,20 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
 
         for policy in self.pre_order_iter() {
             match *policy {
+                After(n) => {
+                    if n == absolute::LockTime::ZERO.into() {
+                        return Err(PolicyError::ZeroTime);
+                    } else if n.to_u32() > 2u32.pow(31) {
+                        return Err(PolicyError::TimeTooFar);
+                    }
+                }
+                Older(n) => {
+                    if n == Sequence::ZERO {
+                        return Err(PolicyError::ZeroTime);
+                    } else if n.to_consensus_u32() > 2u32.pow(31) {
+                        return Err(PolicyError::TimeTooFar);
+                    }
+                }
                 And(ref subs) => {
                     if subs.len() != 2 {
                         return Err(PolicyError::NonBinaryArgAnd);
@@ -771,20 +785,6 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
                         return Err(PolicyError::IncorrectThresh);
                     }
                 }
-                After(n) => {
-                    if n == absolute::LockTime::ZERO.into() {
-                        return Err(PolicyError::ZeroTime);
-                    } else if n.to_u32() > 2u32.pow(31) {
-                        return Err(PolicyError::TimeTooFar);
-                    }
-                }
-                Older(n) => {
-                    if n == Sequence::ZERO {
-                        return Err(PolicyError::ZeroTime);
-                    } else if n.to_consensus_u32() > 2u32.pow(31) {
-                        return Err(PolicyError::TimeTooFar);
-                    }
-                }
                 _ => {}
             }
         }
@@ -810,18 +810,6 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
                 Sha256(_) | Hash256(_) | Ripemd160(_) | Hash160(_) | After(_) | Older(_) => {
                     (false, true)
                 }
-                Threshold(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)| {
-                            (safe_count + safe as usize, non_mall_count + non_mall as usize)
-                        },
-                    );
-                    (
-                        safe_count >= (subs.len() - k + 1),
-                        non_mall_count == subs.len() && safe_count >= (subs.len() - k),
-                    )
-                }
                 And(ref subs) => {
                     let (atleast_one_safe, all_non_mall) = (0..subs.len())
                         .map(acc_for_child_n)
@@ -836,6 +824,18 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
                         });
                     (all_safe, atleast_one_safe && all_non_mall)
                 }
+                Threshold(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)| {
+                            (safe_count + safe as usize, non_mall_count + non_mall as usize)
+                        },
+                    );
+                    (
+                        safe_count >= (subs.len() - k + 1),
+                        non_mall_count == subs.len() && safe_count >= (subs.len() - k),
+                    )
+                }
             };
             acc.push(new);
         }