Expose the fact that templates implement Display

This is a quite useful feature, because you can use templates in
format!(), format_args!(), etc.

askama_shared/src/lib.rs

@@ -29,7 +29,7 @@ mod parser;
 /// Main `Template` trait; implementations are generally derived
 ///
 /// If you need an object-safe template, use [`DynTemplate`].
-pub trait Template {
+pub trait Template: fmt::Display {
     /// Helper method which allocates a new `String` and renders into it
     fn render(&self) -> Result<String> {
         let mut buf = String::with_capacity(Self::SIZE_HINT);
@@ -92,6 +92,12 @@ impl<T: Template> DynTemplate for T {
     }
 }
 
+impl fmt::Display for dyn DynTemplate {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.dyn_render_into(f).map_err(|_| ::std::fmt::Error {})
+    }
+}
+
 #[derive(Debug)]
 struct Config<'a> {
     dirs: Vec<PathBuf>,
@@ -603,10 +609,23 @@ mod tests {
             const MIME_TYPE: &'static str = "text/plain; charset=utf-8";
         }
 
+        impl fmt::Display for Test {
+            #[inline]
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                self.render_into(f).map_err(|_| fmt::Error {})
+            }
+        }
+
         fn render(t: &dyn DynTemplate) -> String {
             t.dyn_render().unwrap()
         }
 
-        assert_eq!(render(&Test), "test");
+        let test = &Test as &dyn DynTemplate;
+
+        assert_eq!(render(test), "test");
+
+        assert_eq!(test.to_string(), "test");
+
+        assert_eq!(format!("{}", test), "test");
     }
 }