Migrate to non-macro combinators

1 files changed, 709 insertions, 541 deletions

diff --git a/askama_derive/src/parser.rs b/askama_derive/src/parser.rs
index 1045090..d22ac5a 100644
--- a/askama_derive/src/parser.rs
+++ b/askama_derive/src/parser.rs
@@ -1,7 +1,11 @@
-// rustfmt doesn't do a very good job on nom parser invocations.
-#![cfg_attr(rustfmt, rustfmt_skip)]
-
-use nom;
+use nom::branch::alt;
+use nom::bytes::complete::{is_not, tag, take_until};
+use nom::character::complete::{char, digit1};
+use nom::combinator::{complete, map, opt};
+use nom::error::ParseError;
+use nom::multi::{many0, many1, separated_list, separated_nonempty_list};
+use nom::sequence::{delimited, pair, tuple};
+use nom::{self, Compare, IResult, InputTake};
 use std::str;
 
 use askama_shared::Syntax;
@@ -96,11 +100,30 @@ impl<'a> Default for MatchParameters<'a> {
     }
 }
 
+fn ws<F, I, O, E>(inner: F) -> impl Fn(I) -> IResult<I, O, E>
+where
+    F: Fn(I) -> IResult<I, O, E>,
+    I: InputTake + Clone + PartialEq + for<'a> Compare<&'a [u8; 1]>,
+    E: ParseError<I>,
+{
+    move |i: I| {
+        let i = alt::<_, _, (), _>((tag(b" "), tag(b"\t")))(i.clone())
+            .map(|(i, _)| i)
+            .unwrap_or(i);
+        let (i, res) = inner(i)?;
+        let i = alt::<_, _, (), _>((tag(b" "), tag(b"\t")))(i.clone())
+            .map(|(i, _)| i)
+            .unwrap_or(i);
+        Ok((i, res))
+    }
+}
+
 fn split_ws_parts(s: &[u8]) -> Node {
     if s.is_empty() {
-        let rs = str::from_utf8(&s).unwrap();
+        let rs = str::from_utf8(s).unwrap();
         return Node::Lit(rs, rs, rs);
     }
+
     let is_ws = |c: &u8| *c != b' ' && *c != b'\t' && *c != b'\r' && *c != b'\n';
     let start = s.iter().position(&is_ws);
     let res = if start.is_none() {
@@ -115,6 +138,7 @@ fn split_ws_parts(s: &[u8]) -> Node {
             (&s[..start], &s[start..=end], &s[end + 1..])
         }
     };
+
     Node::Lit(
         str::from_utf8(res.0).unwrap(),
         str::from_utf8(res.1).unwrap(),
@@ -197,106 +221,103 @@ fn non_ascii(chr: u8) -> bool {
     chr >= 0x80 && chr <= 0xFD
 }
 
-named!(expr_bool_lit<&[u8], Expr>, map!(
-    alt!(tag!("true") | tag!("false")),
-    |s| Expr::BoolLit(str::from_utf8(&s).unwrap())
-));
+fn expr_bool_lit(i: &[u8]) -> IResult<&[u8], Expr> {
+    map(alt((tag("false"), tag("true"))), |s| {
+        Expr::BoolLit(str::from_utf8(s).unwrap())
+    })(i)
+}
 
-named!(num_lit<&[u8], &str>, map!(nom::character::complete::digit1,
-    |s| str::from_utf8(s).unwrap()
-));
+fn num_lit(i: &[u8]) -> IResult<&[u8], &str> {
+    map(digit1, |s| str::from_utf8(s).unwrap())(i)
+}
 
-named!(expr_num_lit<&[u8], Expr>, map!(num_lit,
-    |s| Expr::NumLit(s)
-));
+fn expr_num_lit(i: &[u8]) -> IResult<&[u8], Expr> {
+    map(num_lit, |s| Expr::NumLit(s))(i)
+}
 
-named!(expr_array_lit<&[u8], Expr>,
-    delimited!(
-        ws!(tag!("[")),
-        map!(separated_nonempty_list!(
-            ws!(tag!(",")),
-            expr_any
-        ), |arr| Expr::Array(arr)),
-        ws!(tag!("]"))
-    )
-);
+fn expr_array_lit(i: &[u8]) -> IResult<&[u8], Expr> {
+    delimited(
+        ws(tag("[")),
+        map(separated_nonempty_list(ws(tag(",")), expr_any), |arr| {
+            Expr::Array(arr)
+        }),
+        ws(tag("]")),
+    )(i)
+}
 
-named!(variant_num_lit<&[u8], MatchVariant>, map!(num_lit,
-    |s| MatchVariant::NumLit(s)
-));
+fn variant_num_lit(i: &[u8]) -> IResult<&[u8], MatchVariant> {
+    map(num_lit, |s| MatchVariant::NumLit(s))(i)
+}
 
-named!(param_num_lit<&[u8], MatchParameter>, map!(num_lit,
-    |s| MatchParameter::NumLit(s)
-));
+fn param_num_lit(i: &[u8]) -> IResult<&[u8], MatchParameter> {
+    map(num_lit, |s| MatchParameter::NumLit(s))(i)
+}
 
-named!(expr_str_lit<&[u8], Expr>, map!(
-    delimited!(char!('"'), take_until!("\""), char!('"')),
-    |s| Expr::StrLit(str::from_utf8(&s).unwrap())
-));
+fn expr_str_lit(i: &[u8]) -> IResult<&[u8], Expr> {
+    map(delimited(char('"'), take_until("\""), char('"')), |s| {
+        Expr::StrLit(str::from_utf8(s).unwrap())
+    })(i)
+}
 
-named!(variant_str_lit<&[u8], MatchVariant>, map!(
-    delimited!(char!('"'), is_not!("\""), char!('"')),
-    |s| MatchVariant::StrLit(str::from_utf8(&s).unwrap())
-));
+fn variant_str_lit(i: &[u8]) -> IResult<&[u8], MatchVariant> {
+    map(delimited(char('"'), is_not("\""), char('"')), |s| {
+        MatchVariant::StrLit(str::from_utf8(s).unwrap())
+    })(i)
+}
 
-named!(param_str_lit<&[u8], MatchParameter>, map!(
-    delimited!(char!('"'), is_not!("\""), char!('"')),
-    |s| MatchParameter::StrLit(str::from_utf8(&s).unwrap())
-));
+fn param_str_lit(i: &[u8]) -> IResult<&[u8], MatchParameter> {
+    map(delimited(char('"'), is_not("\""), char('"')), |s| {
+        MatchParameter::StrLit(str::from_utf8(s).unwrap())
+    })(i)
+}
 
-named!(expr_var<&[u8], Expr>, map!(identifier,
-    |s| Expr::Var(s))
-);
+fn expr_var(i: &[u8]) -> IResult<&[u8], Expr> {
+    map(identifier, |s| Expr::Var(s))(i)
+}
 
-named!(expr_path<&[u8], Expr>, do_parse!(
-    start: call!(identifier) >>
-    tag!("::") >>
-    rest: separated_nonempty_list!(tag!("::"), identifier) >>
-    ({
-        let mut path = vec![start];
-        path.extend(rest);
-        Expr::Path(path)
-    })
-));
-
-named!(variant_path<&[u8], MatchVariant>,
-    map!(
-        separated_nonempty_list!(tag!("::"), identifier),
-        |path| MatchVariant::Path(path)
-    )
-);
+fn expr_path(i: &[u8]) -> IResult<&[u8], Expr> {
+    let tail = separated_nonempty_list(tag("::"), identifier);
+    let (i, (start, _, rest)) = tuple((identifier, tag("::"), tail))(i)?;
 
-named!(target_single<&[u8], Target>, map!(identifier,
-    |s| Target::Name(s)
-));
-
-named!(target_tuple<&[u8], Target>, delimited!(
-    tag!("("),
-    do_parse!(
-        res: separated_list!(tag!(","), ws!(identifier)) >>
-        opt!(ws!(tag!(","))) >>
-        (Target::Tuple(res))
-    ),
-    tag!(")")
-));
-
-named!(variant_name<&[u8], MatchVariant>, map!(identifier,
-    |s| MatchVariant::Name(s)
-));
-
-named!(param_name<&[u8], MatchParameter>, map!(identifier,
-    |s| MatchParameter::Name(s)
-));
-
-named!(arguments<&[u8], Vec<Expr>>, delimited!(
-    tag!("("),
-    separated_list!(tag!(","), ws!(expr_any)),
-    tag!(")")
-));
-
-named!(macro_arguments<&[u8], &str>,
-    delimited!(char!('('), nested_parenthesis, char!(')'))
-);
+    let mut path = vec![start];
+    path.extend(rest);
+    Ok((i, Expr::Path(path)))
+}
+
+fn variant_path(i: &[u8]) -> IResult<&[u8], MatchVariant> {
+    map(separated_nonempty_list(tag("::"), identifier), |path| {
+        MatchVariant::Path(path)
+    })(i)
+}
+
+fn target_single(i: &[u8]) -> IResult<&[u8], Target> {
+    map(identifier, |s| Target::Name(s))(i)
+}
+
+fn target_tuple(i: &[u8]) -> IResult<&[u8], Target> {
+    let parts = separated_list(tag(","), ws(identifier));
+    let trailing = opt(ws(tag(",")));
+    let full = delimited(tag("("), tuple((parts, trailing)), tag(")"));
+
+    let (i, (elems, _)) = full(i)?;
+    Ok((i, Target::Tuple(elems)))
+}
+
+fn variant_name(i: &[u8]) -> IResult<&[u8], MatchVariant> {
+    map(identifier, |s| MatchVariant::Name(s))(i)
+}
+
+fn param_name(i: &[u8]) -> IResult<&[u8], MatchParameter> {
+    map(identifier, |s| MatchParameter::Name(s))(i)
+}
+
+fn arguments(i: &[u8]) -> IResult<&[u8], Vec<Expr>> {
+    delimited(tag("("), separated_list(tag(","), ws(expr_any)), tag(")"))(i)
+}
+
+fn macro_arguments(i: &[u8]) -> IResult<&[u8], &str> {
+    delimited(char('('), nested_parenthesis, char(')'))(i)
+}
 
 fn nested_parenthesis(i: &[u8]) -> Result<(&[u8], &str), nom::Err<(&[u8], nom::error::ErrorKind)>> {
     let mut nested = 0;
@@ -307,16 +328,14 @@ fn nested_parenthesis(i: &[u8]) -> Result<(&[u8], &str), nom::Err<(&[u8], nom::e
     for (i, b) in i.iter().enumerate() {
         if !(*b == b'(' || *b == b')') || !in_str {
             match *b {
-                b'(' => {
-                    nested += 1
-                },
+                b'(' => nested += 1,
                 b')' => {
                     if nested == 0 {
                         last = i;
                         break;
                     }
                     nested -= 1;
-                },
+                }
                 b'"' => {
                     if in_str {
                         if !escaped {
@@ -325,10 +344,10 @@ fn nested_parenthesis(i: &[u8]) -> Result<(&[u8], &str), nom::Err<(&[u8], nom::e
                     } else {
                         in_str = true;
                     }
-                },
+                }
                 b'\\' => {
                     escaped = !escaped;
-                },
+                }
                 _ => (),
             }
         }
@@ -348,160 +367,178 @@ fn nested_parenthesis(i: &[u8]) -> Result<(&[u8], &str), nom::Err<(&[u8], nom::e
     }
 }
 
-named!(parameters<&[u8], Vec<&str>>, delimited!(
-    tag!("("),
-    separated_list!(tag!(","), ws!(identifier)),
-    tag!(")")
-));
-
-named!(with_parameters<&[u8], MatchParameters>, do_parse!(
-    tag!("with") >>
-    value: alt!(match_simple_parameters | match_named_parameters) >>
-    (value)
-));
-
-named!(match_simple_parameters<&[u8], MatchParameters>, delimited!(
-    ws!(tag!("(")),
-    map!(separated_list!(tag!(","), ws!(match_parameter)), |mps| MatchParameters::Simple(mps)),
-    tag!(")")
-));
-
-named!(match_named_parameters<&[u8], MatchParameters>, delimited!(
-    ws!(tag!("{")),
-    map!(separated_list!(tag!(","), ws!(match_named_parameter)), |mps| MatchParameters::Named(mps)),
-    tag!("}")
-));
-
-named!(expr_group<&[u8], Expr>, map!(
-    delimited!(char!('('), expr_any, char!(')')),
-    |s| Expr::Group(Box::new(s))
-));
-
-named!(expr_single<&[u8], Expr>, alt!(
-    expr_bool_lit |
-    expr_num_lit |
-    expr_str_lit |
-    expr_path |
-    expr_rust_macro |
-    expr_array_lit |
-    expr_var |
-    expr_group
-));
-
-named!(match_variant<&[u8], MatchVariant>, alt!(
-    variant_path |
-    variant_name |
-    variant_num_lit |
-    variant_str_lit
-));
-
-named!(match_parameter<&[u8], MatchParameter>, alt!(
-    param_name |
-    param_num_lit |
-    param_str_lit
-));
-
-named!(match_named_parameter<&[u8], (&str, Option<MatchParameter>)>, do_parse!(
-    name: identifier >>
-    param: opt!(do_parse!(
-        ws!(tag!(":")) >>
-        param: match_parameter >>
-        (param)
-    )) >>
-    ((name, param))
-));
-
-named!(attr<&[u8], (&str, Option<Vec<Expr>>)>, do_parse!(
-    tag!(".") >>
-    attr: alt!(num_lit | identifier) >>
-    args: opt!(arguments) >>
-    (attr, args)
-));
-
-named!(expr_attr<&[u8], Expr>, do_parse!(
-    obj: expr_single >>
-    attrs: many0!(attr) >>
-    ({
-        let mut res = obj;
-        for (aname, args) in attrs {
-            res = if args.is_some() {
-                Expr::MethodCall(Box::new(res), aname, args.unwrap())
-            } else {
-                Expr::Attr(Box::new(res), aname)
+fn parameters(i: &[u8]) -> IResult<&[u8], Vec<&str>> {
+    delimited(tag("("), separated_list(tag(","), ws(identifier)), tag(")"))(i)
+}
+
+fn with_parameters(i: &[u8]) -> IResult<&[u8], MatchParameters> {
+    let (i, (_, value)) = tuple((
+        tag("with"),
+        alt((match_simple_parameters, match_named_parameters)),
+    ))(i)?;
+    Ok((i, value))
+}
+
+fn match_simple_parameters(i: &[u8]) -> IResult<&[u8], MatchParameters> {
+    delimited(
+        ws(tag("(")),
+        map(separated_list(tag(","), ws(match_parameter)), |mps| {
+            MatchParameters::Simple(mps)
+        }),
+        tag(")"),
+    )(i)
+}
+
+fn match_named_parameters(i: &[u8]) -> IResult<&[u8], MatchParameters> {
+    delimited(
+        ws(tag("{")),
+        map(separated_list(tag(","), ws(match_named_parameter)), |mps| {
+            MatchParameters::Named(mps)
+        }),
+        tag("}"),
+    )(i)
+}
+
+fn expr_group(i: &[u8]) -> IResult<&[u8], Expr> {
+    map(delimited(char('('), expr_any, char(')')), |s| {
+        Expr::Group(Box::new(s))
+    })(i)
+}
+
+fn expr_single(i: &[u8]) -> IResult<&[u8], Expr> {
+    alt((
+        expr_bool_lit,
+        expr_num_lit,
+        expr_str_lit,
+        expr_path,
+        expr_rust_macro,
+        expr_array_lit,
+        expr_var,
+        expr_group,
+    ))(i)
+}
+
+fn match_variant(i: &[u8]) -> IResult<&[u8], MatchVariant> {
+    alt((variant_path, variant_name, variant_num_lit, variant_str_lit))(i)
+}
+
+fn match_parameter(i: &[u8]) -> IResult<&[u8], MatchParameter> {
+    alt((param_name, param_num_lit, param_str_lit))(i)
+}
+
+fn match_named_parameter(i: &[u8]) -> IResult<&[u8], (&str, Option<MatchParameter>)> {
+    let param = tuple((ws(tag(":")), match_parameter));
+    let (i, (name, param)) = tuple((identifier, opt(param)))(i)?;
+    Ok((i, (name, param.map(|s| s.1))))
+}
+
+fn attr(i: &[u8]) -> IResult<&[u8], (&str, Option<Vec<Expr>>)> {
+    let (i, (_, attr, args)) = tuple((tag("."), alt((num_lit, identifier)), opt(arguments)))(i)?;
+    Ok((i, (attr, args)))
+}
+
+fn expr_attr(i: &[u8]) -> IResult<&[u8], Expr> {
+    let (i, (obj, attrs)) = tuple((expr_single, many0(attr)))(i)?;
+
+    let mut res = obj;
+    for (aname, args) in attrs {
+        res = if args.is_some() {
+            Expr::MethodCall(Box::new(res), aname, args.unwrap())
+        } else {
+            Expr::Attr(Box::new(res), aname)
+        };
+    }
+
+    Ok((i, res))
+}
+
+fn expr_index(i: &[u8]) -> IResult<&[u8], Expr> {
+    let key = opt(tuple((ws(tag("[")), expr_any, ws(tag("]")))));
+    let (i, (obj, key)) = tuple((expr_attr, key))(i)?;
+    let key = key.map(|(_, key, _)| key);
+
+    Ok((
+        i,
+        match key {
+            Some(key) => Expr::Index(Box::new(obj), Box::new(key)),
+            None => obj,
+        },
+    ))
+}
+
+fn filter(i: &[u8]) -> IResult<&[u8], (&str, Option<Vec<Expr>>)> {
+    let (i, (_, fname, args)) = tuple((tag("|"), identifier, opt(arguments)))(i)?;
+    Ok((i, (fname, args)))
+}
+
+fn expr_filtered(i: &[u8]) -> IResult<&[u8], Expr> {
+    let (i, (obj, filters)) = tuple((expr_index, many0(filter)))(i)?;
+
+    let mut res = obj;
+    for (fname, args) in filters {
+        res = Expr::Filter(fname, {
+            let mut args = match args {
+                Some(inner) => inner,
+                None => Vec::new(),
             };
-        }
-        res
-    })
-));
-
-named!(expr_index<&[u8], Expr>, do_parse!(
-    obj: expr_attr >>
-    key: opt!(do_parse!(
-        ws!(tag!("[")) >>
-        key: expr_any >>
-        ws!(tag!("]")) >>
-        (key)
-    )) >>
-    (match key {
-        Some(key) => Expr::Index(Box::new(obj), Box::new(key)),
-        None => obj,
-    })
-));
-
-named!(filter<&[u8], (&str, Option<Vec<Expr>>)>, do_parse!(
-    tag!("|") >>
-    fname: identifier >>
-    args: opt!(arguments) >>
-    (fname, args)
-));
-
-named!(expr_filtered<&[u8], Expr>, do_parse!(
-    obj: expr_index >>
-    filters: many0!(filter) >>
-    ({
-       let mut res = obj;
-       for (fname, args) in filters {
-           res = Expr::Filter(fname, {
-               let mut args = match args {
-                   Some(inner) => inner,
-                   None => Vec::new(),
-               };
-               args.insert(0, res);
-               args
-           });
-       }
-       res
-    })
-));
-
-named!(expr_unary<&[u8], Expr>, do_parse!(
-    op: opt!(alt!(tag!("!") | tag!("-"))) >>
-    expr: expr_filtered >>
-    (match op {
-        Some(op) => Expr::Unary(str::from_utf8(op).unwrap(), Box::new(expr)),
-        None => expr,
-    })
-));
-
-named!(expr_rust_macro<&[u8], Expr>, do_parse!(
-    mname: identifier >>
-    tag!("!") >>
-    args: macro_arguments >>
-    (Expr::RustMacro(mname, args))
-));
+            args.insert(0, res);
+            args
+        });
+    }
+
+    Ok((i, res))
+}
+
+fn expr_unary(i: &[u8]) -> IResult<&[u8], Expr> {
+    let (i, (op, expr)) = tuple((opt(alt((tag("!"), tag("-")))), expr_filtered))(i)?;
+    Ok((
+        i,
+        match op {
+            Some(op) => Expr::Unary(str::from_utf8(op).unwrap(), Box::new(expr)),
+            None => expr,
+        },
+    ))
+}
+
+fn expr_rust_macro(i: &[u8]) -> IResult<&[u8], Expr> {
+    let (i, (mname, _, args)) = tuple((identifier, tag("!"), macro_arguments))(i)?;
+    Ok((i, Expr::RustMacro(mname, args)))
+}
 
 macro_rules! expr_prec_layer {
-    ( $name:ident, $inner:ident, $( $op:expr ),* ) => {
-        named!($name<&[u8], Expr>, do_parse!(
-            left: $inner >>
-            op_and_right: opt!(pair!(ws!(alt!($( tag!($op) )|*)), expr_any)) >>
-            (match op_and_right {
+    ( $name:ident, $inner:ident, $op:expr ) => {
+        fn $name(i: &[u8]) -> IResult<&[u8], Expr> {
+            let (i, (left, op_and_right)) = tuple((
+                $inner,
+                opt(pair(
+                    ws(tag($op)),
+                    expr_any,
+                ))
+            ))(i)?;
+            Ok((i, match op_and_right {
+                Some((op, right)) => Expr::BinOp(
+                    str::from_utf8(op).unwrap(), Box::new(left), Box::new(right)
+                ),
+                None => left,
+            }))
+        }
+    };
+    ( $name:ident, $inner:ident, $( $op:expr ),+ ) => {
+        fn $name(i: &[u8]) -> IResult<&[u8], Expr> {
+            let (i, (left, op_and_right)) = tuple((
+                $inner,
+                opt(pair(
+                    ws(alt(($( tag($op) ),*,))),
+                    expr_any
+                ))
+            ))(i)?;
+            Ok((i, match op_and_right {
                 Some((op, right)) => Expr::BinOp(
                     str::from_utf8(op).unwrap(), Box::new(left), Box::new(right)
                 ),
                 None => left,
-            })
-        ));
+            }))
+        }
     }
 }
 
@@ -515,313 +552,444 @@ expr_prec_layer!(expr_compare, expr_bor, "==", "!=", ">=", ">", "<=", "<");
 expr_prec_layer!(expr_and, expr_compare, "&&");
 expr_prec_layer!(expr_or, expr_and, "||");
 
-named!(range_right<&[u8], Expr>, do_parse!(
-    ws!(tag!("..")) >>
-    incl: opt!(ws!(tag!("="))) >>
-    right: opt!(expr_or) >>
-    (Expr::Range(if incl.is_some() { "..=" } else { ".." }, None, right.map(Box::new)))
-));
-
-named!(expr_any<&[u8], Expr>, alt!(
-    range_right |
-    do_parse!(
-        left: expr_or >>
-        rest: range_right >> (match rest {
-            Expr::Range(op, _, right) => Expr::Range(op, Some(Box::new(left)), right),
-            _ => unreachable!(),
-        })
-    ) |
-    expr_or
-));
-
-named_args!(expr_node<'a>(s: &'a Syntax<'a>) <&'a [u8], Node<'a>>, do_parse!(
-    call!(tag_expr_start, s) >>
-    pws: opt!(tag!("-")) >>
-    expr: ws!(expr_any) >>
-    nws: opt!(tag!("-")) >>
-    call!(tag_expr_end, s) >>
-    (Node::Expr(WS(pws.is_some(), nws.is_some()), expr))
-));
-
-named!(block_call<&[u8], Node>, do_parse!(
-    pws: opt!(tag!("-")) >>
-    ws!(tag!("call")) >>
-    scope: opt!(do_parse!(
-        scope: ws!(identifier) >>
-        ws!(tag!("::")) >>
-        (scope)
-    )) >>
-    name: ws!(identifier) >>
-    args: ws!(arguments) >>
-    nws: opt!(tag!("-")) >>
-    (Node::Call(WS(pws.is_some(), nws.is_some()), scope, name, args))
-));
-
-named!(cond_if<&[u8], Expr>, do_parse!(
-    ws!(tag!("if")) >>
-    cond: ws!(expr_any) >>
-    (cond)
-));
-
-named_args!(cond_block<'a>(s: &'a Syntax<'a>) <&'a [u8], Cond<'a>>, do_parse!(
-    call!(tag_block_start, s) >>
-    pws: opt!(tag!("-")) >>
-    ws!(tag!("else")) >>
-    cond: opt!(cond_if) >>
-    nws: opt!(tag!("-")) >>
-    call!(tag_block_end, s) >>
-    block: call!(parse_template, s) >>
-    (WS(pws.is_some(), nws.is_some()), cond, block)
-));
-
-named_args!(block_if<'a>(s: &'a Syntax<'a>) <&'a [u8], Node<'a>>, do_parse!(
-    pws1: opt!(tag!("-")) >>
-    cond: ws!(cond_if) >>
-    nws1: opt!(tag!("-")) >>
-    call!(tag_block_end, s) >>
-    block: call!(parse_template, s) >>
-    elifs: many0!(call!(cond_block, s)) >>
-    call!(tag_block_start, s) >>
-    pws2: opt!(tag!("-")) >>
-    ws!(tag!("endif")) >>
-    nws2: opt!(tag!("-")) >>
-    ({
-       let mut res = Vec::new();
-       res.push((WS(pws1.is_some(), nws1.is_some()), Some(cond), block));
-       res.extend(elifs);
-       Node::Cond(res, WS(pws2.is_some(), nws2.is_some()))
-    })
-));
-
-named_args!(match_else_block<'a>(s: &'a Syntax<'a>) <&'a [u8], When<'a>>, do_parse!(
-    call!(tag_block_start, s) >>
-    pws: opt!(tag!("-")) >>
-    ws!(tag!("else")) >>
-    nws: opt!(tag!("-")) >>
-    call!(tag_block_end, s) >>
-    block: call!(parse_template, s) >>
-    (WS(pws.is_some(), nws.is_some()), None, MatchParameters::Simple(vec![]), block)
-));
-
-named_args!(when_block<'a>(s: &'a Syntax<'a>) <&'a [u8], When<'a>>, do_parse!(
-    call!(tag_block_start, s) >>
-    pws: opt!(tag!("-")) >>
-    ws!(tag!("when")) >>
-    variant: ws!(match_variant) >>
-    params: opt!(ws!(with_parameters)) >>
-    nws: opt!(tag!("-")) >>
-    call!(tag_block_end, s) >>
-    block: call!(parse_template, s) >>
-    (WS(pws.is_some(), nws.is_some()), Some(variant), params.unwrap_or_default(), block)
-));
-
-named_args!(block_match<'a>(s: &'a Syntax<'a>)<&'a [u8], Node<'a>>, do_parse!(
-    pws1: opt!(tag!("-")) >>
-    ws!(tag!("match")) >>
-    expr: ws!(expr_any) >>
-    nws1: opt!(tag!("-")) >>
-    call!(tag_block_end, s) >>
-    inter: opt!(call!(take_content, s)) >>
-    arms: many1!(call!(when_block, s)) >>
-    else_arm: opt!(call!(match_else_block, s)) >>
-    ws!(call!(tag_block_start, s)) >>
-    pws2: opt!(tag!("-")) >>
-    ws!(tag!("endmatch")) >>
-    nws2: opt!(tag!("-")) >>
-    ({
-        let mut arms = arms;
-        if let Some(arm) = else_arm {
-            arms.push(arm);
+fn range_right(i: &[u8]) -> IResult<&[u8], Expr> {
+    let (i, (_, incl, right)) = tuple((ws(tag("..")), opt(ws(tag("="))), opt(expr_or)))(i)?;
+    Ok((
+        i,
+        Expr::Range(
+            if incl.is_some() { "..=" } else { ".." },
+            None,
+            right.map(Box::new),
+        ),
+    ))
+}
+
+fn expr_any(i: &[u8]) -> IResult<&[u8], Expr> {
+    let compound = map(tuple((expr_or, range_right)), |(left, rest)| match rest {
+        Expr::Range(op, _, right) => Expr::Range(op, Some(Box::new(left)), right),
+        _ => unreachable!(),
+    });
+    let p = alt((range_right, compound, expr_or));
+    Ok(p(i)?)
+}
+
+fn expr_node<'a>(i: &'a [u8], s: &'a Syntax<'a>) -> IResult<&'a [u8], Node<'a>> {
+    let p = tuple((
+        |i| tag_expr_start(i, s),
+        opt(tag("-")),
+        ws(expr_any),
+        opt(tag("-")),
+        |i| tag_expr_end(i, s),
+    ));
+    let (i, (_, pws, expr, nws, _)) = p(i)?;
+    Ok((i, Node::Expr(WS(pws.is_some(), nws.is_some()), expr)))
+}
+
+fn block_call(i: &[u8]) -> IResult<&[u8], Node> {
+    let p = tuple((
+        opt(tag("-")),
+        ws(tag("call")),
+        opt(tuple((ws(identifier), ws(tag("::"))))),
+        ws(identifier),
+        ws(arguments),
+        opt(tag("-")),
+    ));
+    let (i, (pws, _, scope, name, args, nws)) = p(i)?;
+    let scope = scope.map(|(scope, _)| scope);
+    Ok((
+        i,
+        Node::Call(WS(pws.is_some(), nws.is_some()), scope, name, args),
+    ))
+}
+
+fn cond_if(i: &[u8]) -> IResult<&[u8], Expr> {
+    let (i, (_, cond)) = tuple((ws(tag("if")), ws(expr_any)))(i)?;
+    Ok((i, cond))
+}
+
+fn cond_block<'a>(i: &'a [u8], s: &'a Syntax<'a>) -> IResult<&'a [u8], Cond<'a>> {
+    let p = tuple((
+        |i| tag_block_start(i, s),
+        opt(tag("-")),
+        ws(tag("else")),
+        opt(cond_if),
+        opt(tag("-")),
+        |i| tag_block_end(i, s),
+        |i| parse_template(i, s),
+    ));
+    let (i, (_, pws, _, cond, nws, _, block)) = p(i)?;
+    Ok((i, (WS(pws.is_some(), nws.is_some()), cond, block)))
+}
+
+fn block_if<'a>(i: &'a [u8], s: &'a Syntax<'a>) -> IResult<&'a [u8], Node<'a>> {
+    let p = tuple((
+        opt(tag("-")),
+        cond_if,
+        opt(tag("-")),
+        |i| tag_block_end(i, s),
+        |i| parse_template(i, s),
+        many0(|i| cond_block(i, s)),
+        |i| tag_block_start(i, s),
+        opt(tag("-")),
+        ws(tag("endif")),
+        opt(tag("-")),
+    ));
+    let (i, (pws1, cond, nws1, _, block, elifs, _, pws2, _, nws2)) = p(i)?;
+
+    let mut res = Vec::new();
+    res.push((WS(pws1.is_some(), nws1.is_some()), Some(cond), block));
+    res.extend(elifs);
+    Ok((i, Node::Cond(res, WS(pws2.is_some(), nws2.is_some()))))
+}
+
+fn match_else_block<'a>(i: &'a [u8], s: &'a Syntax<'a>) -> IResult<&'a [u8], When<'a>> {
+    let p = tuple((
+        |i| tag_block_start(i, s),
+        opt(tag("-")),
+        ws(tag("else")),
+        opt(tag("-")),
+        |i| tag_block_end(i, s),
+        |i| parse_template(i, s),
+    ));
+    let (i, (_, pws, _, nws, _, block)) = p(i)?;
+    Ok((
+        i,
+        (
+            WS(pws.is_some(), nws.is_some()),
+            None,
+            MatchParameters::Simple(vec![]),
+            block,
+        ),
+    ))
+}
+
+fn when_block<'a>(i: &'a [u8], s: &'a Syntax<'a>) -> IResult<&'a [u8], When<'a>> {
+    let p = tuple((
+        |i| tag_block_start(i, s),
+        opt(tag("-")),
+        ws(tag("when")),
+        ws(match_variant),
+        opt(ws(with_parameters)),
+        opt(tag("-")),
+        |i| tag_block_end(i, s),
+        |i| parse_template(i, s),
+    ));
+    let (i, (_, pws, _, variant, params, nws, _, block)) = p(i)?;
+    Ok((
+        i,
+        (
+            WS(pws.is_some(), nws.is_some()),
+            Some(variant),
+            params.unwrap_or_default(),
+            block,
+        ),
+    ))
+}
+
+fn block_match<'a>(i: &'a [u8], s: &'a Syntax<'a>) -> IResult<&'a [u8], Node<'a>> {
+    let p = tuple((
+        opt(tag("-")),
+        ws(tag("match")),
+        ws(expr_any),
+        opt(tag("-")),
+        |i| tag_block_end(i, s),
+        opt(|i| take_content(i, s)),
+        many1(|i| when_block(i, s)),
+        opt(|i| match_else_block(i, s)),
+        ws(|i| tag_block_start(i, s)),
+        opt(tag("-")),
+        ws(tag("endmatch")),
+        opt(tag("-")),
+    ));
+    let (i, (pws1, _, expr, nws1, _, inter, arms, else_arm, _, pws2, _, nws2)) = p(i)?;
+
+    let mut arms = arms;
+    if let Some(arm) = else_arm {
+        arms.push(arm);
+    }
+
+    let inter = match inter {
+        Some(Node::Lit(lws, val, rws)) => {
+            assert!(
+                val.is_empty(),
+                "only whitespace allowed between match and first when, found {}",
+                val
+            );
+            assert!(
+                rws.is_empty(),
+                "only whitespace allowed between match and first when, found {}",
+                rws
+            );
+            Some(lws)
         }
-        let inter = match inter {
-            Some(Node::Lit(lws, val, rws)) => {
-                assert!(val.is_empty(),
-                        "only whitespace allowed between match and first when, found {}", val);
-                assert!(rws.is_empty(),
-                        "only whitespace allowed between match and first when, found {}", rws);
-                Some(lws)
-            },
-            None => None,
-            _ => panic!("only literals allowed between match and first when"),
-        };
+        None => None,
+        _ => panic!("only literals allowed between match and first when"),
+    };
+
+    Ok((
+        i,
         Node::Match(
             WS(pws1.is_some(), nws1.is_some()),
             expr,
             inter,
             arms,
             WS(pws2.is_some(), nws2.is_some()),
-        )
-    })
-));
-
-named!(block_let<&[u8], Node>, do_parse!(
-    pws: opt!(tag!("-")) >>
-    ws!(tag!("let")) >>
-    var: ws!(alt!(target_single | target_tuple)) >>
-    val: opt!(do_parse!(
-        ws!(tag!("=")) >>
-        val: ws!(expr_any) >>
-        (val)
-    )) >>
-    nws: opt!(tag!("-")) >>
-    (if val.is_some() {
-        Node::Let(WS(pws.is_some(), nws.is_some()), var, val.unwrap())
-    } else {
-        Node::LetDecl(WS(pws.is_some(), nws.is_some()), var)
-    })
-));
-
-named_args!(block_for<'a>(s: &'a Syntax<'a>) <&'a [u8], Node<'a>>, do_parse!(
-    pws1: opt!(tag!("-")) >>
-    ws!(tag!("for")) >>
-    var: ws!(alt!(target_single | target_tuple)) >>
-    ws!(tag!("in")) >>
-    iter: ws!(expr_any) >>
-    nws1: opt!(tag!("-")) >>
-    call!(tag_block_end, s) >>
-    block: call!(parse_template, s) >>
-    call!(tag_block_start, s) >>
-    pws2: opt!(tag!("-")) >>
-    ws!(tag!("endfor")) >>
-    nws2: opt!(tag!("-")) >>
-    (Node::Loop(WS(pws1.is_some(), nws1.is_some()),
-                var, iter, block,
-                WS(pws2.is_some(), nws2.is_some())))
-));
-
-named!(block_extends<&[u8], Node>, do_parse!(
-    ws!(tag!("extends")) >>
-    name: ws!(expr_str_lit) >>
-    (Node::Extends(name))
-));
-
-named_args!(block_block<'a>(s: &'a Syntax<'a>) <&'a [u8], Node<'a>>, do_parse!(
-    pws1: opt!(tag!("-")) >>
-    ws!(tag!("block")) >>
-    name: ws!(identifier) >>
-    nws1: opt!(tag!("-")) >>
-    call!(tag_block_end, s) >>
-    contents: call!(parse_template, s) >>
-    call!(tag_block_start, s) >>
-    pws2: opt!(tag!("-")) >>
-    ws!(tag!("endblock")) >>
-    opt!(ws!(tag!(name))) >>
-    nws2: opt!(tag!("-")) >>
-    (Node::BlockDef(WS(pws1.is_some(), nws1.is_some()),
-                    name, contents,
-                    WS(pws2.is_some(), nws2.is_some())))
-));
-
-named!(block_include<&[u8], Node>, do_parse!(
-    pws: opt!(tag!("-")) >>
-    ws!(tag!("include")) >>
-    name: ws!(expr_str_lit) >>
-    nws: opt!(tag!("-")) >>
-    (Node::Include(WS(pws.is_some(), nws.is_some()), match name {
-        Expr::StrLit(s) => s,
-        _ => panic!("include path must be a string literal"),
-    }))
-));
-
-named!(block_import<&[u8], Node>, do_parse!(
-    pws: opt!(tag!("-")) >>
-    ws!(tag!("import")) >>
-    name: ws!(expr_str_lit) >>
-    ws!(tag!("as")) >>
-    scope: ws!(identifier) >>
-    nws: opt!(tag!("-")) >>
-    (Node::Import(WS(pws.is_some(), nws.is_some()), match name {
-        Expr::StrLit(s) => s,
-        _ => panic!("import path must be a string literal"),
-    }, scope))
-));
-
-named_args!(block_macro<'a>(s: &'a Syntax<'a>) <&'a [u8], Node<'a>>, do_parse!(
-    pws1: opt!(tag!("-")) >>
-    ws!(tag!("macro")) >>
-    name: ws!(identifier) >>
-    params: ws!(parameters) >>
-    nws1: opt!(tag!("-")) >>
-    call!(tag_block_end, s) >>
-    contents: call!(parse_template, s) >>
-    call!(tag_block_start, s) >>
-    pws2: opt!(tag!("-")) >>
-    ws!(tag!("endmacro")) >>
-    nws2: opt!(tag!("-")) >>
-    ({
-        if name == "super" {
-            panic!("invalid macro name 'super'");
-        }
+        ),
+    ))
+}
+
+fn block_let(i: &[u8]) -> IResult<&[u8], Node> {
+    let p = tuple((
+        opt(tag("-")),
+        ws(tag("let")),
+        ws(alt((target_single, target_tuple))),
+        opt(tuple((ws(tag("=")), ws(expr_any)))),
+        opt(tag("-")),
+    ));
+    let (i, (pws, _, var, val, nws)) = p(i)?;
+
+    Ok((
+        i,
+        if let Some((_, val)) = val {
+            Node::Let(WS(pws.is_some(), nws.is_some()), var, val)
+        } else {
+            Node::LetDecl(WS(pws.is_some(), nws.is_some()), var)
+        },
+    ))
+}
+
+fn block_for<'a>(i: &'a [u8], s: &'a Syntax<'a>) -> IResult<&'a [u8], Node<'a>> {
+    let p = tuple((
+        opt(tag("-")),
+        ws(tag("for")),
+        ws(alt((target_single, target_tuple))),
+        ws(tag("in")),
+        ws(expr_any),
+        opt(tag("-")),
+        |i| tag_block_end(i, s),
+        |i| parse_template(i, s),
+        |i| tag_block_start(i, s),
+        opt(tag("-")),
+        ws(tag("endfor")),
+        opt(tag("-")),
+    ));
+    let (i, (pws1, _, var, _, iter, nws1, _, block, _, pws2, _, nws2)) = p(i)?;
+    Ok((
+        i,
+        Node::Loop(
+            WS(pws1.is_some(), nws1.is_some()),
+            var,
+            iter,
+            block,
+            WS(pws2.is_some(), nws2.is_some()),
+        ),
+    ))
+}
+
+fn block_extends(i: &[u8]) -> IResult<&[u8], Node> {
+    let (i, (_, name)) = tuple((ws(tag("extends")), ws(expr_str_lit)))(i)?;
+    Ok((i, Node::Extends(name)))
+}
+
+fn block_block<'a>(i: &'a [u8], s: &'a Syntax<'a>) -> IResult<&'a [u8], Node<'a>> {
+    let start = tuple((
+        opt(tag("-")),
+        ws(tag("block")),
+        ws(identifier),
+        opt(tag("-")),
+        |i| tag_block_end(i, s),
+        |i| parse_template(i, s),
+    ));
+    let (i, (pws1, _, name, nws1, _, contents)) = start(i)?;
+
+    let end = tuple((
+        |i| tag_block_start(i, s),
+        opt(tag("-")),
+        ws(tag("endblock")),
+        opt(ws(tag(name))),
+        opt(tag("-")),
+    ));
+    let (i, (_, pws2, _, _, nws2)) = end(i)?;
+
+    Ok((
+        i,
+        Node::BlockDef(
+            WS(pws1.is_some(), nws1.is_some()),
+            name,
+            contents,
+            WS(pws2.is_some(), nws2.is_some()),
+        ),
+    ))
+}
+
+fn block_include(i: &[u8]) -> IResult<&[u8], Node> {
+    let p = tuple((
+        opt(tag("-")),
+        ws(tag("include")),
+        ws(expr_str_lit),
+        opt(tag("-")),
+    ));
+    let (i, (pws, _, name, nws)) = p(i)?;
+    Ok((
+        i,
+        Node::Include(
+            WS(pws.is_some(), nws.is_some()),
+            match name {
+                Expr::StrLit(s) => s,
+                _ => panic!("include path must be a string literal"),
+            },
+        ),
+    ))
+}
+
+fn block_import(i: &[u8]) -> IResult<&[u8], Node> {
+    let p = tuple((
+        opt(tag("-")),
+        ws(tag("import")),
+        ws(expr_str_lit),
+        ws(tag("as")),
+        ws(identifier),
+        opt(tag("-")),
+    ));
+    let (i, (pws, _, name, _, scope, nws)) = p(i)?;
+    Ok((
+        i,
+        Node::Import(
+            WS(pws.is_some(), nws.is_some()),
+            match name {
+                Expr::StrLit(s) => s,
+                _ => panic!("import path must be a string literal"),
+            },
+            scope,
+        ),
+    ))
+}
+
+fn block_macro<'a>(i: &'a [u8], s: &'a Syntax<'a>) -> IResult<&'a [u8], Node<'a>> {
+    let p = tuple((
+        opt(tag("-")),
+        ws(tag("macro")),
+        ws(identifier),
+        ws(parameters),
+        opt(tag("-")),
+        |i| tag_block_end(i, s),
+        |i| parse_template(i, s),
+        |i| tag_block_start(i, s),
+        opt(tag("-")),
+        ws(tag("endmacro")),
+        opt(tag("-")),
+    ));
+
+    let (i, (pws1, _, name, params, nws1, _, contents, _, pws2, _, nws2)) = p(i)?;
+    if name == "super" {
+        panic!("invalid macro name 'super'");
+    }
+
+    Ok((
+        i,
         Node::Macro(
             name,
             Macro {
                 ws1: WS(pws1.is_some(), nws1.is_some()),
                 args: params,
                 nodes: contents,
-                ws2: WS(pws2.is_some(), nws2.is_some())
-            }
-        )
-    })
-));
-
-named_args!(block_raw<'a>(s: &'a Syntax<'a>) <&'a [u8], Node<'a>>, do_parse!(
-    pws1: opt!(tag!("-")) >>
-    ws!(tag!("raw")) >>
-    nws1: opt!(tag!("-")) >>
-    call!(tag_block_end, s) >>
-    contents: take_until!("{% endraw %}") >>
-    call!(tag_block_start, s) >>
-    pws2: opt!(tag!("-")) >>
-    ws!(tag!("endraw")) >>
-    nws2: opt!(tag!("-")) >>
-    ({
-        let str_contents = str::from_utf8(&contents).unwrap();
-        (Node::Raw(WS(pws1.is_some(), nws1.is_some()),
-                   str_contents,
-                   WS(pws2.is_some(), nws2.is_some())))
-    })
-));
-
-named_args!(block_node<'a>(s: &'a Syntax<'a>) <&'a [u8], Node<'a>>, do_parse!(
-    call!(tag_block_start, s) >>
-    contents: alt!(
-        block_call |
-        block_let |
-        call!(block_if, s) |
-        call!(block_for, s) |
-        call!(block_match, s) |
-        block_extends |
-        block_include |
-        block_import |
-        call!(block_block, s) |
-        call!(block_macro, s) |
-        call!(block_raw, s)
-    ) >>
-    call!(tag_block_end, s) >>
-    (contents)
-));
-
-named_args!(block_comment<'a>(s: &'a Syntax<'a>) <&'a [u8], Node<'a>>, do_parse!(
-    call!(tag_comment_start, s)  >>
-    pws: opt!(tag!("-")) >>
-    inner: take_until!(s.comment_end) >>
-    call!(tag_comment_end, s) >>
-    (Node::Comment(WS(pws.is_some(), inner.len() > 1 && inner[inner.len() - 1] == b'-')))
-));
-
-named_args!(parse_template<'a>(s: &'a Syntax<'a>)<&'a [u8], Vec<Node<'a>>>, many0!(alt!(
-    complete!(call!(take_content, s)) |
-    complete!(call!(block_comment, s)) |
-    complete!(call!(expr_node, s)) |
-    complete!(call!(block_node, s))
-)));
-
-named_args!(tag_block_start<'a>(s: &'a Syntax<'a>) <&'a [u8], &'a [u8]>, tag!(s.block_start));
-named_args!(tag_block_end<'a>(s: &'a Syntax<'a>) <&'a [u8], &'a [u8]>, tag!(s.block_end));
-named_args!(tag_comment_start<'a>(s: &'a Syntax<'a>) <&'a [u8], &'a [u8]>, tag!(s.comment_start));
-named_args!(tag_comment_end<'a>(s: &'a Syntax<'a>) <&'a [u8], &'a [u8]>, tag!(s.comment_end));
-named_args!(tag_expr_start<'a>(s: &'a Syntax<'a>) <&'a [u8], &'a [u8]>, tag!(s.expr_start));
-named_args!(tag_expr_end<'a>(s: &'a Syntax<'a>) <&'a [u8], &'a [u8]>, tag!(s.expr_end));
+                ws2: WS(pws2.is_some(), nws2.is_some()),
+            },
+        ),
+    ))
+}
+
+fn block_raw<'a>(i: &'a [u8], s: &'a Syntax<'a>) -> IResult<&'a [u8], Node<'a>> {
+    let p = tuple((
+        opt(tag("-")),
+        ws(tag("raw")),
+        opt(tag("-")),
+        |i| tag_block_end(i, s),
+        take_until("{% endraw %}"),
+        |i| tag_block_start(i, s),
+        opt(tag("-")),
+        ws(tag("endraw")),
+        opt(tag("-")),
+    ));
+
+    let (i, (pws1, _, nws1, _, contents, _, pws2, _, nws2)) = p(i)?;
+    let str_contents = str::from_utf8(contents).unwrap();
+    Ok((
+        i,
+        Node::Raw(
+            WS(pws1.is_some(), nws1.is_some()),
+            str_contents,
+            WS(pws2.is_some(), nws2.is_some()),
+        ),
+    ))
+}
+
+fn block_node<'a>(i: &'a [u8], s: &'a Syntax<'a>) -> IResult<&'a [u8], Node<'a>> {
+    let p = tuple((
+        |i| tag_block_start(i, s),
+        alt((
+            block_call,
+            block_let,
+            |i| block_if(i, s),
+            |i| block_for(i, s),
+            |i| block_match(i, s),
+            block_extends,
+            block_include,
+            block_import,
+            |i| block_block(i, s),
+            |i| block_macro(i, s),
+            |i| block_raw(i, s),
+        )),
+        |i| tag_block_end(i, s),
+    ));
+    let (i, (_, contents, _)) = p(i)?;
+    Ok((i, contents))
+}
+
+fn block_comment<'a>(i: &'a [u8], s: &'a Syntax<'a>) -> IResult<&'a [u8], Node<'a>> {
+    let p = tuple((
+        |i| tag_comment_start(i, s),
+        opt(tag("-")),
+        take_until(s.comment_end),
+        |i| tag_comment_end(i, s),
+    ));
+    let (i, (_, pws, inner, _)) = p(i)?;
+    Ok((
+        i,
+        Node::Comment(WS(
+            pws.is_some(),
+            inner.len() > 1 && inner[inner.len() - 1] == b'-',
+        )),
+    ))
+}
+
+fn parse_template<'a>(i: &'a [u8], s: &'a Syntax<'a>) -> IResult<&'a [u8], Vec<Node<'a>>> {
+    many0(alt((
+        complete(|i| take_content(i, s)),
+        complete(|i| block_comment(i, s)),
+        complete(|i| expr_node(i, s)),
+        complete(|i| block_node(i, s)),
+    )))(i)
+}
+
+fn tag_block_start<'a>(i: &'a [u8], s: &'a Syntax<'a>) -> IResult<&'a [u8], &'a [u8]> {
+    tag(s.block_start)(i)
+}
+fn tag_block_end<'a>(i: &'a [u8], s: &'a Syntax<'a>) -> IResult<&'a [u8], &'a [u8]> {
+    tag(s.block_end)(i)
+}
+fn tag_comment_start<'a>(i: &'a [u8], s: &'a Syntax<'a>) -> IResult<&'a [u8], &'a [u8]> {
+    tag(s.comment_start)(i)
+}
+fn tag_comment_end<'a>(i: &'a [u8], s: &'a Syntax<'a>) -> IResult<&'a [u8], &'a [u8]> {
+    tag(s.comment_end)(i)
+}
+fn tag_expr_start<'a>(i: &'a [u8], s: &'a Syntax<'a>) -> IResult<&'a [u8], &'a [u8]> {
+    tag(s.expr_start)(i)
+}
+fn tag_expr_end<'a>(i: &'a [u8], s: &'a Syntax<'a>) -> IResult<&'a [u8], &'a [u8]> {
+    tag(s.expr_end)(i)
+}
 
 pub fn parse<'a>(src: &'a str, syntax: &'a Syntax<'a>) -> Vec<Node<'a>> {
     match parse_template(src.as_bytes(), syntax) {