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

@@ -182,45 +182,15 @@ 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) {
-            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(match type_map.corr.input {
-                types::Input::Zero => "z",
-                types::Input::One => "o",
-                types::Input::OneNonZero => "on",
-                types::Input::Any => "",
-                types::Input::AnyNonZero => "n",
-            })?;
-            if type_map.corr.dissatisfiable {
-                fmt::Write::write_char(f, 'd')?;
-            }
-            if type_map.corr.unit {
-                fmt::Write::write_char(f, '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')?;
-            }
-            if type_map.mall.non_malleable {
-                fmt::Write::write_char(f, 'm')?;
-            }
+            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 {
@@ -229,6 +199,41 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> fmt::Debug for Terminal<Pk, Ctx> {
     }
 }
 
+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",
+    })?;
+    f.write_str("/")?;
+    f.write_str(match type_map.corr.input {
+        types::Input::Zero => "z",
+        types::Input::One => "o",
+        types::Input::OneNonZero => "on",
+        types::Input::Any => "",
+        types::Input::AnyNonZero => "n",
+    })?;
+    if type_map.corr.dissatisfiable {
+        f.write_str("d")?;
+    }
+    if type_map.corr.unit {
+        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 {
+        f.write_str("s")?;
+    }
+    if type_map.mall.non_malleable {
+        f.write_str("m")?;
+    }
+    Ok(())
+}
+
 impl<Pk: MiniscriptKey, Ctx: ScriptContext> fmt::Display for Terminal<Pk, Ctx> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { self.conditional_fmt(f, false) }
 }