apply immediate dispatch in generic fn

by refactoring out the function when the type is known, we avoid the duplication
in the generic function.

In the process write_char is replaced with write_str when the string is
static because by looking at the impl it saves a utf8 str conversion from the
char.

Author: RCasatta

src/miniscript/astelem.rs

@@ -180,15 +180,15 @@ fn conditional_fmt<D: fmt::Debug + fmt::Display>(
 
 impl<Pk: MiniscriptKey, Ctx: ScriptContext> fmt::Debug for Terminal<Pk, Ctx> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str("[")?;
-        if let Ok(type_map) = types::Type::type_check(self) {
+
+        fn fmt_type_map(f: &mut fmt::Formatter<'_>, type_map: types::Type) -> fmt::Result {
             f.write_str(match type_map.corr.base {
                 types::Base::B => "B",
                 types::Base::K => "K",
                 types::Base::V => "V",
                 types::Base::W => "W",
             })?;
-            fmt::Write::write_char(f, '/')?;
+            f.write_str("/")?;
             f.write_str(match type_map.corr.input {
                 types::Input::Zero => "z",
                 types::Input::One => "o",
@@ -197,30 +197,36 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> fmt::Debug for Terminal<Pk, Ctx> {
                 types::Input::AnyNonZero => "n",
             })?;
             if type_map.corr.dissatisfiable {
-                fmt::Write::write_char(f, 'd')?;
+                f.write_str("d")?;
             }
             if type_map.corr.unit {
-                fmt::Write::write_char(f, 'u')?;
+                f.write_str("u")?;
             }
             f.write_str(match type_map.mall.dissat {
                 types::Dissat::None => "f",
                 types::Dissat::Unique => "e",
                 types::Dissat::Unknown => "",
             })?;
             if type_map.mall.safe {
-                fmt::Write::write_char(f, 's')?;
+                f.write_str("s")?;
             }
             if type_map.mall.non_malleable {
-                fmt::Write::write_char(f, 'm')?;
+                f.write_str("m")?;
             }
+            Ok(())
+        }
+
+        f.write_str("[")?;
+        if let Ok(type_map) = types::Type::type_check(self) {
+            fmt_type_map(f, type_map)?;
         } else {
             f.write_str("TYPECHECK FAILED")?;
         }
         f.write_str("]")?;
         if let Some((ch, sub)) = self.wrap_char() {
             fmt::Write::write_char(f, ch)?;
             if sub.node.wrap_char().is_none() {
-                fmt::Write::write_char(f, ':')?;
+                f.write_str(":")?;
             }
             write!(f, "{:?}", sub)
         } else {