Put the two Miniscript impl blocks together

There are now two impl blocks for `Miniscript` with different generics,
put one directly under the other.

To match the diff this should be said "move trait impls below the second
Miniscript impl block".

Author: tcharding

src/miniscript/mod.rs

@@ -251,59 +251,6 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {
     }
 }
 
-/// `PartialOrd` of `Miniscript` must depend only on node and not the type information.
-///
-/// The type information and extra_properties can be deterministically determined by the AST.
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> PartialOrd for Miniscript<Pk, Ctx> {
-    fn partial_cmp(&self, other: &Miniscript<Pk, Ctx>) -> Option<cmp::Ordering> {
-        Some(self.node.cmp(&other.node))
-    }
-}
-
-/// `Ord` of `Miniscript` must depend only on node and not the type information.
-///
-/// The type information and extra_properties can be deterministically determined by the AST.
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> Ord for Miniscript<Pk, Ctx> {
-    fn cmp(&self, other: &Miniscript<Pk, Ctx>) -> cmp::Ordering {
-        self.node.cmp(&other.node)
-    }
-}
-
-/// `PartialEq` of `Miniscript` must depend only on node and not the type information.
-///
-/// The type information and extra_properties can be deterministically determined by the AST.
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> PartialEq for Miniscript<Pk, Ctx> {
-    fn eq(&self, other: &Miniscript<Pk, Ctx>) -> bool {
-        self.node.eq(&other.node)
-    }
-}
-
-/// `Eq` of `Miniscript` must depend only on node and not the type information.
-///
-/// The type information and extra_properties can be deterministically determined by the AST.
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> Eq for Miniscript<Pk, Ctx> {}
-
-/// `Hash` of `Miniscript` must depend only on node and not the type information.
-///
-/// The type information and extra_properties can be deterministically determined by the AST.
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> hash::Hash for Miniscript<Pk, Ctx> {
-    fn hash<H: hash::Hasher>(&self, state: &mut H) {
-        self.node.hash(state);
-    }
-}
-
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> fmt::Debug for Miniscript<Pk, Ctx> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{:?}", self.node)
-    }
-}
-
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> fmt::Display for Miniscript<Pk, Ctx> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.node)
-    }
-}
-
 impl<Ctx: ScriptContext> Miniscript<Ctx::Key, Ctx> {
     /// Attempt to parse an insane(scripts don't clear sanity checks)
     /// script into a Miniscript representation.
@@ -383,6 +330,59 @@ impl<Ctx: ScriptContext> Miniscript<Ctx::Key, Ctx> {
     }
 }
 
+/// `PartialOrd` of `Miniscript` must depend only on node and not the type information.
+///
+/// The type information and extra_properties can be deterministically determined by the AST.
+impl<Pk: MiniscriptKey, Ctx: ScriptContext> PartialOrd for Miniscript<Pk, Ctx> {
+    fn partial_cmp(&self, other: &Miniscript<Pk, Ctx>) -> Option<cmp::Ordering> {
+        Some(self.node.cmp(&other.node))
+    }
+}
+
+/// `Ord` of `Miniscript` must depend only on node and not the type information.
+///
+/// The type information and extra_properties can be deterministically determined by the AST.
+impl<Pk: MiniscriptKey, Ctx: ScriptContext> Ord for Miniscript<Pk, Ctx> {
+    fn cmp(&self, other: &Miniscript<Pk, Ctx>) -> cmp::Ordering {
+        self.node.cmp(&other.node)
+    }
+}
+
+/// `PartialEq` of `Miniscript` must depend only on node and not the type information.
+///
+/// The type information and extra_properties can be deterministically determined by the AST.
+impl<Pk: MiniscriptKey, Ctx: ScriptContext> PartialEq for Miniscript<Pk, Ctx> {
+    fn eq(&self, other: &Miniscript<Pk, Ctx>) -> bool {
+        self.node.eq(&other.node)
+    }
+}
+
+/// `Eq` of `Miniscript` must depend only on node and not the type information.
+///
+/// The type information and extra_properties can be deterministically determined by the AST.
+impl<Pk: MiniscriptKey, Ctx: ScriptContext> Eq for Miniscript<Pk, Ctx> {}
+
+/// `Hash` of `Miniscript` must depend only on node and not the type information.
+///
+/// The type information and extra_properties can be deterministically determined by the AST.
+impl<Pk: MiniscriptKey, Ctx: ScriptContext> hash::Hash for Miniscript<Pk, Ctx> {
+    fn hash<H: hash::Hasher>(&self, state: &mut H) {
+        self.node.hash(state);
+    }
+}
+
+impl<Pk: MiniscriptKey, Ctx: ScriptContext> fmt::Debug for Miniscript<Pk, Ctx> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{:?}", self.node)
+    }
+}
+
+impl<Pk: MiniscriptKey, Ctx: ScriptContext> fmt::Display for Miniscript<Pk, Ctx> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.node)
+    }
+}
+
 impl<Pk: MiniscriptKey, Ctx: ScriptContext> ForEachKey<Pk> for Miniscript<Pk, Ctx> {
     fn for_each_key<'a, F: FnMut(&'a Pk) -> bool>(&'a self, mut pred: F) -> bool {
         for ms in self.pre_order_iter() {