add conditional formatting for Terminal

fmt functions produce big binaries.
Since Debug and Display implementation of the match are equal except the Debug
or Display representation of its child, this introduce conditional fmt
trading performance for code size. Since performance shouldn't be that
important in string conversion seems an interesting trade-off.

Author: RCasatta

src/miniscript/astelem.rs

@@ -7,7 +7,7 @@
 //! encoding in Bitcoin script, as well as a datatype. Full details
 //! are given on the Miniscript website.
 
-use core::fmt;
+use core::fmt::{self, Write};
 use core::str::FromStr;
 
 use bitcoin::hashes::{hash160, Hash};
@@ -41,6 +41,25 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {
             _ => None,
         }
     }
+
+    fn conditional_fmt(&self,  f: &mut fmt::Formatter, is_debug: bool)-> fmt::Result {
+        match *self {
+            Terminal::PkK(ref pk) => {
+                f.write_str("pk_k(")?;
+                conditional_fmt(f, pk, is_debug)?;
+                f.write_char(')')
+            }
+            _ => todo!()
+        }
+    }
+}
+
+fn conditional_fmt<D: fmt::Debug + fmt::Display>(f: &mut fmt::Formatter, data: &D, is_debug: bool) -> fmt::Result {
+    if is_debug {
+        fmt::Debug::fmt(data, f)
+    } else {
+        fmt::Display::fmt(data, f)
+    }
 }
 
 impl<Pk: MiniscriptKey, Ctx: ScriptContext> fmt::Debug for Terminal<Pk, Ctx> {
@@ -89,154 +108,14 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> fmt::Debug for Terminal<Pk, Ctx> {
             }
             write!(f, "{:?}", sub)
         } else {
-            match *self {
-                Terminal::PkK(ref pk) => write!(f, "pk_k({:?})", pk),
-                Terminal::PkH(ref pk) => write!(f, "pk_h({:?})", pk),
-                Terminal::RawPkH(ref pkh) => write!(f, "expr_raw_pk_h({:?})", pkh),
-                Terminal::After(t) => write!(f, "after({})", t),
-                Terminal::Older(t) => write!(f, "older({})", t),
-                Terminal::Sha256(ref h) => write!(f, "sha256({})", h),
-                Terminal::Hash256(ref h) => write!(f, "hash256({})", h),
-                Terminal::Ripemd160(ref h) => write!(f, "ripemd160({})", h),
-                Terminal::Hash160(ref h) => write!(f, "hash160({})", h),
-                Terminal::True => f.write_str("1"),
-                Terminal::False => f.write_str("0"),
-                Terminal::AndV(ref l, ref r) => write!(f, "and_v({:?},{:?})", l, r),
-                Terminal::AndB(ref l, ref r) => write!(f, "and_b({:?},{:?})", l, r),
-                Terminal::AndOr(ref a, ref b, ref c) => {
-                    if c.node == Terminal::False {
-                        write!(f, "and_n({:?},{:?})", a, b)
-                    } else {
-                        write!(f, "andor({:?},{:?},{:?})", a, b, c)
-                    }
-                }
-                Terminal::OrB(ref l, ref r) => write!(f, "or_b({:?},{:?})", l, r),
-                Terminal::OrD(ref l, ref r) => write!(f, "or_d({:?},{:?})", l, r),
-                Terminal::OrC(ref l, ref r) => write!(f, "or_c({:?},{:?})", l, r),
-                Terminal::OrI(ref l, ref r) => write!(f, "or_i({:?},{:?})", l, r),
-                Terminal::Thresh(k, ref subs) => {
-                    write!(f, "thresh({}", k)?;
-                    for s in subs {
-                        write!(f, ",{:?}", s)?;
-                    }
-                    f.write_str(")")
-                }
-                Terminal::Multi(k, ref keys) => {
-                    write!(f, "multi({}", k)?;
-                    for k in keys {
-                        write!(f, ",{:?}", k)?;
-                    }
-                    f.write_str(")")
-                }
-                Terminal::MultiA(k, ref keys) => {
-                    write!(f, "multi_a({}", k)?;
-                    for k in keys {
-                        write!(f, ",{}", k)?;
-                    }
-                    f.write_str(")")
-                }
-                _ => unreachable!(),
-            }
+            self.conditional_fmt(f, true)
         }
     }
 }
 
 impl<Pk: MiniscriptKey, Ctx: ScriptContext> fmt::Display for Terminal<Pk, Ctx> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Terminal::PkK(ref pk) => write!(f, "pk_k({})", pk),
-            Terminal::PkH(ref pk) => write!(f, "pk_h({})", pk),
-            Terminal::RawPkH(ref pkh) => write!(f, "expr_raw_pk_h({})", pkh),
-            Terminal::After(t) => write!(f, "after({})", t),
-            Terminal::Older(t) => write!(f, "older({})", t),
-            Terminal::Sha256(ref h) => write!(f, "sha256({})", h),
-            Terminal::Hash256(ref h) => write!(f, "hash256({})", h),
-            Terminal::Ripemd160(ref h) => write!(f, "ripemd160({})", h),
-            Terminal::Hash160(ref h) => write!(f, "hash160({})", h),
-            Terminal::True => f.write_str("1"),
-            Terminal::False => f.write_str("0"),
-            Terminal::AndV(ref l, ref r) if r.node != Terminal::True => {
-                write!(f, "and_v({},{})", l, r)
-            }
-            Terminal::AndB(ref l, ref r) => write!(f, "and_b({},{})", l, r),
-            Terminal::AndOr(ref a, ref b, ref c) => {
-                if c.node == Terminal::False {
-                    write!(f, "and_n({},{})", a, b)
-                } else {
-                    write!(f, "andor({},{},{})", a, b, c)
-                }
-            }
-            Terminal::OrB(ref l, ref r) => write!(f, "or_b({},{})", l, r),
-            Terminal::OrD(ref l, ref r) => write!(f, "or_d({},{})", l, r),
-            Terminal::OrC(ref l, ref r) => write!(f, "or_c({},{})", l, r),
-            Terminal::OrI(ref l, ref r)
-                if l.node != Terminal::False && r.node != Terminal::False =>
-            {
-                write!(f, "or_i({},{})", l, r)
-            }
-            Terminal::Thresh(k, ref subs) => {
-                write!(f, "thresh({}", k)?;
-                for s in subs {
-                    write!(f, ",{}", s)?;
-                }
-                f.write_str(")")
-            }
-            Terminal::Multi(k, ref keys) => {
-                write!(f, "multi({}", k)?;
-                for k in keys {
-                    write!(f, ",{}", k)?;
-                }
-                f.write_str(")")
-            }
-            Terminal::MultiA(k, ref keys) => {
-                write!(f, "multi_a({}", k)?;
-                for k in keys {
-                    write!(f, ",{}", k)?;
-                }
-                f.write_str(")")
-            }
-            // wrappers
-            _ => {
-                if let Some((ch, sub)) = self.wrap_char() {
-                    if ch == 'c' {
-                        if let Terminal::PkK(ref pk) = sub.node {
-                            // alias: pk(K) = c:pk_k(K)
-                            return write!(f, "pk({})", pk);
-                        } else if let Terminal::RawPkH(ref pkh) = sub.node {
-                            // `RawPkH` is currently unsupported in the descriptor spec
-                            // alias: pkh(K) = c:pk_h(K)
-                            // We temporarily display there using raw_pkh, but these descriptors
-                            // are not defined in the spec yet. These are prefixed with `expr`
-                            // in the descriptor string.
-                            // We do not support parsing these descriptors yet.
-                            return write!(f, "expr_raw_pkh({})", pkh);
-                        } else if let Terminal::PkH(ref pk) = sub.node {
-                            // alias: pkh(K) = c:pk_h(K)
-                            return write!(f, "pkh({})", pk);
-                        }
-                    }
-
-                    fmt::Write::write_char(f, ch)?;
-                    match sub.node.wrap_char() {
-                        None => {
-                            fmt::Write::write_char(f, ':')?;
-                        }
-                        // Add a ':' wrapper if there are other wrappers apart from c:pk_k()
-                        // tvc:pk_k() -> tv:pk()
-                        Some(('c', ms)) => match ms.node {
-                            Terminal::PkK(_) | Terminal::PkH(_) | Terminal::RawPkH(_) => {
-                                fmt::Write::write_char(f, ':')?
-                            }
-                            _ => {}
-                        },
-                        _ => {}
-                    };
-                    write!(f, "{}", sub)
-                } else {
-                    unreachable!();
-                }
-            }
-        }
+        self.conditional_fmt(f, false)
     }
 }