Refactor ForEach to contain only Pk.

This change allows us to allow to refactor `Terminal::PkH(Pk::Hash)` to `Terminal::PkH(Pk)`.

Author: heap-coder

src/descriptor/bare.rs

@@ -331,7 +331,7 @@ impl<Pk: MiniscriptKey> ForEachKey<Pk> for Pkh<Pk> {
         Pk: 'a,
         Pk::Hash: 'a,
     {
-        pred(ForEach::Key(&self.pk))
+        pred(ForEach(&self.pk))
     }
 }
 

src/descriptor/segwitv0.rs

@@ -444,7 +444,7 @@ impl<Pk: MiniscriptKey> ForEachKey<Pk> for Wpkh<Pk> {
         Pk: 'a,
         Pk::Hash: 'a,
     {
-        pred(ForEach::Key(&self.pk))
+        pred(ForEach(&self.pk))
     }
 }
 

src/descriptor/sortedmulti.rs

@@ -117,7 +117,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> ForEachKey<Pk> for SortedMultiVec<Pk
         Pk: 'a,
         Pk::Hash: 'a,
     {
-        self.pks.iter().all(|key| pred(ForEach::Key(key)))
+        self.pks.iter().all(|key| pred(ForEach(key)))
     }
 }
 

src/descriptor/tr.rs

@@ -587,7 +587,7 @@ impl<Pk: MiniscriptKey> ForEachKey<Pk> for Tr<Pk> {
         let script_keys_res = self
             .iter_scripts()
             .all(|(_d, ms)| ms.for_each_key(&mut pred));
-        script_keys_res && pred(ForEach::Key(&self.internal_key))
+        script_keys_res && pred(ForEach(&self.internal_key))
     }
 }
 
@@ -702,9 +702,6 @@ mod tests {
         let desc = desc.replace(&[' ', '\n'][..], "");
         let tr = Tr::<String>::from_str(&desc).unwrap();
         // Note the last ac12 only has ac and fails the predicate
-        assert!(!tr.for_each_key(|k| match k {
-            ForEach::Key(k) => k.starts_with("acc"),
-            ForEach::Hash(_h) => unreachable!(),
-        }));
+        assert!(!tr.for_each_key(|k| k.0.starts_with("acc")));
     }
 }

src/lib.rs

@@ -458,21 +458,13 @@ where
         T: Translator<P, Q, E>;
 }
 
-/// Either a key or a keyhash
-pub enum ForEach<'a, Pk: MiniscriptKey> {
-    /// A key
-    Key(&'a Pk),
-    /// A keyhash
-    Hash(&'a Pk::Hash),
-}
+/// Either a key or keyhash, but both contain Pk
+pub struct ForEach<'a, Pk: MiniscriptKey>(&'a Pk);
 
 impl<'a, Pk: MiniscriptKey<Hash = Pk>> ForEach<'a, Pk> {
     /// Convenience method to avoid distinguishing between keys and hashes when these are the same type
     pub fn as_key(&self) -> &'a Pk {
-        match *self {
-            ForEach::Key(ref_key) => ref_key,
-            ForEach::Hash(ref_key) => ref_key,
-        }
+        self.0
     }
 }
 

src/miniscript/astelem.rs

@@ -85,8 +85,8 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {
         Pk::Hash: 'a,
     {
         match *self {
-            Terminal::PkK(ref p) => pred(ForEach::Key(p)),
-            Terminal::PkH(ref p) => pred(ForEach::Hash(p)),
+            Terminal::PkK(ref p) => pred(ForEach(p)),
+            Terminal::PkH(ref _p) => todo!("KeyHash should contain Pk"),
             Terminal::After(..)
             | Terminal::Older(..)
             | Terminal::Sha256(..)
@@ -117,7 +117,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {
             }
             Terminal::Thresh(_, ref subs) => subs.iter().all(|sub| sub.real_for_each_key(pred)),
             Terminal::Multi(_, ref keys) | Terminal::MultiA(_, ref keys) => {
-                keys.iter().all(|key| pred(ForEach::Key(key)))
+                keys.iter().all(|key| pred(ForEach(key)))
             }
         }
     }

src/policy/concrete.rs

@@ -304,7 +304,7 @@ impl<Pk: MiniscriptKey> ForEachKey<Pk> for Policy<Pk> {
     {
         match *self {
             Policy::Unsatisfiable | Policy::Trivial => true,
-            Policy::Key(ref pk) => pred(ForEach::Key(pk)),
+            Policy::Key(ref pk) => pred(ForEach(pk)),
             Policy::Sha256(..)
             | Policy::Hash256(..)
             | Policy::Ripemd160(..)

src/policy/semantic.rs

@@ -63,7 +63,7 @@ impl<Pk: MiniscriptKey> ForEachKey<Pk> for Policy<Pk> {
     {
         match *self {
             Policy::Unsatisfiable | Policy::Trivial => true,
-            Policy::KeyHash(ref pkh) => pred(ForEach::Hash(pkh)),
+            Policy::KeyHash(ref _pkh) => todo!("Semantic Policy KeyHash must store Pk"),
             Policy::Sha256(..)
             | Policy::Hash256(..)
             | Policy::Ripemd160(..)