Remove f_ prefix from translator method names

tcharding · sanket1729 · commit fca7d9d206ce · 2022-06-07T13:11:11.000-07:00
We can shorten the unusual `Translator` trait method names with no loss
of meaning.

It is not immediately obvious what the `f_` prefix means, it is a relic
of history from when we used function pointers.

Remove the `f_` prefix, shortening the translator method names to just
the thing they are translating.
diff --git a/src/descriptor/bare.rs b/src/descriptor/bare.rs
@@ -346,6 +346,6 @@ where
     where
         T: Translator<P, Q, E>,
     {
-        Ok(Pkh::new(t.f_pk(&self.pk)?))
+        Ok(Pkh::new(t.pk(&self.pk)?))
     }
 }
diff --git a/src/descriptor/mod.rs b/src/descriptor/mod.rs
@@ -527,11 +527,11 @@ impl Descriptor<DescriptorPublicKey> {
         struct Derivator(u32);
 
         impl PkTranslator<DescriptorPublicKey, DerivedDescriptorKey, ()> for Derivator {
-            fn f_pk(&mut self, pk: &DescriptorPublicKey) -> Result<DerivedDescriptorKey, ()> {
+            fn pk(&mut self, pk: &DescriptorPublicKey) -> Result<DerivedDescriptorKey, ()> {
                 Ok(pk.clone().derive(self.0))
             }
 
-            fn f_pkh(&mut self, pkh: &DescriptorPublicKey) -> Result<DerivedDescriptorKey, ()> {
+            fn pkh(&mut self, pkh: &DescriptorPublicKey) -> Result<DerivedDescriptorKey, ()> {
                 Ok(pkh.clone().derive(self.0))
             }
         }
@@ -574,14 +574,14 @@ impl Descriptor<DescriptorPublicKey> {
             PkTranslator<DerivedDescriptorKey, bitcoin::PublicKey, ConversionError>
             for Derivator<'a, C>
         {
-            fn f_pk(
+            fn pk(
                 &mut self,
                 pk: &DerivedDescriptorKey,
             ) -> Result<bitcoin::PublicKey, ConversionError> {
                 pk.derive_public_key(&self.0)
             }
 
-            fn f_pkh(
+            fn pkh(
                 &mut self,
                 pkh: &DerivedDescriptorKey,
             ) -> Result<bitcoin::hashes::hash160::Hash, ConversionError> {
@@ -633,15 +633,15 @@ impl Descriptor<DescriptorPublicKey> {
         impl<'a, C: secp256k1::Signing> Translator<String, DescriptorPublicKey, Error>
             for KeyMapWrapper<'a, C>
         {
-            fn f_pk(&mut self, pk: &String) -> Result<DescriptorPublicKey, Error> {
+            fn pk(&mut self, pk: &String) -> Result<DescriptorPublicKey, Error> {
                 parse_key(pk, &mut self.0, self.1)
             }
 
-            fn f_pkh(&mut self, pkh: &String) -> Result<DescriptorPublicKey, Error> {
+            fn pkh(&mut self, pkh: &String) -> Result<DescriptorPublicKey, Error> {
                 parse_key(pkh, &mut self.0, self.1)
             }
 
-            fn f_sha256(&mut self, sha256: &String) -> Result<sha256::Hash, Error> {
+            fn sha256(&mut self, sha256: &String) -> Result<sha256::Hash, Error> {
                 let hash =
                     sha256::Hash::from_str(sha256).map_err(|e| Error::Unexpected(e.to_string()))?;
                 Ok(hash)
@@ -661,15 +661,15 @@ impl Descriptor<DescriptorPublicKey> {
         struct KeyMapLookUp<'a>(&'a KeyMap);
 
         impl<'a> Translator<DescriptorPublicKey, String, ()> for KeyMapLookUp<'a> {
-            fn f_pk(&mut self, pk: &DescriptorPublicKey) -> Result<String, ()> {
+            fn pk(&mut self, pk: &DescriptorPublicKey) -> Result<String, ()> {
                 key_to_string(pk, self.0)
             }
 
-            fn f_pkh(&mut self, pkh: &DescriptorPublicKey) -> Result<String, ()> {
+            fn pkh(&mut self, pkh: &DescriptorPublicKey) -> Result<String, ()> {
                 key_to_string(pkh, self.0)
             }
 
-            fn f_sha256(&mut self, sha256: &sha256::Hash) -> Result<String, ()> {
+            fn sha256(&mut self, sha256: &sha256::Hash) -> Result<String, ()> {
                 Ok(sha256.to_string())
             }
         }
diff --git a/src/descriptor/segwitv0.rs b/src/descriptor/segwitv0.rs
@@ -459,6 +459,6 @@ where
     where
         T: Translator<P, Q, E>,
     {
-        Ok(Wpkh::new(t.f_pk(&self.pk)?).expect("Uncompressed keys in Wpkh"))
+        Ok(Wpkh::new(t.pk(&self.pk)?).expect("Uncompressed keys in Wpkh"))
     }
 }
diff --git a/src/descriptor/sortedmulti.rs b/src/descriptor/sortedmulti.rs
@@ -102,7 +102,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> SortedMultiVec<Pk, Ctx> {
         T: Translator<Pk, Q, FuncError>,
         Q: MiniscriptKey,
     {
-        let pks: Result<Vec<Q>, _> = self.pks.iter().map(|pk| t.f_pk(pk)).collect();
+        let pks: Result<Vec<Q>, _> = self.pks.iter().map(|pk| t.pk(pk)).collect();
         Ok(SortedMultiVec {
             k: self.k,
             pks: pks?,
diff --git a/src/descriptor/tr.rs b/src/descriptor/tr.rs
@@ -611,7 +611,7 @@ where
         T: Translator<P, Q, E>,
     {
         let translate_desc = Tr {
-            internal_key: translate.f_pk(&self.internal_key)?,
+            internal_key: translate.pk(&self.internal_key)?,
             tree: match &self.tree {
                 Some(tree) => Some(tree.translate_helper(translate)?),
                 None => None,
diff --git a/src/interpreter/inner.rs b/src/interpreter/inner.rs
@@ -378,16 +378,15 @@ impl<Ctx: ScriptContext> ToNoChecks for Miniscript<bitcoin::PublicKey, Ctx> {
         struct TranslateFullPk;
 
         impl PkTranslator<bitcoin::PublicKey, BitcoinKey, ()> for TranslateFullPk {
-            fn f_pk(&mut self, pk: &bitcoin::PublicKey) -> Result<BitcoinKey, ()> {
+            fn pk(&mut self, pk: &bitcoin::PublicKey) -> Result<BitcoinKey, ()> {
                 Ok(BitcoinKey::Fullkey(*pk))
             }
 
-            fn f_pkh(&mut self, pkh: &hash160::Hash) -> Result<TypedHash160, ()> {
+            fn pkh(&mut self, pkh: &hash160::Hash) -> Result<TypedHash160, ()> {
                 Ok(TypedHash160::FullKey(*pkh))
             }
         }
 
-        // specify the () error type as this cannot error
         self.real_translate_pk(&mut TranslateFullPk)
             .expect("Translation should succeed")
     }
@@ -399,11 +398,11 @@ impl<Ctx: ScriptContext> ToNoChecks for Miniscript<bitcoin::XOnlyPublicKey, Ctx>
         struct TranslateXOnlyPk;
 
         impl PkTranslator<bitcoin::XOnlyPublicKey, BitcoinKey, ()> for TranslateXOnlyPk {
-            fn f_pk(&mut self, pk: &bitcoin::XOnlyPublicKey) -> Result<BitcoinKey, ()> {
+            fn pk(&mut self, pk: &bitcoin::XOnlyPublicKey) -> Result<BitcoinKey, ()> {
                 Ok(BitcoinKey::XOnlyPublicKey(*pk))
             }
 
-            fn f_pkh(&mut self, pkh: &hash160::Hash) -> Result<TypedHash160, ()> {
+            fn pkh(&mut self, pkh: &hash160::Hash) -> Result<TypedHash160, ()> {
                 Ok(TypedHash160::XonlyKey(*pkh))
             }
         }
diff --git a/src/lib.rs b/src/lib.rs
@@ -397,13 +397,13 @@ where
     Q: MiniscriptKey,
 {
     /// Translates public keys P -> Q.
-    fn f_pk(&mut self, pk: &P) -> Result<Q, E>;
+    fn pk(&mut self, pk: &P) -> Result<Q, E>;
 
     /// Translates public key hashes P::Hash -> Q::Hash.
-    fn f_pkh(&mut self, pkh: &P::Hash) -> Result<Q::Hash, E>;
+    fn pkh(&mut self, pkh: &P::Hash) -> Result<Q::Hash, E>;
 
     /// Translates sha256 hashes from P::Sha256 -> Q::Sha256
-    fn f_sha256(&mut self, sha256: &P::Sha256) -> Result<Q::Sha256, E>;
+    fn sha256(&mut self, sha256: &P::Sha256) -> Result<Q::Sha256, E>;
 }
 
 /// Provides the conversion information required in [`TranslatePk`].
@@ -415,10 +415,10 @@ where
     Q: MiniscriptKey<Sha256 = P::Sha256>,
 {
     /// Provides the translation public keys P -> Q
-    fn f_pk(&mut self, pk: &P) -> Result<Q, E>;
+    fn pk(&mut self, pk: &P) -> Result<Q, E>;
 
     /// Provides the translation public keys hashes P::Hash -> Q::Hash
-    fn f_pkh(&mut self, pkh: &P::Hash) -> Result<Q::Hash, E>;
+    fn pkh(&mut self, pkh: &P::Hash) -> Result<Q::Hash, E>;
 }
 
 impl<P, Q, E, T> Translator<P, Q, E> for T
@@ -427,15 +427,15 @@ where
     P: MiniscriptKey,
     Q: MiniscriptKey<Sha256 = P::Sha256>,
 {
-    fn f_pk(&mut self, pk: &P) -> Result<Q, E> {
-        <Self as PkTranslator<P, Q, E>>::f_pk(self, pk)
+    fn pk(&mut self, pk: &P) -> Result<Q, E> {
+        <Self as PkTranslator<P, Q, E>>::pk(self, pk)
     }
 
-    fn f_pkh(&mut self, pkh: &<P as MiniscriptKey>::Hash) -> Result<<Q as MiniscriptKey>::Hash, E> {
-        <Self as PkTranslator<P, Q, E>>::f_pkh(self, pkh)
+    fn pkh(&mut self, pkh: &<P as MiniscriptKey>::Hash) -> Result<<Q as MiniscriptKey>::Hash, E> {
+        <Self as PkTranslator<P, Q, E>>::pkh(self, pkh)
     }
 
-    fn f_sha256(&mut self, sha256: &<P as MiniscriptKey>::Sha256) -> Result<<Q>::Sha256, E> {
+    fn sha256(&mut self, sha256: &<P as MiniscriptKey>::Sha256) -> Result<<Q>::Sha256, E> {
         Ok(sha256.clone())
     }
 }
diff --git a/src/miniscript/astelem.rs b/src/miniscript/astelem.rs
@@ -129,11 +129,11 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {
         T: Translator<Pk, Q, E>,
     {
         let frag: Terminal<Q, CtxQ> = match *self {
-            Terminal::PkK(ref p) => Terminal::PkK(t.f_pk(p)?),
-            Terminal::PkH(ref p) => Terminal::PkH(t.f_pkh(p)?),
+            Terminal::PkK(ref p) => Terminal::PkK(t.pk(p)?),
+            Terminal::PkH(ref p) => Terminal::PkH(t.pkh(p)?),
             Terminal::After(n) => Terminal::After(n),
             Terminal::Older(n) => Terminal::Older(n),
-            Terminal::Sha256(ref x) => Terminal::Sha256(t.f_sha256(&x)?),
+            Terminal::Sha256(ref x) => Terminal::Sha256(t.sha256(&x)?),
             Terminal::Hash256(x) => Terminal::Hash256(x),
             Terminal::Ripemd160(x) => Terminal::Ripemd160(x),
             Terminal::Hash160(x) => Terminal::Hash160(x),
@@ -185,11 +185,11 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {
                 Terminal::Thresh(k, subs?)
             }
             Terminal::Multi(k, ref keys) => {
-                let keys: Result<Vec<Q>, _> = keys.iter().map(|k| t.f_pk(k)).collect();
+                let keys: Result<Vec<Q>, _> = keys.iter().map(|k| t.pk(k)).collect();
                 Terminal::Multi(k, keys?)
             }
             Terminal::MultiA(k, ref keys) => {
-                let keys: Result<Vec<Q>, _> = keys.iter().map(|k| t.f_pk(k)).collect();
+                let keys: Result<Vec<Q>, _> = keys.iter().map(|k| t.pk(k)).collect();
                 Terminal::MultiA(k, keys?)
             }
         };
diff --git a/src/miniscript/iter.rs b/src/miniscript/iter.rs
@@ -121,7 +121,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {
     /// NB: The function analyzes only single miniscript item and not any of its descendants in AST.
     /// To obtain a list of all public keys within AST use [Miniscript::iter_pk()] function, for example
     /// `miniscript.iter_pubkeys().collect()`.
-    pub fn get_leaf_pk(&self) -> Vec<Pk> {
+    pub fn get_leapk(&self) -> Vec<Pk> {
         match self.node {
             Terminal::PkK(ref key) => vec![key.clone()],
             Terminal::Multi(_, ref keys) | Terminal::MultiA(_, ref keys) => keys.clone(),
@@ -138,7 +138,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {
     /// NB: The function analyzes only single miniscript item and not any of its descendants in AST.
     /// To obtain a list of all public key hashes within AST use [Miniscript::iter_pkh()] function,
     /// for example `miniscript.iter_pubkey_hashes().collect()`.
-    pub fn get_leaf_pkh(&self) -> Vec<Pk::Hash> {
+    pub fn get_leapkh(&self) -> Vec<Pk::Hash> {
         match self.node {
             Terminal::PkH(ref hash) => vec![hash.clone()],
             Terminal::PkK(ref key) => vec![key.to_pubkeyhash()],
@@ -156,7 +156,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {
     /// NB: The function analyzes only single miniscript item and not any of its descendants in AST.
     /// To obtain a list of all public keys or hashes within AST use [Miniscript::iter_pk_pkh()]
     /// function, for example `miniscript.iter_pubkeys_and_hashes().collect()`.
-    pub fn get_leaf_pk_pkh(&self) -> Vec<PkPkh<Pk>> {
+    pub fn get_leapk_pkh(&self) -> Vec<PkPkh<Pk>> {
         match self.node {
             Terminal::PkH(ref hash) => vec![PkPkh::HashedPubkey(hash.clone())],
             Terminal::PkK(ref key) => vec![PkPkh::PlainPubkey(key.clone())],
@@ -605,7 +605,7 @@ pub mod test {
                     return;
                 }
                 let ms = *ms.branches().first().unwrap_or(&&ms);
-                assert_eq!(ms.get_leaf_pk(), k);
+                assert_eq!(ms.get_leapk(), k);
             })
     }
 
@@ -624,7 +624,7 @@ pub mod test {
                     .collect();
                 // In our test cases we always have plain keys going first
                 all.extend(h);
-                assert_eq!(ms.get_leaf_pkh(), all);
+                assert_eq!(ms.get_leapkh(), all);
             })
     }
 
@@ -642,7 +642,7 @@ pub mod test {
                 } else {
                     k.into_iter().map(|k| PkPkh::PlainPubkey(k)).collect()
                 };
-                assert_eq!(ms.get_leaf_pk_pkh(), r);
+                assert_eq!(ms.get_leapk_pkh(), r);
             })
     }
 
diff --git a/src/policy/concrete.rs b/src/policy/concrete.rs
@@ -344,17 +344,17 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
     /// // we would use the general Translator Trait.
     /// impl Translator<String, bitcoin::PublicKey, ()> for StrPkTranslator {
     ///     // Provides the translation public keys P -> Q
-    ///     fn f_pk(&mut self, pk: &String) -> Result<bitcoin::PublicKey, ()> {
+    ///     fn pk(&mut self, pk: &String) -> Result<bitcoin::PublicKey, ()> {
     ///         self.pk_map.get(pk).copied().ok_or(()) // Dummy Err
     ///     }
     ///
     ///     // If our policy also contained other fragments, we could provide the translation here.
-    ///     fn f_pkh(&mut self, pkh: &String) -> Result<hash160::Hash, ()> {
+    ///     fn pkh(&mut self, pkh: &String) -> Result<hash160::Hash, ()> {
     ///         unreachable!("Policy does not contain any pkh fragment");
     ///     }
     ///
     ///     // If our policy also contained other fragments, we could provide the translation here.
-    ///     fn f_sha256(&mut self, sha256: &String) -> Result<sha256::Hash, ()> {
+    ///     fn sha256(&mut self, sha256: &String) -> Result<sha256::Hash, ()> {
     ///         unreachable!("Policy does not contain any sha256 fragment");
     ///     }
     /// }
@@ -385,8 +385,8 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
         match *self {
             Policy::Unsatisfiable => Ok(Policy::Unsatisfiable),
             Policy::Trivial => Ok(Policy::Trivial),
-            Policy::Key(ref pk) => t.f_pk(pk).map(Policy::Key),
-            Policy::Sha256(ref h) => t.f_sha256(h).map(Policy::Sha256),
+            Policy::Key(ref pk) => t.pk(pk).map(Policy::Key),
+            Policy::Sha256(ref h) => t.sha256(h).map(Policy::Sha256),
             Policy::Hash256(ref h) => Ok(Policy::Hash256(*h)),
             Policy::Ripemd160(ref h) => Ok(Policy::Ripemd160(*h)),
             Policy::Hash160(ref h) => Ok(Policy::Hash160(*h)),
diff --git a/src/policy/semantic.rs b/src/policy/semantic.rs
@@ -99,18 +99,18 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
     /// // If we also wanted to provide mapping of other associated types(sha256, older etc),
     /// // we would use the general Translator Trait.
     /// impl Translator<String, bitcoin::PublicKey, ()> for StrPkTranslator {
-    ///     fn f_pk(&mut self, pk: &String) -> Result<bitcoin::PublicKey, ()> {
+    ///     fn pk(&mut self, pk: &String) -> Result<bitcoin::PublicKey, ()> {
     ///         unreachable!("Policy does not contain any pk fragment");
     ///     }
     ///
     ///     // Provides the translation public keys P::Hash -> Q::Hash
     ///     // If our policy also contained other fragments, we could provide the translation here.
-    ///     fn f_pkh(&mut self, pkh: &String) -> Result<hash160::Hash, ()> {
+    ///     fn pkh(&mut self, pkh: &String) -> Result<hash160::Hash, ()> {
     ///         self.pk_map.get(pkh).copied().ok_or(()) // Dummy Err
     ///     }
     ///
     ///     // If our policy also contained other fragments, we could provide the translation here.
-    ///     fn f_sha256(&mut self, sha256: &String) -> Result<sha256::Hash, ()> {
+    ///     fn sha256(&mut self, sha256: &String) -> Result<sha256::Hash, ()> {
     ///         unreachable!("Policy does not contain any sha256 fragment");
     ///     }
     /// }
@@ -141,8 +141,8 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
         match *self {
             Policy::Unsatisfiable => Ok(Policy::Unsatisfiable),
             Policy::Trivial => Ok(Policy::Trivial),
-            Policy::KeyHash(ref pkh) => t.f_pkh(pkh).map(Policy::KeyHash),
-            Policy::Sha256(ref h) => t.f_sha256(h).map(Policy::Sha256),
+            Policy::KeyHash(ref pkh) => t.pkh(pkh).map(Policy::KeyHash),
+            Policy::Sha256(ref h) => t.sha256(h).map(Policy::Sha256),
             Policy::Hash256(ref h) => Ok(Policy::Hash256(*h)),
             Policy::Ripemd160(ref h) => Ok(Policy::Ripemd160(*h)),
             Policy::Hash160(ref h) => Ok(Policy::Hash160(*h)),
diff --git a/src/psbt/mod.rs b/src/psbt/mod.rs
@@ -940,14 +940,14 @@ struct XOnlyHashLookUp(
 impl PkTranslator<DescriptorPublicKey, bitcoin::PublicKey, descriptor::ConversionError>
     for XOnlyHashLookUp
 {
-    fn f_pk(
+    fn pk(
         &mut self,
         xpk: &DescriptorPublicKey,
     ) -> Result<bitcoin::PublicKey, descriptor::ConversionError> {
         xpk.derive_public_key(&self.1)
     }
 
-    fn f_pkh(
+    fn pkh(
         &mut self,
         xpk: &DescriptorPublicKey,
     ) -> Result<hash160::Hash, descriptor::ConversionError> {
@@ -969,7 +969,7 @@ struct KeySourceLookUp(
 impl PkTranslator<DescriptorPublicKey, bitcoin::PublicKey, descriptor::ConversionError>
     for KeySourceLookUp
 {
-    fn f_pk(
+    fn pk(
         &mut self,
         xpk: &DescriptorPublicKey,
     ) -> Result<bitcoin::PublicKey, descriptor::ConversionError> {
@@ -981,11 +981,11 @@ impl PkTranslator<DescriptorPublicKey, bitcoin::PublicKey, descriptor::Conversio
         Ok(derived)
     }
 
-    fn f_pkh(
+    fn pkh(
         &mut self,
         xpk: &DescriptorPublicKey,
     ) -> Result<hash160::Hash, descriptor::ConversionError> {
-        Ok(self.f_pk(xpk)?.to_pubkeyhash())
+        Ok(self.pk(xpk)?.to_pubkeyhash())
     }
 }
 
diff --git a/src/test_utils.rs b/src/test_utils.rs
diff --git a/tests/setup/test_util.rs b/tests/setup/test_util.rs

Original file line number	Diff line number	Diff line change
`@@ -346,6 +346,6 @@ where`
`346`	`346`	`where`
`347`	`347`	`T: Translator<P, Q, E>,`
`348`	`348`	`{`
`349`		`- Ok(Pkh::new(t.f_pk(&self.pk)?))`
	`349`	`+ Ok(Pkh::new(t.pk(&self.pk)?))`
`350`	`350`	`}`
`351`	`351`	`}`
Original file line number	Diff line number	Diff line change
`@@ -527,11 +527,11 @@ impl Descriptor<DescriptorPublicKey> {`
`527`	`527`	`struct Derivator(u32);`
`528`	`528`
`529`	`529`	`impl PkTranslator<DescriptorPublicKey, DerivedDescriptorKey, ()> for Derivator {`
`530`		`- fn f_pk(&mut self, pk: &DescriptorPublicKey) -> Result<DerivedDescriptorKey, ()> {`
	`530`	`+ fn pk(&mut self, pk: &DescriptorPublicKey) -> Result<DerivedDescriptorKey, ()> {`
`531`	`531`	`Ok(pk.clone().derive(self.0))`
`532`	`532`	`}`
`533`	`533`
`534`		`- fn f_pkh(&mut self, pkh: &DescriptorPublicKey) -> Result<DerivedDescriptorKey, ()> {`
	`534`	`+ fn pkh(&mut self, pkh: &DescriptorPublicKey) -> Result<DerivedDescriptorKey, ()> {`
`535`	`535`	`Ok(pkh.clone().derive(self.0))`
`536`	`536`	`}`
`537`	`537`	`}`
`@@ -574,14 +574,14 @@ impl Descriptor<DescriptorPublicKey> {`
`574`	`574`	`PkTranslator<DerivedDescriptorKey, bitcoin::PublicKey, ConversionError>`
`575`	`575`	`for Derivator<'a, C>`
`576`	`576`	`{`
`577`		`- fn f_pk(`
	`577`	`+ fn pk(`
`578`	`578`	`&mut self,`
`579`	`579`	`pk: &DerivedDescriptorKey,`
`580`	`580`	`) -> Result<bitcoin::PublicKey, ConversionError> {`
`581`	`581`	`pk.derive_public_key(&self.0)`
`582`	`582`	`}`
`583`	`583`
`584`		`- fn f_pkh(`
	`584`	`+ fn pkh(`
`585`	`585`	`&mut self,`
`586`	`586`	`pkh: &DerivedDescriptorKey,`
`587`	`587`	`) -> Result<bitcoin::hashes::hash160::Hash, ConversionError> {`
`@@ -633,15 +633,15 @@ impl Descriptor<DescriptorPublicKey> {`
`633`	`633`	`impl<'a, C: secp256k1::Signing> Translator<String, DescriptorPublicKey, Error>`
`634`	`634`	`for KeyMapWrapper<'a, C>`
`635`	`635`	`{`
`636`		`- fn f_pk(&mut self, pk: &String) -> Result<DescriptorPublicKey, Error> {`
	`636`	`+ fn pk(&mut self, pk: &String) -> Result<DescriptorPublicKey, Error> {`
`637`	`637`	`parse_key(pk, &mut self.0, self.1)`
`638`	`638`	`}`
`639`	`639`
`640`		`- fn f_pkh(&mut self, pkh: &String) -> Result<DescriptorPublicKey, Error> {`
	`640`	`+ fn pkh(&mut self, pkh: &String) -> Result<DescriptorPublicKey, Error> {`
`641`	`641`	`parse_key(pkh, &mut self.0, self.1)`
`642`	`642`	`}`
`643`	`643`
`644`		`- fn f_sha256(&mut self, sha256: &String) -> Result<sha256::Hash, Error> {`
	`644`	`+ fn sha256(&mut self, sha256: &String) -> Result<sha256::Hash, Error> {`
`645`	`645`	`let hash =`
`646`	`646`	`sha256::Hash::from_str(sha256).map_err(\|e\| Error::Unexpected(e.to_string()))?;`
`647`	`647`	`Ok(hash)`
`@@ -661,15 +661,15 @@ impl Descriptor<DescriptorPublicKey> {`
`661`	`661`	`struct KeyMapLookUp<'a>(&'a KeyMap);`
`662`	`662`
`663`	`663`	`impl<'a> Translator<DescriptorPublicKey, String, ()> for KeyMapLookUp<'a> {`
`664`		`- fn f_pk(&mut self, pk: &DescriptorPublicKey) -> Result<String, ()> {`
	`664`	`+ fn pk(&mut self, pk: &DescriptorPublicKey) -> Result<String, ()> {`
`665`	`665`	`key_to_string(pk, self.0)`
`666`	`666`	`}`
`667`	`667`
`668`		`- fn f_pkh(&mut self, pkh: &DescriptorPublicKey) -> Result<String, ()> {`
	`668`	`+ fn pkh(&mut self, pkh: &DescriptorPublicKey) -> Result<String, ()> {`
`669`	`669`	`key_to_string(pkh, self.0)`
`670`	`670`	`}`
`671`	`671`
`672`		`- fn f_sha256(&mut self, sha256: &sha256::Hash) -> Result<String, ()> {`
	`672`	`+ fn sha256(&mut self, sha256: &sha256::Hash) -> Result<String, ()> {`
`673`	`673`	`Ok(sha256.to_string())`
`674`	`674`	`}`
`675`	`675`	`}`
Original file line number	Diff line number	Diff line change
`@@ -459,6 +459,6 @@ where`
`459`	`459`	`where`
`460`	`460`	`T: Translator<P, Q, E>,`
`461`	`461`	`{`
`462`		`- Ok(Wpkh::new(t.f_pk(&self.pk)?).expect("Uncompressed keys in Wpkh"))`
	`462`	`+ Ok(Wpkh::new(t.pk(&self.pk)?).expect("Uncompressed keys in Wpkh"))`
`463`	`463`	`}`
`464`	`464`	`}`
Original file line number	Diff line number	Diff line change
`@@ -102,7 +102,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> SortedMultiVec<Pk, Ctx> {`
`102`	`102`	`T: Translator<Pk, Q, FuncError>,`
`103`	`103`	`Q: MiniscriptKey,`
`104`	`104`	`{`
`105`		`- let pks: Result<Vec<Q>, _> = self.pks.iter().map(\|pk\| t.f_pk(pk)).collect();`
	`105`	`+ let pks: Result<Vec<Q>, _> = self.pks.iter().map(\|pk\| t.pk(pk)).collect();`
`106`	`106`	`Ok(SortedMultiVec {`
`107`	`107`	`k: self.k,`
`108`	`108`	`pks: pks?,`
Original file line number	Diff line number	Diff line change
`@@ -611,7 +611,7 @@ where`
`611`	`611`	`T: Translator<P, Q, E>,`
`612`	`612`	`{`
`613`	`613`	`let translate_desc = Tr {`
`614`		`- internal_key: translate.f_pk(&self.internal_key)?,`
	`614`	`+ internal_key: translate.pk(&self.internal_key)?,`
`615`	`615`	`tree: match &self.tree {`
`616`	`616`	`Some(tree) => Some(tree.translate_helper(translate)?),`
`617`	`617`	`None => None,`
Original file line number	Diff line number	Diff line change
`@@ -378,16 +378,15 @@ impl<Ctx: ScriptContext> ToNoChecks for Miniscript<bitcoin::PublicKey, Ctx> {`
`378`	`378`	`struct TranslateFullPk;`
`379`	`379`
`380`	`380`	`impl PkTranslator<bitcoin::PublicKey, BitcoinKey, ()> for TranslateFullPk {`
`381`		`- fn f_pk(&mut self, pk: &bitcoin::PublicKey) -> Result<BitcoinKey, ()> {`
	`381`	`+ fn pk(&mut self, pk: &bitcoin::PublicKey) -> Result<BitcoinKey, ()> {`
`382`	`382`	`Ok(BitcoinKey::Fullkey(*pk))`
`383`	`383`	`}`
`384`	`384`
`385`		`- fn f_pkh(&mut self, pkh: &hash160::Hash) -> Result<TypedHash160, ()> {`
	`385`	`+ fn pkh(&mut self, pkh: &hash160::Hash) -> Result<TypedHash160, ()> {`
`386`	`386`	`Ok(TypedHash160::FullKey(*pkh))`
`387`	`387`	`}`
`388`	`388`	`}`
`389`	`389`
`390`		`- // specify the () error type as this cannot error`
`391`	`390`	`self.real_translate_pk(&mut TranslateFullPk)`
`392`	`391`	`.expect("Translation should succeed")`
`393`	`392`	`}`
`@@ -399,11 +398,11 @@ impl<Ctx: ScriptContext> ToNoChecks for Miniscript<bitcoin::XOnlyPublicKey, Ctx>`
`399`	`398`	`struct TranslateXOnlyPk;`
`400`	`399`
`401`	`400`	`impl PkTranslator<bitcoin::XOnlyPublicKey, BitcoinKey, ()> for TranslateXOnlyPk {`
`402`		`- fn f_pk(&mut self, pk: &bitcoin::XOnlyPublicKey) -> Result<BitcoinKey, ()> {`
	`401`	`+ fn pk(&mut self, pk: &bitcoin::XOnlyPublicKey) -> Result<BitcoinKey, ()> {`
`403`	`402`	`Ok(BitcoinKey::XOnlyPublicKey(*pk))`
`404`	`403`	`}`
`405`	`404`
`406`		`- fn f_pkh(&mut self, pkh: &hash160::Hash) -> Result<TypedHash160, ()> {`
	`405`	`+ fn pkh(&mut self, pkh: &hash160::Hash) -> Result<TypedHash160, ()> {`
`407`	`406`	`Ok(TypedHash160::XonlyKey(*pkh))`
`408`	`407`	`}`
`409`	`408`	`}`
Original file line number	Diff line number	Diff line change
`@@ -397,13 +397,13 @@ where`
`397`	`397`	`Q: MiniscriptKey,`
`398`	`398`	`{`
`399`	`399`	`/// Translates public keys P -> Q.`
`400`		`- fn f_pk(&mut self, pk: &P) -> Result<Q, E>;`
	`400`	`+ fn pk(&mut self, pk: &P) -> Result<Q, E>;`
`401`	`401`
`402`	`402`	`/// Translates public key hashes P::Hash -> Q::Hash.`
`403`		`- fn f_pkh(&mut self, pkh: &P::Hash) -> Result<Q::Hash, E>;`
	`403`	`+ fn pkh(&mut self, pkh: &P::Hash) -> Result<Q::Hash, E>;`
`404`	`404`
`405`	`405`	`/// Translates sha256 hashes from P::Sha256 -> Q::Sha256`
`406`		`- fn f_sha256(&mut self, sha256: &P::Sha256) -> Result<Q::Sha256, E>;`
	`406`	`+ fn sha256(&mut self, sha256: &P::Sha256) -> Result<Q::Sha256, E>;`
`407`	`407`	`}`
`408`	`408`
`409`	`409`	/// Provides the conversion information required in [`TranslatePk`].
`@@ -415,10 +415,10 @@ where`
`415`	`415`	`Q: MiniscriptKey<Sha256 = P::Sha256>,`
`416`	`416`	`{`
`417`	`417`	`/// Provides the translation public keys P -> Q`
`418`		`- fn f_pk(&mut self, pk: &P) -> Result<Q, E>;`
	`418`	`+ fn pk(&mut self, pk: &P) -> Result<Q, E>;`
`419`	`419`
`420`	`420`	`/// Provides the translation public keys hashes P::Hash -> Q::Hash`
`421`		`- fn f_pkh(&mut self, pkh: &P::Hash) -> Result<Q::Hash, E>;`
	`421`	`+ fn pkh(&mut self, pkh: &P::Hash) -> Result<Q::Hash, E>;`
`422`	`422`	`}`
`423`	`423`
`424`	`424`	`impl<P, Q, E, T> Translator<P, Q, E> for T`
`@@ -427,15 +427,15 @@ where`
`427`	`427`	`P: MiniscriptKey,`
`428`	`428`	`Q: MiniscriptKey<Sha256 = P::Sha256>,`
`429`	`429`	`{`
`430`		`- fn f_pk(&mut self, pk: &P) -> Result<Q, E> {`
`431`		`- <Self as PkTranslator<P, Q, E>>::f_pk(self, pk)`
	`430`	`+ fn pk(&mut self, pk: &P) -> Result<Q, E> {`
	`431`	`+ <Self as PkTranslator<P, Q, E>>::pk(self, pk)`
`432`	`432`	`}`
`433`	`433`
`434`		`- fn f_pkh(&mut self, pkh: &<P as MiniscriptKey>::Hash) -> Result<<Q as MiniscriptKey>::Hash, E> {`
`435`		`- <Self as PkTranslator<P, Q, E>>::f_pkh(self, pkh)`
	`434`	`+ fn pkh(&mut self, pkh: &<P as MiniscriptKey>::Hash) -> Result<<Q as MiniscriptKey>::Hash, E> {`
	`435`	`+ <Self as PkTranslator<P, Q, E>>::pkh(self, pkh)`
`436`	`436`	`}`
`437`	`437`
`438`		`- fn f_sha256(&mut self, sha256: &<P as MiniscriptKey>::Sha256) -> Result<<Q>::Sha256, E> {`
	`438`	`+ fn sha256(&mut self, sha256: &<P as MiniscriptKey>::Sha256) -> Result<<Q>::Sha256, E> {`
`439`	`439`	`Ok(sha256.clone())`
`440`	`440`	`}`
`441`	`441`	`}`