Shorten translatefpk identifier

Recently we refactored the translate pk traits, in doing so the
identifier fpk and fpkh were favoured over translatefpk, and
translatefpkh respectively. I missed a bunch of places.

Be uniform across the code base and use the identifiers fpk and fpkh.

This patch is the result of applying s/translatefpk/fpk/g to all source
files.

Refactor only, no logic changes.

Author: tcharding

src/descriptor/sortedmulti.rs

@@ -90,18 +90,18 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> SortedMultiVec<Pk, Ctx> {
         pks.map(|pks| SortedMultiVec::new(k as usize, pks))?
     }
 
-    /// This will panic if translatefpk returns an uncompressed key when
+    /// This will panic if fpk returns an uncompressed key when
     /// converting to a Segwit descriptor. To prevent this panic, ensure
-    /// translatefpk returns an error in this case instead.
+    /// fpk returns an error in this case instead.
     pub fn translate_pk<FPk, Q, FuncError>(
         &self,
-        translatefpk: &mut FPk,
+        fpk: &mut FPk,
     ) -> Result<SortedMultiVec<Q, Ctx>, FuncError>
     where
         FPk: FnMut(&Pk) -> Result<Q, FuncError>,
         Q: MiniscriptKey,
     {
-        let pks: Result<Vec<Q>, _> = self.pks.iter().map(&mut *translatefpk).collect();
+        let pks: Result<Vec<Q>, _> = self.pks.iter().map(&mut *fpk).collect();
         Ok(SortedMultiVec {
             k: self.k,
             pks: pks?,

src/descriptor/tr.rs

@@ -129,8 +129,8 @@ impl<Pk: MiniscriptKey> TapTree<Pk> {
     // Helper function to translate keys
     fn translate_helper<FPk, FPkh, Q, Error>(
         &self,
-        translatefpk: &mut FPk,
-        translatefpkh: &mut FPkh,
+        fpk: &mut FPk,
+        fpkh: &mut FPkh,
     ) -> Result<TapTree<Q>, Error>
     where
         FPk: FnMut(&Pk) -> Result<Q, Error>,
@@ -139,12 +139,10 @@ impl<Pk: MiniscriptKey> TapTree<Pk> {
     {
         let frag = match self {
             TapTree::Tree(l, r) => TapTree::Tree(
-                Arc::new(l.translate_helper(translatefpk, translatefpkh)?),
-                Arc::new(r.translate_helper(translatefpk, translatefpkh)?),
+                Arc::new(l.translate_helper(fpk, fpkh)?),
+                Arc::new(r.translate_helper(fpk, fpkh)?),
             ),
-            TapTree::Leaf(ms) => {
-                TapTree::Leaf(Arc::new(ms.translate_pk(translatefpk, translatefpkh)?))
-            }
+            TapTree::Leaf(ms) => TapTree::Leaf(Arc::new(ms.translate_pk(fpk, fpkh)?)),
         };
         Ok(frag)
     }

src/policy/concrete.rs

@@ -185,44 +185,42 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
     /// let expected_policy = Policy::from_str(&format!("and(pk({}),pk({}))", alice_key, bob_key)).unwrap();
     /// assert_eq!(real_policy, expected_policy);
     /// ```
-    pub fn translate_pk<Fpk, Q, E>(&self, mut translatefpk: Fpk) -> Result<Policy<Q>, E>
+    pub fn translate_pk<Fpk, Q, E>(&self, mut fpk: Fpk) -> Result<Policy<Q>, E>
     where
         Fpk: FnMut(&Pk) -> Result<Q, E>,
         Q: MiniscriptKey,
     {
-        self._translate_pk(&mut translatefpk)
+        self._translate_pk(&mut fpk)
     }
 
-    fn _translate_pk<Fpk, Q, E>(&self, translatefpk: &mut Fpk) -> Result<Policy<Q>, E>
+    fn _translate_pk<Fpk, Q, E>(&self, fpk: &mut Fpk) -> Result<Policy<Q>, E>
     where
         Fpk: FnMut(&Pk) -> Result<Q, E>,
         Q: MiniscriptKey,
     {
         match *self {
             Policy::Unsatisfiable => Ok(Policy::Unsatisfiable),
             Policy::Trivial => Ok(Policy::Trivial),
-            Policy::Key(ref pk) => translatefpk(pk).map(Policy::Key),
+            Policy::Key(ref pk) => fpk(pk).map(Policy::Key),
             Policy::Sha256(ref h) => Ok(Policy::Sha256(h.clone())),
             Policy::Hash256(ref h) => Ok(Policy::Hash256(h.clone())),
             Policy::Ripemd160(ref h) => Ok(Policy::Ripemd160(h.clone())),
             Policy::Hash160(ref h) => Ok(Policy::Hash160(h.clone())),
             Policy::After(n) => Ok(Policy::After(n)),
             Policy::Older(n) => Ok(Policy::Older(n)),
             Policy::Threshold(k, ref subs) => {
-                let new_subs: Result<Vec<Policy<Q>>, _> = subs
-                    .iter()
-                    .map(|sub| sub._translate_pk(translatefpk))
-                    .collect();
+                let new_subs: Result<Vec<Policy<Q>>, _> =
+                    subs.iter().map(|sub| sub._translate_pk(fpk)).collect();
                 new_subs.map(|ok| Policy::Threshold(k, ok))
             }
             Policy::And(ref subs) => Ok(Policy::And(
                 subs.iter()
-                    .map(|sub| sub._translate_pk(translatefpk))
+                    .map(|sub| sub._translate_pk(fpk))
                     .collect::<Result<Vec<Policy<Q>>, E>>()?,
             )),
             Policy::Or(ref subs) => Ok(Policy::Or(
                 subs.iter()
-                    .map(|&(ref prob, ref sub)| Ok((*prob, sub._translate_pk(translatefpk)?)))
+                    .map(|&(ref prob, ref sub)| Ok((*prob, sub._translate_pk(fpk)?)))
                     .collect::<Result<Vec<(usize, Policy<Q>)>, E>>()?,
             )),
         }

src/policy/semantic.rs

@@ -99,34 +99,32 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
     /// let expected_policy = Policy::<PublicKey>::from_str(&format!("and(pkh({}),pkh({}))", alice_pkh, bob_pkh)).unwrap();
     /// assert_eq!(real_policy, expected_policy);
     /// ```
-    pub fn translate_pkh<Fpkh, Q, E>(&self, mut translatefpkh: Fpkh) -> Result<Policy<Q>, E>
+    pub fn translate_pkh<Fpkh, Q, E>(&self, mut fpkh: Fpkh) -> Result<Policy<Q>, E>
     where
         Fpkh: FnMut(&Pk::Hash) -> Result<Q::Hash, E>,
         Q: MiniscriptKey,
     {
-        self._translate_pkh(&mut translatefpkh)
+        self._translate_pkh(&mut fpkh)
     }
 
-    fn _translate_pkh<Fpkh, Q, E>(&self, translatefpkh: &mut Fpkh) -> Result<Policy<Q>, E>
+    fn _translate_pkh<Fpkh, Q, E>(&self, fpkh: &mut Fpkh) -> Result<Policy<Q>, E>
     where
         Fpkh: FnMut(&Pk::Hash) -> Result<Q::Hash, E>,
         Q: MiniscriptKey,
     {
         match *self {
             Policy::Unsatisfiable => Ok(Policy::Unsatisfiable),
             Policy::Trivial => Ok(Policy::Trivial),
-            Policy::KeyHash(ref pkh) => translatefpkh(pkh).map(Policy::KeyHash),
+            Policy::KeyHash(ref pkh) => fpkh(pkh).map(Policy::KeyHash),
             Policy::Sha256(ref h) => Ok(Policy::Sha256(h.clone())),
             Policy::Hash256(ref h) => Ok(Policy::Hash256(h.clone())),
             Policy::Ripemd160(ref h) => Ok(Policy::Ripemd160(h.clone())),
             Policy::Hash160(ref h) => Ok(Policy::Hash160(h.clone())),
             Policy::After(n) => Ok(Policy::After(n)),
             Policy::Older(n) => Ok(Policy::Older(n)),
             Policy::Threshold(k, ref subs) => {
-                let new_subs: Result<Vec<Policy<Q>>, _> = subs
-                    .iter()
-                    .map(|sub| sub._translate_pkh(translatefpkh))
-                    .collect();
+                let new_subs: Result<Vec<Policy<Q>>, _> =
+                    subs.iter().map(|sub| sub._translate_pkh(fpkh)).collect();
                 new_subs.map(|ok| Policy::Threshold(k, ok))
             }
         }