diff --git a/.travis.yml b/.travis.yml
index 55904342..02b75619 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -6,8 +6,7 @@ cache:
     - target
 
 rust:
-- 1.16.0
-- 1.17.0
+- 1.46.0
 - stable
 - nightly
 - beta
diff --git a/Cargo.toml b/Cargo.toml
index 4586cea5..48120590 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -4,6 +4,8 @@ description = "Rust implementation of Mustache"
 repository = "https://github.com/nickel-org/rust-mustache"
 documentation = "http://nickel-org.github.io/rust-mustache"
 version = "0.9.0"
+autotests = false
+edition = "2021"
 authors = ["erick.tryzelaar@gmail.com"]
 license = "MIT/Apache-2.0"
 
diff --git a/README.md b/README.md
index 7c3cb778..89755a32 100644
--- a/README.md
+++ b/README.md
@@ -117,7 +117,7 @@ git push --tags origin master
 [1]: http://code.google.com/p/google-ctemplate/
 [2]: http://www.ivan.fomichev.name/2008/05/erlang-template-engine-prototype.html
 [3]: https://mustache.github.io/
-[4]: http://mustache.github.com/mustache.5.html
+[4]: https://mustache.github.io/mustache.5.html
 [5]: https://docs.rs/mustache
 
 # License
diff --git a/src/builder.rs b/src/builder.rs
index 83c5ca47..ecdddc29 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -3,11 +3,11 @@ use std::string::ToString;
 use std::collections::HashMap;
 use serde::Serialize;
 
-use encoder::Error;
+use crate::encoder::Error;
 use super::{Data, to_data};
 
 /// `MapBuilder` is a helper type that construct `Data` types.
-#[derive(Default)]
+#[derive(Default, Debug)]
 pub struct MapBuilder {
     data: HashMap<String, Data>,
 }
@@ -149,6 +149,15 @@ impl MapBuilder {
         data.insert(key.to_string(), Data::Fun(RefCell::new(Box::new(f))));
         MapBuilder { data: data }
     }
+    #[inline]
+    pub fn insert_fn2<K: ToString, F>(self, key: K, f: F) -> MapBuilder
+    where
+        F: FnMut(String, &mut dyn FnMut(String) -> String) -> String + Send + 'static,
+    {
+        let MapBuilder { mut data } = self;
+        data.insert(key.to_string(), Data::Fun2(RefCell::new(Box::new(f))));
+        MapBuilder { data: data }
+    }
 
     /// Return the built `Data`.
     #[inline]
diff --git a/src/compiler.rs b/src/compiler.rs
index dcd6eae2..834cfd2a 100644
--- a/src/compiler.rs
+++ b/src/compiler.rs
@@ -3,10 +3,10 @@ use std::io::ErrorKind::NotFound;
 use std::io::Read;
 use std::fs::File;
 
-use parser::{Parser, Token};
+use crate::parser::{Parser, Token};
 use super::Context;
 
-use Result;
+use crate::Result;
 
 pub type PartialsMap = HashMap<String, Vec<Token>>;
 
@@ -51,7 +51,7 @@ impl<T: Iterator<Item = char>> Compiler<T> {
     pub fn compile(mut self) -> Result<(Vec<Token>, PartialsMap)> {
         let (tokens, partials) = {
             let parser = Parser::new(&mut self.reader, &self.otag, &self.ctag);
-            try!(parser.parse())
+            parser.parse()?
         };
 
         // Compile the partials if we haven't done so already.
@@ -66,7 +66,7 @@ impl<T: Iterator<Item = char>> Compiler<T> {
                 match File::open(&path) {
                     Ok(mut file) => {
                         let mut string = String::new();
-                        try!(file.read_to_string(&mut string));
+                        file.read_to_string(&mut string)?;
 
                         let compiler = Compiler {
                             ctx: self.ctx.clone(),
@@ -76,7 +76,7 @@ impl<T: Iterator<Item = char>> Compiler<T> {
                             ctag: "}}".to_string(),
                         };
 
-                        let (tokens, subpartials) = try!(compiler.compile());
+                        let (tokens, subpartials) = compiler.compile()?;
 
                         // Include subpartials
                         self.partials.extend(subpartials.into_iter());
@@ -101,9 +101,9 @@ impl<T: Iterator<Item = char>> Compiler<T> {
 mod tests {
     use std::path::PathBuf;
 
-    use parser::Token;
-    use compiler::Compiler;
-    use context::Context;
+    use crate::parser::Token;
+    use crate::compiler::Compiler;
+    use crate::context::Context;
 
     fn compile_str(template: &str) -> Vec<Token> {
         let ctx = Context::new(PathBuf::from("."));
diff --git a/src/context.rs b/src/context.rs
index e95aef69..906ad888 100644
--- a/src/context.rs
+++ b/src/context.rs
@@ -1,6 +1,6 @@
-use template::{self, Template};
-use compiler;
-use {Result, Error};
+use crate::template::{self, Template};
+use crate::compiler;
+use crate::{Result, Error};
 
 use std::fmt;
 use std::fs::File;
@@ -37,7 +37,7 @@ impl Context {
     /// Compiles a template from a string
     pub fn compile<IT: Iterator<Item = char>>(&self, reader: IT) -> Result<Template> {
         let compiler = compiler::Compiler::new(self.clone(), reader);
-        let (tokens, partials) = try!(compiler.compile());
+        let (tokens, partials) = compiler.compile()?;
 
         Ok(template::new(self.clone(), tokens, partials))
     }
@@ -49,8 +49,8 @@ impl Context {
         let mut path = self.template_path.join(path.as_ref());
         path.set_extension(&self.template_extension);
         let mut s = vec![];
-        let mut file = try!(File::open(&path));
-        try!(file.read_to_end(&mut s));
+        let mut file = File::open(&path)?;
+        file.read_to_end(&mut s)?;
 
         // TODO: maybe allow UTF-16 as well?
         let template = match str::from_utf8(&*s) {
@@ -62,4 +62,4 @@ impl Context {
 
         self.compile(template.chars())
     }
-}
\ No newline at end of file
+}
diff --git a/src/data.rs b/src/data.rs
index b71c79f4..d821675f 100644
--- a/src/data.rs
+++ b/src/data.rs
@@ -2,13 +2,17 @@ use std::collections::HashMap;
 use std::cell::RefCell;
 use std::fmt;
 
+// for bug!
+use log::{log, error};
+
 pub enum Data {
     Null,
     String(String),
     Bool(bool),
     Vec(Vec<Data>),
     Map(HashMap<String, Data>),
-    Fun(RefCell<Box<FnMut(String) -> String + Send>>),
+    Fun(RefCell<Box<dyn FnMut(String) -> String + Send>>),
+    Fun2(RefCell<Box<dyn FnMut(String, &mut dyn FnMut(String) -> String) -> String + Send>>),
 }
 
 impl PartialEq for Data {
@@ -20,7 +24,10 @@ impl PartialEq for Data {
             (&Data::Bool(ref v0), &Data::Bool(ref v1)) => v0 == v1,
             (&Data::Vec(ref v0), &Data::Vec(ref v1)) => v0 == v1,
             (&Data::Map(ref v0), &Data::Map(ref v1)) => v0 == v1,
-            (&Data::Fun(_), &Data::Fun(_)) => bug!("Cannot compare closures"),
+            (&Data::Fun(_), &Data::Fun(_)) => {
+                bug!("Cannot compare closures");
+                false
+            },
             (_, _) => false,
         }
     }
@@ -35,6 +42,7 @@ impl fmt::Debug for Data {
             Data::Vec(ref v) => write!(f, "VecVal({:?})", v),
             Data::Map(ref v) => write!(f, "Map({:?})", v),
             Data::Fun(_) => write!(f, "Fun(...)"),
+            Data::Fun2(_) => write!(f, "Fun2(...)"),
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/encoder.rs b/src/encoder.rs
index 947c8363..c333b340 100644
--- a/src/encoder.rs
+++ b/src/encoder.rs
@@ -1,7 +1,7 @@
 use std::collections::HashMap;
-use std::error;
+use std::error::Error as StdError;
 use std::fmt::{self, Display};
-use std::result;
+use std::result::Result as StdResult;
 
 use serde::{self, Serialize, ser};
 
@@ -31,18 +31,11 @@ impl serde::ser::Error for Error {
 }
 
 /// Alias for a `Result` with the error type `mustache::encoder::Error`.
-pub type Result<T> = result::Result<T, Error>;
+pub type Result<T> = StdResult<T, Error>;
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        use std::error::Error;
-        self.description().fmt(f)
-    }
-}
-
-impl error::Error for Error {
-    fn description(&self) -> &str {
-        match *self {
+        write!(f, "{}", match *self {
             Error::NestedOptions => "nested Option types are not supported",
             Error::UnsupportedType => "unsupported type",
             Error::MissingElements => "no elements in value",
@@ -50,10 +43,12 @@ impl error::Error for Error {
             Error::NoDataToEncode => "the encodable type created no data",
             Error::Message(ref s) => s,
             Error::__Nonexhaustive => unreachable!(),
-        }
+        })
     }
 }
 
+impl StdError for Error { }
+
 #[derive(Default)]
 pub struct Encoder;
 
@@ -328,7 +323,7 @@ impl ser::SerializeTupleVariant for SerializeTupleVariant {
     fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
         where T: Serialize
     {
-        self.vec.push(try!(to_data(&value)));
+        self.vec.push(to_data(&value)?);
         Ok(())
     }
 
@@ -362,11 +357,10 @@ impl ser::SerializeMap for SerializeMap {
     where
         T: Serialize
     {
-        let key = self.next_key.take();
-        // Panic because this indicates a bug in the program rather than an
-        // expected failure.
-        let key = key.expect("serialize_value called before serialize_key");
-        self.map.insert(key, try!(to_data(&value)));
+        // Taking the key should only fail if this gets called before
+        // serialize_key, which is a bug in the library.
+        let key = self.next_key.take().ok_or(Error::MissingElements)?;
+        self.map.insert(key, to_data(&value)?);
         Ok(())
     }
 
diff --git a/src/error.rs b/src/error.rs
index f9a11610..cc0eef10 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -1,10 +1,9 @@
-use std::error::Error as StdError;
 use std::fmt;
 use std::io::Error as StdIoError;
-use std::result;
+use std::result::Result as StdResult;
 
-use parser;
-use encoder;
+use crate::parser;
+use crate::encoder;
 
 /// Error type for any error within this library.
 ///
@@ -14,6 +13,7 @@ use encoder;
 pub enum Error {
     InvalidStr,
     NoFilename,
+    IncompleteSection,
     Io(StdIoError),
     Parser(parser::Error),
     Encoder(encoder::Error),
@@ -22,24 +22,19 @@ pub enum Error {
     __Nonexhaustive,
 }
 
-pub type Result<T> = result::Result<T, Error>;
+pub type Result<T> = StdResult<T, Error>;
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.description().fmt(f)
-    }
-}
-
-impl StdError for Error {
-    fn description(&self) -> &str {
-        match *self {
-            Error::InvalidStr => "invalid str",
-            Error::NoFilename => "a filename must be provided",
-            Error::Io(ref err) => err.description(),
-            Error::Parser(ref err) => err.description(),
-            Error::Encoder(ref err) => err.description(),
+        write!(f, "{}", match *self {
+            Error::InvalidStr => "invalid str".to_string(),
+            Error::NoFilename => "a filename must be provided".to_string(),
+            Error::IncompleteSection => "a section wasn't completed".to_string(), // Is there a better way to put this?
+            Error::Io(ref err) => err.to_string(),
+            Error::Parser(ref err) => err.to_string(),
+            Error::Encoder(ref err) => err.to_string(),
             Error::__Nonexhaustive => unreachable!(),
-        }
+        })
     }
 }
 
diff --git a/src/macros.rs b/src/macros.rs
index 50e9d6d6..5662948a 100644
--- a/src/macros.rs
+++ b/src/macros.rs
@@ -1,11 +1,9 @@
-/// This should be the only place to panic inside non-test code.
-// TODO: ensure no panics elsewhere via clippy
 macro_rules! bug {
     ($msg:expr) => ({
         bug!("{}", $msg)
     });
     ($fmt:expr, $($arg:tt)+) => ({
-        panic!(
+        error!(
             concat!("bug: ",
                     $fmt,
                     ". Please report this issue on GitHub if you find \
diff --git a/src/parser.rs b/src/parser.rs
index ecbf3d65..991316c7 100644
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -2,6 +2,9 @@ use std::error::Error as StdError;
 use std::mem;
 use std::fmt;
 
+// for bug!
+use log::{log, error};
+
 /// `Token` is a section of a compiled mustache string.
 #[derive(Clone, Debug, PartialEq)]
 pub enum Token {
@@ -32,39 +35,21 @@ pub enum Error {
     __Nonexhaustive,
 }
 
-impl StdError for Error {
-    fn description(&self) -> &'static str {
-        match *self {
-            Error::BadClosingTag(..) => "found a malformed closing tag",
-            Error::UnclosedTag => "found an unclosed tag",
-            Error::UnclosedSection(..) => "found an unclosed section",
-            Error::UnbalancedUnescapeTag => "found an unbalanced unescape tag",
-            Error::EmptyTag => "found an empty tag",
-            Error::EarlySectionClose(..) => "found a closing tag for an unopened section",
-            Error::MissingSetDelimeterClosingTag => "missing the new closing tag in set delimeter tag",
-            Error::InvalidSetDelimeterSyntax => "invalid set delimeter tag syntax",
-            Error::__Nonexhaustive => unreachable!(),
-        }
-    }
-}
+impl StdError for Error { }
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         // Provide more information where possible
         match *self {
-            Error::BadClosingTag(actual, expected) => {
-                write!(f,
-                       "character {:?} was unexpected in the closing tag, expected {:?}",
-                       actual,
-                       expected)
-            }
-            Error::UnclosedSection(ref name) => {
-                write!(f, "found an unclosed section: {:?}", name)
-            },
-            Error::EarlySectionClose(ref name) => {
-                write!(f, "found a closing tag for an unopened section {:?}", name)
-            },
-            _ => write!(f, "{}", self.description()),
+            Error::BadClosingTag(actual, expected) => write!(f, "character {:?} was unexpected in the closing tag, expected {:?}", actual, expected),
+            Error::UnclosedSection(ref name) => write!(f, "found an unclosed section: {:?}", name),
+            Error::EarlySectionClose(ref name) => write!(f, "found a closing tag for an unopened section {:?}", name),
+            Error::UnclosedTag => write!(f, "found an unclosed tag"),
+            Error::UnbalancedUnescapeTag => write!(f, "found an unbalanced unescape tag"),
+            Error::EmptyTag => write!(f, "found an empty tag",),
+            Error::MissingSetDelimeterClosingTag => write!(f, "missing the new closing tag in set delimeter tag"),
+            Error::InvalidSetDelimeterSyntax => write!(f, "invalid set delimeter tag syntax"),
+            Error::__Nonexhaustive => unreachable!(),
         }
     }
 }
@@ -213,7 +198,7 @@ impl<'a, T: Iterator<Item = char>> Parser<'a, T> {
                             self.state = ParserState::ClosingTag;
                             self.bump();
                         } else {
-                            try!(self.add_tag());
+                            self.add_tag()?;
                             self.state = ParserState::Text;
                         }
                     } else {
@@ -224,7 +209,7 @@ impl<'a, T: Iterator<Item = char>> Parser<'a, T> {
                 ParserState::ClosingTag => {
                     if ch == self.closing_tag_chars[self.tag_position] {
                         if self.tag_position == self.closing_tag_chars.len() - 1 {
-                            try!(self.add_tag());
+                            self.add_tag()?;
                             self.state = ParserState::Text;
                         } else {
                             self.state = ParserState::Tag;
@@ -362,7 +347,7 @@ impl<'a, T: Iterator<Item = char>> Parser<'a, T> {
         let mut content = String::new();
         mem::swap(&mut content, &mut self.content);
         let len = content.len();
-        try!(deny_blank(&content));
+        deny_blank(&content)?;
         let content = content;
 
         match content.as_bytes()[0] as char {
@@ -372,13 +357,13 @@ impl<'a, T: Iterator<Item = char>> Parser<'a, T> {
             }
             '&' => {
                 let name = &content[1..len];
-                let name = try!(get_name_or_implicit(name));
+                let name = get_name_or_implicit(name)?;
                 self.tokens.push(Token::UnescapedTag(name, tag));
             }
             '{' => {
                 if content.ends_with('}') {
                     let name = &content[1..len - 1];
-                    let name = try!(get_name_or_implicit(name));
+                    let name = get_name_or_implicit(name)?;
                     self.tokens.push(Token::UnescapedTag(name, tag));
                 } else {
                     return Err(Error::UnbalancedUnescapeTag)
@@ -387,19 +372,19 @@ impl<'a, T: Iterator<Item = char>> Parser<'a, T> {
             '#' => {
                 let newlined = self.eat_whitespace();
 
-                let name = try!(get_name_or_implicit(&content[1..len]));
+                let name = get_name_or_implicit(&content[1..len])?;
                 self.tokens.push(Token::IncompleteSection(name, false, tag, newlined));
             }
             '^' => {
                 let newlined = self.eat_whitespace();
 
-                let name = try!(get_name_or_implicit(&content[1..len]));
+                let name = get_name_or_implicit(&content[1..len])?;
                 self.tokens.push(Token::IncompleteSection(name, true, tag, newlined));
             }
             '/' => {
                 self.eat_whitespace();
 
-                let name = try!(get_name_or_implicit(&content[1..len]));
+                let name = get_name_or_implicit(&content[1..len])?;
                 let mut children: Vec<Token> = Vec::new();
 
                 loop {
@@ -458,14 +443,12 @@ impl<'a, T: Iterator<Item = char>> Parser<'a, T> {
                     }
                 }
             }
-            '>' => {
-                try!(self.add_partial(&content, tag));
-            }
+            '>' => self.add_partial(&content, tag)?,
             '=' => {
                 self.eat_whitespace();
 
                 if len > 2usize && content.ends_with('=') {
-                    let s = try!(deny_blank(&content[1..len - 1]));
+                    let s = deny_blank(&content[1..len - 1])?;
 
                     let pos = s.find(char::is_whitespace);
                     let pos = match pos {
@@ -492,7 +475,7 @@ impl<'a, T: Iterator<Item = char>> Parser<'a, T> {
             _ => {
                 // If the name is "." then we want the top element, which we represent with
                 // an empty name.
-                let name = try!(get_name_or_implicit(&content));
+                let name = get_name_or_implicit(&content)?;
                 self.tokens.push(Token::EscapedTag(name, tag));
             }
         };
@@ -530,7 +513,7 @@ impl<'a, T: Iterator<Item = char>> Parser<'a, T> {
         // partial. So instead, we'll cache the partials we used and look them
         // up later.
         let name = &content[1..content.len()];
-        let name = try!(deny_blank(name));
+        let name = deny_blank(name)?;
 
         self.tokens.push(Token::Partial(name.into(), indent, tag));
         self.partials.push(name.into());
@@ -560,7 +543,7 @@ impl<'a, T: Iterator<Item = char>> Parser<'a, T> {
 fn get_name_or_implicit(name: &str) -> Result<Vec<String>, Error> {
     // If the name is "." then we want the top element, which we represent with
     // an empty name.
-    let name = try!(deny_blank(&name));
+    let name = deny_blank(&name)?;
     Ok(if name == "." {
         Vec::new()
     } else {
diff --git a/src/template.rs b/src/template.rs
index 1d6825ee..263abdce 100644
--- a/src/template.rs
+++ b/src/template.rs
@@ -1,14 +1,15 @@
-use std::io::Write;
 use std::collections::HashMap;
 use std::mem;
-use std::result;
+use std::io::Write;
 use std::str;
-use serde::Serialize;
 
-use compiler::Compiler;
-use parser::Token;
+use crate::compiler::Compiler;
+// for bug!
+use log::{log, error};
+use crate::parser::Token;
+use serde::Serialize;
 
-use super::{Context, Data, Result, to_data, Error};
+use super::{Context, Data, Error, Result, to_data};
 
 /// `Template` represents a compiled mustache file.
 #[derive(Debug, Clone)]
@@ -47,17 +48,17 @@ impl Template {
     }
 
     /// Renders the template to a `String` with the `Encodable` data.
-    pub fn render_to_string<T: Serialize>(&self, data: &T) -> result::Result<String, Error> {
+    pub fn render_to_string<T: Serialize>(&self, data: &T) -> Result<String> {
         let mut output = Vec::new();
-        try!(self.render(&mut output, data));
-        Ok(String::from_utf8(output).expect("invalid utf-8 in template"))
+        self.render(&mut output, data)?;
+        String::from_utf8(output).map_err(|_| Error::InvalidStr)
     }
 
     /// Renders the template to a `String` with the `Data`.
-    pub fn render_data_to_string(&self, data: &Data) -> result::Result<String, Error> {
+    pub fn render_data_to_string(&self, data: &Data) -> Result<String> {
         let mut output = Vec::new();
-        try!(self.render_data(&mut output, data));
-        Ok(String::from_utf8(output).expect("invalid utf-8 in template"))
+        self.render_data(&mut output, data)?;
+        String::from_utf8(output).map_err(|_| Error::InvalidStr)
     }
 }
 
@@ -65,6 +66,7 @@ struct RenderContext<'a> {
     template: &'a Template,
     indent: String,
     line_start: bool,
+    inner_fn2_rendered: bool,
 }
 
 impl<'a> RenderContext<'a> {
@@ -73,12 +75,13 @@ impl<'a> RenderContext<'a> {
             template: template,
             indent: "".to_string(),
             line_start: true,
+            inner_fn2_rendered: true,
         }
     }
 
     fn render<W: Write>(&mut self, wr: &mut W, stack: &mut Vec<&Data>, tokens: &[Token]) -> Result<()> {
         for token in tokens.iter() {
-            try!(self.render_token(wr, stack, token));
+            self.render_token(wr, stack, token)?;
         }
 
         Ok(())
@@ -105,13 +108,14 @@ impl<'a> RenderContext<'a> {
                 self.render_partial(wr, stack, name, indent)
             }
             Token::IncompleteSection(..) => {
-                bug!("render_token should not encounter IncompleteSections")
+                bug!("render_token should not encounter IncompleteSections");
+                Err(Error::IncompleteSection)
             }
         }
     }
 
     fn write_tracking_newlines<W: Write>(&mut self, wr: &mut W, value: &str) -> Result<()> {
-        try!(wr.write_all(value.as_bytes()));
+        wr.write_all(value.as_bytes())?;
         self.line_start = match value.chars().last() {
             None => self.line_start, // None == ""
             Some('\n') => true,
@@ -123,7 +127,7 @@ impl<'a> RenderContext<'a> {
 
     fn write_indent<W: Write>(&mut self, wr: &mut W) -> Result<()> {
         if self.line_start {
-            try!(wr.write_all(self.indent.as_bytes()));
+            wr.write_all(self.indent.as_bytes())?;
         }
 
         Ok(())
@@ -153,10 +157,10 @@ impl<'a> RenderContext<'a> {
                 };
 
                 if line.as_bytes()[0] != b'\n' {
-                    try!(self.write_indent(wr));
+                    self.write_indent(wr)?;
                 }
 
-                try!(self.write_tracking_newlines(wr, line));
+                self.write_tracking_newlines(wr, line)?;
             }
         }
 
@@ -166,28 +170,16 @@ impl<'a> RenderContext<'a> {
     fn render_etag<W: Write>(&mut self, wr: &mut W, stack: &mut Vec<&Data>, path: &[String]) -> Result<()> {
         let mut bytes = vec![];
 
-        try!(self.render_utag(&mut bytes, stack, path));
+        self.render_utag(&mut bytes, stack, path)?;
 
         for b in bytes {
             match b {
-                b'<' => {
-                    try!(wr.write_all(b"&lt;"));
-                }
-                b'>' => {
-                    try!(wr.write_all(b"&gt;"));
-                }
-                b'&' => {
-                    try!(wr.write_all(b"&amp;"));
-                }
-                b'"' => {
-                    try!(wr.write_all(b"&quot;"));
-                }
-                b'\'' => {
-                    try!(wr.write_all(b"&#39;"));
-                }
-                _ => {
-                    try!(wr.write_all(&[b]));
-                }
+                b'<' => wr.write_all(b"&lt;")?,
+                b'>' => wr.write_all(b"&gt;")?,
+                b'&' => wr.write_all(b"&amp;")?,
+                b'"' => wr.write_all(b"&quot;")?,
+                b'\'' => wr.write_all(b"&#39;")?,
+                _ => wr.write_all(&[b])?,
             }
         }
 
@@ -198,7 +190,7 @@ impl<'a> RenderContext<'a> {
         match self.find(path, stack) {
             None => {}
             Some(value) => {
-                try!(self.write_indent(wr));
+                self.write_indent(wr)?;
 
                 // Currently this doesn't allow Option<Option<Foo>>, which
                 // would be un-nameable in the view anyway, so I'm unsure if it's
@@ -210,14 +202,14 @@ impl<'a> RenderContext<'a> {
 
                 match *value {
                     Data::String(ref value) => {
-                        try!(self.write_tracking_newlines(wr, value));
+                        self.write_tracking_newlines(wr, value)?;
                     }
 
                     // etags and utags use the default delimiter.
                     Data::Fun(ref fcell) => {
                         let f = &mut *fcell.borrow_mut();
-                        let tokens = try!(self.render_fun("", "{{", "}}", f));
-                        try!(self.render(wr, stack, &tokens));
+                        let tokens = self.render_fun("", "{{", "}}", f)?;
+                        self.render(wr, stack, &tokens)?;
                     }
 
                     ref value => {
@@ -263,33 +255,75 @@ impl<'a> RenderContext<'a> {
                     Data::Null => {
                         // do nothing
                     }
-                    Data::Bool(true) => {
-                        try!(self.render(wr, stack, children));
-                    }
-                    Data::Bool(false) => {}
+                    Data::Bool(true) => self.render(wr, stack, children)?,
+                    Data::Bool(false) => (),
                     Data::String(ref val) => {
                         if !val.is_empty() {
                             stack.push(value);
-                            try!(self.render(wr, stack, children));
+                            self.render(wr, stack, children)?;
                             stack.pop();
                         }
                     }
                     Data::Vec(ref vs) => {
                         for v in vs.iter() {
                             stack.push(v);
-                            try!(self.render(wr, stack, children));
+                            self.render(wr, stack, children)?;
                             stack.pop();
                         }
                     }
                     Data::Map(_) => {
                         stack.push(value);
-                        try!(self.render(wr, stack, children));
+                        self.render(wr, stack, children)?;
                         stack.pop();
                     }
                     Data::Fun(ref fcell) => {
                         let f = &mut *fcell.borrow_mut();
-                        let tokens = try!(self.render_fun(src, otag, ctag, f));
-                        try!(self.render(wr, stack, &tokens));
+                        let tokens = self.render_fun(src, otag, ctag, f)?;
+                        self.render(wr, stack, &tokens)?;
+                    }
+                    Data::Fun2(ref fcell) => {
+                        let f = &mut *fcell.borrow_mut();
+                        let ctx2 = self.template.ctx.clone();
+                        let partials2 = self.template.partials.clone();
+                        self.inner_fn2_rendered = false;
+
+                        let mut f0 = {
+                            |src: String| {
+                                let compiler = Compiler::new_with(
+                                    ctx2.clone(),
+                                    src.chars(),
+                                    partials2.clone(),
+                                    otag.to_string(),
+                                    ctag.to_string(),
+                                );
+                                let mut vw: Vec<u8> = vec![];
+                                match compiler.compile() {
+                                    Ok((tokens, _)) => {
+                                        /* a trick to reset the flag is to pass an empty string */
+                                        self.inner_fn2_rendered = src.len() > 0;
+                                        self.render(&mut vw, stack, &tokens).unwrap_or(())
+                                    }
+                                    _ => (),
+                                }
+                                String::from_utf8_lossy(&vw).to_string()
+                            }
+                        };
+                        let src = f(src.to_string(), &mut f0);
+                        if self.inner_fn2_rendered {
+                            self.inner_fn2_rendered = false;
+                            self.render_text(wr, &src)?;
+                        } else {
+                            let compiler = Compiler::new_with(
+                                self.template.ctx.clone(),
+                                src.chars(),
+                                self.template.partials.clone(),
+                                otag.to_string(),
+                                ctag.to_string(),
+                            );
+
+                            let (tokens, _) = compiler.compile()?;
+                            self.render(wr, stack, &tokens)?;
+                        }
                     }
                 }
             }
@@ -304,12 +338,12 @@ impl<'a> RenderContext<'a> {
                                 name: &str,
                                 indent: &str) -> Result<()> {
         match self.template.partials.get(name) {
-            None => {}
+            None => (),
             Some(ref tokens) => {
                 let mut indent = self.indent.clone() + indent;
 
                 mem::swap(&mut self.indent, &mut indent);
-                try!(self.render(wr, stack, &tokens));
+                self.render(wr, stack, &tokens)?;
                 mem::swap(&mut self.indent, &mut indent);
             }
         };
@@ -321,7 +355,7 @@ impl<'a> RenderContext<'a> {
                   src: &str,
                   otag: &str,
                   ctag: &str,
-                  f: &mut Box<FnMut(String) -> String + Send + 'static>)
+                  f: &mut Box<dyn FnMut(String) -> String + Send + 'static>)
                   -> Result<Vec<Token>> {
         let src = f(src.to_string());
 
@@ -331,7 +365,7 @@ impl<'a> RenderContext<'a> {
                                           otag.to_string(),
                                           ctag.to_string());
 
-        let (tokens, _) = try!(compiler.compile());
+        let (tokens, _) = compiler.compile()?;
         Ok(tokens)
     }
 
diff --git a/tests/template.rs b/tests/template.rs
index fad2292a..f6053a94 100644
--- a/tests/template.rs
+++ b/tests/template.rs
@@ -52,7 +52,7 @@ where T: Serialize
     let template = compile_str(template);
 
     let mut bytes = vec![];
-    try!(template.render(&mut bytes, data));
+    template.render(&mut bytes, data)?;
 
     Ok(String::from_utf8(bytes).expect("Failed to encode String"))
 }
@@ -300,8 +300,6 @@ fn render_data(template: &Template, data: &Data) -> String {
 
 #[test]
 fn test_write_failure() {
-    use std::error::Error;
-
     let mut ctx = HashMap::new();
     ctx.insert("name", "foobar");
 
@@ -317,9 +315,10 @@ fn test_write_failure() {
     ctx.insert("name", "longerthansix");
 
     let mut writer: &mut [u8] = &mut buffer;
-    assert_let!(Err(e) = template.render(&mut writer, &ctx) => {
-        assert_eq!(e.description(), "failed to write whole buffer")
-    })
+    assert!(template.render(&mut writer, &ctx).is_err());
+    //assert_let!(Err(e) = template.render(&mut writer, &ctx) => {
+    //    assert_eq!(format!("{}", e.to_string()), "failed to write whole buffer")
+    //})
 }
 
 #[test]