pipa-lang 1.0.0-alpha.1

// SPDX-FileCopyrightText: Copyright 2026 olav@occy.org
// SPDX-License-Identifier: MPL-2.0

pub mod adapter;
pub(crate) mod args;
pub mod arity;
pub mod error;
#[doc(hidden)]
pub mod escape;
pub mod eval;
pub(crate) mod label;
mod lex;
pub(crate) mod machine;
pub(crate) mod node;
mod parse;
#[doc(hidden)]
pub mod template;

use crate::lang::parse::parse;
use crate::value::Value;
use crate::value::keys::Keys;
use crate::value::map::Map;
use crate::value::span::Span;
use crate::value::tracer::Segment;
use crate::value::tracer::Tracer;
use adapter::Adapter;
use error::Error;
use eval::Eval;
use eval::eval;
use eval::eval_keys;
use template::TemplateResult;
use template::TemplateSegment;
use template::split_template_delimiters;

/// Evaluate a template like `Hello {capitalize name}!`.
///
/// * `adapter`: define custom functions and built-in values.
/// * `map`: the environment used by getters and setters.
/// * `template`: the template under evaluation.
///
pub fn eval_template(adapter: &impl Adapter, map: &mut Map, tmpl: &[u8]) -> Vec<TemplateResult> {
    let span = adapter.template_span().unwrap_or_else(|| Span::from(tmpl));

    let value_from_static_bytes = |s: Span| -> Eval<Value> {
        let mut eval = Eval::<Value>::from(s.read(tmpl).to_vec());
        let result = core::mem::take(&mut eval.result);
        let tracer = Tracer::default()
            .with_source(adapter.template_source().unwrap_or_default())
            .with_span(span.zoom(s))
            .with_segment(Segment::Static);
        eval.result = result.with_tracer(tracer);
        eval
    };

    let eval_delimited_segment = |splat| match splat {
        TemplateSegment::Dynamic(s) => Some(TemplateResult {
            result: eval_expression_impl(adapter, map, span.zoom(s), s.read(tmpl)),
            segment: TemplateSegment::Dynamic(s.expand(1, 1)),
        }),
        TemplateSegment::Static(s) => Some(TemplateResult {
            result: Ok(value_from_static_bytes(s)),
            segment: TemplateSegment::Static(s),
        }),
        TemplateSegment::Escaper(_) => None,
        TemplateSegment::Delimiter(_) => None,
    };

    split_template_delimiters(tmpl)
        .into_iter()
        .filter_map(eval_delimited_segment)
        .collect()
}

/// Evaluate an expression like `name | trim | capitalize`.
///
/// * `adapter`: define custom functions and built-in values.
/// * `map`: the environment used by getters and setters.
/// * `template`: the expression under evaluation.
///
pub fn eval_expression(
    adapter: &impl Adapter,
    map: &mut Map,
    exp: &[u8],
) -> Result<Eval<Value>, Error> {
    let span = adapter.template_span().unwrap_or_else(|| Span::from(exp));

    eval_expression_impl(adapter, map, span, exp)
}

#[doc(hidden)]
pub fn eval_keys_template(
    adapter: &impl Adapter,
    map: &mut Map,
    tmpl: &[u8],
) -> Result<Option<Eval<Keys>>, Error> {
    let span = adapter.template_span().unwrap_or_else(|| Span::from(tmpl));

    let eval_span = split_template_delimiters(tmpl)
        .into_iter()
        .find_map(|t| match t {
            TemplateSegment::Dynamic(s) => Some(s),
            TemplateSegment::Escaper(_) => None,
            TemplateSegment::Delimiter(_) => None,
            TemplateSegment::Static(_) => None,
        })
        .unwrap_or_default();

    let node = parse(
        adapter.template_source(),
        span.zoom(eval_span),
        eval_span.read(tmpl),
    )?;

    eval_keys(adapter, map, span, node)
}

#[doc(hidden)]
pub fn eval_keys_expression(
    adapter: &impl Adapter,
    map: &mut Map,
    exp: &[u8],
) -> Result<Option<Eval<Keys>>, Error> {
    let span = adapter.template_span().unwrap_or_else(|| Span::from(exp));

    eval_keys(
        adapter,
        map,
        span,
        parse(adapter.template_source(), span, exp)?,
    )
}

fn eval_expression_impl(
    adapter: &impl Adapter,
    map: &mut Map,
    span: Span,
    exp: &[u8],
) -> Result<Eval<Value>, Error> {
    eval(
        adapter,
        map,
        span,
        parse(adapter.template_source(), span, exp)?,
    )
}

#[cfg(test)]
mod test {
    use super::*;
    use crate::lang::adapter;
    use crate::value::list::List;
    use crate::value::map::Map;
    use crate::value::operation;
    use crate::value::operation::fold_map_value;
    use crate::value::operation::get_map_value;

    #[test]
    fn test_expression() {
        assert_eq!(expression(b"a").unwrap(), b"");
        assert_eq!(expression(b"1").unwrap(), b"1");
        assert_eq!(expression(b"1 2").unwrap(), b"12");
        assert_eq!(expression(b"{1 2}").unwrap(), b"2");
        assert_eq!(expression(b"<i>").unwrap(), b"<i>");
        assert_eq!(expression(b"<i>1").unwrap(), b"<i>1");
        assert_eq!(expression(b"1</i>").unwrap(), b"1</i>");
        assert!(!expression(b"").is_err());
        assert!(expression(b"}").is_err());
        assert!(expression(b"a}").is_err());
    }

    #[test]
    fn test_template() {
        assert_eq!(template_ok(b""), b"");
        assert_eq!(template_ok(b"a"), b"a");
        assert_eq!(template_ok(b"{{}}"), b"");
        assert_eq!(template_ok(b"{a}"), b"");
        assert_eq!(template_ok(b"{1}"), b"1");
        assert_eq!(template_ok(b"{1 2}"), b"12");
        assert_eq!(template_ok(b"{1 a}"), b"1");
        assert_eq!(template_ok(b"{ 1\n }"), b"1");
        assert_eq!(template_ok(b" {.}\t\n  "), b" \t\n  ");
        assert_eq!(template_ok(b"/foo/{bar}/{baz}.h"), b"/foo//.h");
        assert_eq!(template_ok(b"{\" 'a' b \"}"), b" 'a' b ");
        assert_eq!(template_ok(b"{'a b c'}"), b"a b c");
        assert_eq!(template_ok(b"{ 'a b c' }"), b"a b c");
        assert_eq!(template_ok(b"{ 'a b c' # comment\n }"), b"a b c");
        assert_eq!(template_ok(br#"{"{}"}"#), b"{}");
        assert_eq!(template_ok(b"{'{{{'}"), b"{{{");
        assert_eq!(template_ok(br#"{" \"a\" b "}"#), br#" \"a\" b "#);
        assert_eq!(template_ok(br#"{' \'a\' b '}"#), br#" \'a\' b "#);
        assert_eq!(template_ok(b"{(1)}"), b"1");
        assert_eq!(template_ok(b"{1|append # 2 \n 3}"), b"13");
        assert_eq!(template_ok(br#"{(1 2 3)}"#), b"123");
        assert!(!template_err(b"{").is_err());
        assert!(!template_err(b"{{").is_err());
        assert!(!template_err(b"{[]}").is_err());
        assert!(!template_err(b"}}").is_err());
        assert!(!template_err(b"}").is_err());
        assert!(!template_err(b"{foo").is_err());
        assert!(!template_err(b"foo}").is_err());
        assert!(!template_err(b"{ # {{{ # }").is_err());
        assert!(!template_err(b"{## {{{ ##}").is_err());
        assert!(!template_err(b"{}").is_err());
        assert!(!template_err(b"{ }").is_err());
        assert!(!template_err(b"{\n\t}").is_err());
        assert!(!template_err(b"{()}").is_err());
        assert!(!template_err(br#"{###}"#).is_err());
        assert!(template_err(b"{a // }").is_err());
        assert!(template_err(b"{{{}}}").is_err());
    }

    #[test]
    fn test_concat() {
        let myz = Value::Map(Map::default().with("y", "z"));
        let mut map = Map::default().with("x", myz);
        assert_eq!(template(b"{1|2}", &mut map).unwrap(), b"2");
        assert_eq!(template(b"{1 2 x}", &mut map).unwrap(), b"12z");
        assert_eq!(template(b"{1 x x}", &mut map).unwrap(), b"1zz");
        assert_eq!(template(b"{x x x}", &mut map).unwrap(), b"zzz");
        assert_eq!(template(b"{x x 3}", &mut map).unwrap(), b"zz3");
        assert_eq!(template(b"{x 2 3}", &mut map).unwrap(), b"z23");
        assert_eq!(template(b"{x (x.y) (1 2) x}", &mut map).unwrap(), b"zz12z");
        assert_eq!(template(b"{1||2}", &mut map).unwrap(), b"1");
        assert_eq!(template(b"{1&&2}", &mut map).unwrap(), b"2");
        assert_eq!(template(b"{1 2|3 4}", &mut map).unwrap(), b"34");
        assert_eq!(template(b"{1 2||3 4}", &mut map).unwrap(), b"12");
        assert_eq!(template(b"{1 2&&3 4}", &mut map).unwrap(), b"34");
        assert_eq!(template(b"{ 1 2|3 4}", &mut map).unwrap(), b"34");
        assert_eq!(template(b"{ 1 2||3 4}", &mut map).unwrap(), b"12");
        assert_eq!(template(b"{ 1 2&&3 4}", &mut map).unwrap(), b"34");
        assert_eq!(template(b"{1 2|3 4 }", &mut map).unwrap(), b"34");
        assert_eq!(template(b"{1 2||3 4 }", &mut map).unwrap(), b"12");
        assert_eq!(template(b"{1 2&&3 4 }", &mut map).unwrap(), b"34");
        assert_eq!(template(b"{1 2 | 3 4}", &mut map).unwrap(), b"34");
        assert_eq!(template(b"{1 2 || 3 4}", &mut map).unwrap(), b"12");
        assert_eq!(template(b"{1 2 && 3 4}", &mut map).unwrap(), b"34");
        assert_eq!(template(b"{1 |||23}", &mut map).unwrap(), b"23");
        assert_eq!(template(b"{1||| 23}", &mut map).unwrap(), b"23");
        assert_eq!(template(b"{1 ||| 23}", &mut map).unwrap(), b"23");
        assert_eq!(template(b"{1 && 2}", &mut map).unwrap(), b"2");
        assert_eq!(template(b"{(1 && 2)}", &mut map).unwrap(), b"2");
        assert_eq!(template(b"{(1&&2)||3}", &mut map).unwrap(), b"2");
        assert_eq!(template(b"{(1&&2)|| 3}", &mut map).unwrap(), b"2");
        assert_eq!(template(b"{(1)||2}", &mut map).unwrap(), b"1");
        assert_eq!(template(b"{(1)|| 2}", &mut map).unwrap(), b"1");
        assert_eq!(template(b"{(1) ||2}", &mut map).unwrap(), b"1");
        assert_eq!(template(b"{(1) || 2}", &mut map).unwrap(), b"1");
        assert_eq!(template(b"{(1)&&2}", &mut map).unwrap(), b"2");
        assert_eq!(template(b"{(1)&& 2}", &mut map).unwrap(), b"2");
        assert_eq!(template(b"{(1) &&2}", &mut map).unwrap(), b"2");
        assert_eq!(template(b"{(1) && 2}", &mut map).unwrap(), b"2");
        assert_eq!(template(b"{1 [2].0}", &mut map).unwrap(), b"12");
        assert_eq!(template(b"{(1)}", &mut map).unwrap(), b"1");
        assert_eq!(template(b"{1 (2)}", &mut map).unwrap(), b"12");
        assert_eq!(template(b"{(1) 2}", &mut map).unwrap(), b"12");
        assert_eq!(template(b"{(1) (2)}", &mut map).unwrap(), b"12");
        assert_eq!(template(b"{(1) 2 3}", &mut map).unwrap(), b"123");
        assert_eq!(template(b"{1 (2) 3}", &mut map).unwrap(), b"123");
        assert_eq!(template(b"{1 2 (3)}", &mut map).unwrap(), b"123");
        assert_eq!(template(b"{(1) (2) 3}", &mut map).unwrap(), b"123");
        assert_eq!(template(b"{1 (2) (3)}", &mut map).unwrap(), b"123");
        assert_eq!(template(b"{(1) 2 (3)}", &mut map).unwrap(), b"123");
        assert_eq!(template(b"{(1) (2) (3)}", &mut map).unwrap(), b"123");
        assert_eq!(template(b"{1 2 | 3 4}", &mut map).unwrap(), b"34");
        assert_eq!(template(b"{1 2 | 3}", &mut map).unwrap(), b"3");
        assert_eq!(template(b"{1 | 2 3}", &mut map).unwrap(), b"23");
        assert_eq!(template(b"{1 | _ 2 3}", &mut map).unwrap(), b"123");
        assert_eq!(template(b"{1 | _ 2 3 _}", &mut map).unwrap(), b"1231");
    }

    #[test]
    fn test_tags() {
        let mut map = Map::default().with("x", "y");
        assert_eq!(template(b"{<x>}", &mut map).unwrap(), b"<x>");
        assert_eq!(template(br#"{<\<x>}"#, &mut map).unwrap(), br#"<\<x>"#);
        assert_eq!(template(b"{</x>}", &mut map).unwrap(), b"</x>");
        assert_eq!(template(br#"{</x\>>}"#, &mut map).unwrap(), br#"</x\>>"#);
        assert_eq!(template(b"{<foo> 1}", &mut map).unwrap(), b"<foo>1");
        assert_eq!(template(b"{1 </foo>}", &mut map).unwrap(), b"1</foo>");
        assert_eq!(template(b"{<i> 1 </i>}", &mut map).unwrap(), b"<i>1</i>");
        assert_eq!(template(b"{<i> 1</i>}", &mut map).unwrap(), b"<i>1</i>");
        assert_eq!(template(b"{<i>1 </i>}", &mut map).unwrap(), b"<i>1</i>");
        assert_eq!(template(b"{<i>1</i>}", &mut map).unwrap(), b"<i>1</i>");
        assert_eq!(template(b"{<em>2</em>}", &mut map).unwrap(), b"<em>2</em>");
        assert_eq!(template(b"{<i>x}", &mut map).unwrap(), b"<i>y");
        assert_eq!(template(b"{<i> x}", &mut map).unwrap(), b"<i>y");
        assert_eq!(template(b"{x</i>}", &mut map).unwrap(), b"y</i>");
        assert_eq!(template(b"{x </i>}", &mut map).unwrap(), b"y</i>");
        assert_eq!(template(b"{<i>x</i>}", &mut map).unwrap(), b"<i>y</i>");
        assert_eq!(template(b"{<i>x </i>}", &mut map).unwrap(), b"<i>y</i>");
        assert_eq!(template(b"{<i> x</i>}", &mut map).unwrap(), b"<i>y</i>");
        assert_eq!(template(b"{<i> x </i>}", &mut map).unwrap(), b"<i>y</i>");
        assert_eq!(template(b"{<i> x 2</i>}", &mut map).unwrap(), b"<i>y2</i>");
        assert_eq!(template(b"{<i>3 x</i>}", &mut map).unwrap(), b"<i>3y</i>");
        assert_eq!(template(b"{<i>a x </i>}", &mut map).unwrap(), b"<i>y</i>");
        assert_eq!(template(b"{<i>x 'a'</i>}", &mut map).unwrap(), b"<i>ya</i>");
        assert_eq!(template(b"{<i><i><i>}", &mut map).unwrap(), b"<i><i><i>");
        assert_eq!(template(b"{</i></i>}", &mut map).unwrap(), b"</i></i>");
        assert_eq!(template(b"{7|<i>_}", &mut map).unwrap(), b"<i>7");
        assert_eq!(template(b"{7| <i> _ }", &mut map).unwrap(), b"<i>7");
        assert_eq!(template(b"{7|_</i>}", &mut map).unwrap(), b"7</i>");
        assert_eq!(template(b"{7| _ </i> }", &mut map).unwrap(), b"7</i>");
        assert_eq!(template(b"{7|<i>_</i>}", &mut map).unwrap(), b"<i>7</i>");
        assert!(template(b"{<i}", &mut map).is_err());
        assert!(template(b"{i>}", &mut map).is_err());
        assert!(template(b"{<<i}", &mut map).is_err());
        assert!(template(b"{i>>}", &mut map).is_err());
        assert!(template(b"{<<i>>}", &mut map).is_err());
        assert!(template(b"{<<<i>>>}", &mut map).is_err());
        assert!(template(b"{</<i>>}", &mut map).is_err());
        assert!(template(b"{</</i>>}", &mut map).is_err());
        assert!(template(b"{<i>>}", &mut map).is_err());
        assert!(template(b"{/<i>}", &mut map).is_err());
    }

    #[test]
    fn test_label() {
        let mab = Value::Map(Map::default().with("a", "b"));
        let mbc = Value::Map(Map::default().with("b", "c"));
        let mut map = Map::default().with("x", mab).with("y", mbc);
        assert_eq!(template(b"{z}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{x}", &mut map).unwrap(), b"b");
        assert_eq!(template(b"{y}", &mut map).unwrap(), b"c");
        assert_eq!(template(b"{y.b}", &mut map).unwrap(), b"c");
        assert_eq!(template(b"{y.z}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{[x]}", &mut map).unwrap(), b"b");
        assert_eq!(template(b"{y[x]}", &mut map).unwrap(), b"c");
        assert_eq!(template(b"{y(get x)}", &mut map).unwrap(), b"c");
        assert_eq!(template(b"{get x}", &mut map).unwrap(), b"b");
        assert_eq!(template(b"{get z}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{z && get x}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{z || get x}", &mut map).unwrap(), b"b");
        assert_eq!(template(b"{y(z || get x)}", &mut map).unwrap(), b"c");
        assert_eq!(template(b"{y(get x || z)}", &mut map).unwrap(), b"c");
        assert_eq!(template(b"{get x && z}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{(get x && z)}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{get x && 'z'}", &mut map).unwrap(), b"z");
        assert_eq!(template(b"{(get x && 'z')}", &mut map).unwrap(), b"z");
        assert_eq!(template(b"{y(get x && z)}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{y(get x && 'z')}", &mut map).unwrap(), b"");
    }

    #[test]
    fn test_label_prefix() {
        let mut map = Map::default().with("a", "b").with("eq", "c");
        assert_eq!(template(b"{a}", &mut map).unwrap(), b"b");
        assert_eq!(template(b"{b}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{:a}", &mut map).unwrap(), b"b");
        assert_eq!(template(b"{:b}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{eq}", &mut map).unwrap(), b"c");
        assert_eq!(template(b"{eq 1 1}", &mut map).unwrap(), b"c11");
        assert_eq!(template(b"{:eq 1 1}", &mut map).unwrap(), b"c11");
        assert_eq!(template(b"{fn:eq 1 1}", &mut map).unwrap(), b"true");
        assert_eq!(template(b"{:format-date}", &mut map).unwrap(), b"");
        assert!(template(b"{format-date}", &mut map).is_err());
        assert!(template(b"{a:}", &mut map).is_err());
        assert!(template(b"{b:}", &mut map).is_err());
        assert!(template(b"{fn:a}", &mut map).is_err());
        assert!(template(b"{fn:b}", &mut map).is_err());
        assert!(template(b"{eq:}", &mut map).is_err());
        assert!(template(b"{fn:eq}", &mut map).is_err());
    }

    #[test]
    fn test_and_or() {
        assert_eq!(expression(b"1 || 2").unwrap(), b"1");
        assert_eq!(expression(b"1 && 2").unwrap(), b"2");
        assert_eq!(expression(b"1 || 2 || 3").unwrap(), b"1");
        assert_eq!(expression(b"1 && 2 && 3").unwrap(), b"3");
        assert_eq!(expression(b"1 || 2 && 3").unwrap(), b"1");
        assert_eq!(expression(b"1 && 2 || 3").unwrap(), b"2");
        assert_eq!(expression(b"'' || 2").unwrap(), b"2");
        assert_eq!(expression(b"'' && 2").unwrap(), b"");
        assert_eq!(expression(b"'' || 2 || 3").unwrap(), b"2");
        assert_eq!(expression(b"'' && 2 && 3").unwrap(), b"");
        assert_eq!(expression(b"'' || 2 && 3").unwrap(), b"3");
        assert_eq!(expression(b"'' && 2 || 3").unwrap(), b"3");
        assert_eq!(expression(b"('' && 2) || 3").unwrap(), b"3");
        assert_eq!(expression(b"1 || ''").unwrap(), b"1");
        assert_eq!(expression(b"1 && ''").unwrap(), b"");
        assert_eq!(expression(b"1 || '' || 3").unwrap(), b"1");
        assert_eq!(expression(b"1 && '' && 3").unwrap(), b"");
        assert_eq!(expression(b"1 || '' && 3").unwrap(), b"1");
        assert_eq!(expression(b"1 && '' || 3").unwrap(), b"3");
        assert_eq!(expression(b"1 || 2 || ''").unwrap(), b"1");
        assert_eq!(expression(b"1 && 2 && ''").unwrap(), b"");
        assert_eq!(expression(b"1 || 2 && ''").unwrap(), b"1");
        assert_eq!(expression(b"1 && 2 || ''").unwrap(), b"2");
        assert_eq!(expression(b"'' || '' || 3").unwrap(), b"3");
        assert_eq!(expression(b"'' && '' && 3").unwrap(), b"");
        assert_eq!(expression(b"'' || '' && 3").unwrap(), b"");
        assert_eq!(expression(b"'' && '' || 3").unwrap(), b"3");
        assert_eq!(expression(b"('' && '') || 3").unwrap(), b"3");
        assert_eq!(expression(b"1 || '' || ''").unwrap(), b"1");
        assert_eq!(expression(b"1 && '' && ''").unwrap(), b"");
        assert_eq!(expression(b"1 || '' && ''").unwrap(), b"1");
        assert_eq!(expression(b"1 && '' || ''").unwrap(), b"");
        assert_eq!(expression(b"'' || 2 || ''").unwrap(), b"2");
        assert_eq!(expression(b"'' && 2 && ''").unwrap(), b"");
        assert_eq!(expression(b"'' || 2 && ''").unwrap(), b"");
        assert_eq!(expression(b"'' && 2 || ''").unwrap(), b"");
        assert_eq!(expression(b"('' && 2) || ''").unwrap(), b"");
        assert_eq!(expression(b"'' || '' || ''").unwrap(), b"");
        assert_eq!(expression(b"'' && '' && ''").unwrap(), b"");
        assert_eq!(expression(b"'' || '' && ''").unwrap(), b"");
        assert_eq!(expression(b"'' && '' || ''").unwrap(), b"");
        assert_eq!(expression(b"'' || 2").unwrap(), b"2");
        assert_eq!(expression(b"'' || (2)").unwrap(), b"2");
        assert_eq!(expression(b"'' || (1 && 2)").unwrap(), b"2");
        assert_eq!(expression(b"'' || ((eq 1 1) && 2)").unwrap(), b"2");
        assert_eq!(expression(b"'' || (eq 1 1 && 2)").unwrap(), b"2");
    }

    #[test]
    fn test_and_or_pipe() {
        assert_eq!(expression(b"1 | [0 _ 0]").unwrap(), b"010");
        assert_eq!(expression(b"1 | [0 _ 0]").unwrap(), b"010");
        assert_eq!(expression(b"1 || 2 | [0 _ 0]").unwrap(), b"010");
        assert_eq!(expression(b"1 && 2 | [0 _ 0]").unwrap(), b"020");
        assert_eq!(expression(b"1 || 2 || 3 | [0 _ 0]").unwrap(), b"010");
        assert_eq!(expression(b"1 && 2 && 3 | [0 _ 0]").unwrap(), b"030");
        assert_eq!(expression(b"1 || 2 && 3 | [0 _ 0]").unwrap(), b"010");
        assert_eq!(expression(b"1 && 2 || 3 | [0 _ 0]").unwrap(), b"020");
        assert_eq!(expression(b"'' || 2 || 3 | [0 _ 0]").unwrap(), b"020");
        assert_eq!(expression(b"'' && 2 && 3 | [0 _ 0]").unwrap(), b"00");
        assert_eq!(expression(b"'' || 2 && 3 | [0 _ 0]").unwrap(), b"030");
        assert_eq!(expression(b"'' && 2 || 3 | [0 _ 0]").unwrap(), b"030");
        assert_eq!(expression(b"1 || '' || 3 | [0 _ 0]").unwrap(), b"010");
        assert_eq!(expression(b"1 && '' && 3 | [0 _ 0]").unwrap(), b"00");
        assert_eq!(expression(b"1 || '' && 3 | [0 _ 0]").unwrap(), b"010");
        assert_eq!(expression(b"1 && '' || 3 | [0 _ 0]").unwrap(), b"030");
        assert_eq!(expression(b"1 || 2 || '' | [0 _ 0]").unwrap(), b"010");
        assert_eq!(expression(b"1 && 2 && '' | [0 _ 0]").unwrap(), b"00");
        assert_eq!(expression(b"1 || 2 && '' | [0 _ 0]").unwrap(), b"010");
        assert_eq!(expression(b"1 && 2 || '' | [0 _ 0]").unwrap(), b"020");
        assert_eq!(expression(b"'' || '' || 3 | [0 _ 0]").unwrap(), b"030");
        assert_eq!(expression(b"'' && '' && 3 | [0 _ 0]").unwrap(), b"00");
        assert_eq!(expression(b"'' || '' && 3 | [0 _ 0]").unwrap(), b"00");
        assert_eq!(expression(b"'' && '' || 3 | [0 _ 0]").unwrap(), b"030");
        assert_eq!(expression(b"1 || '' || '' | [0 _ 0]").unwrap(), b"010");
        assert_eq!(expression(b"1 && '' && '' | [0 _ 0]").unwrap(), b"00");
        assert_eq!(expression(b"1 || '' && '' | [0 _ 0]").unwrap(), b"010");
        assert_eq!(expression(b"1 && '' || '' | [0 _ 0]").unwrap(), b"00");
        assert_eq!(expression(b"'' || '' || '' | [0 _ 0]").unwrap(), b"00");
        assert_eq!(expression(b"'' && '' && '' | [0 _ 0]").unwrap(), b"00");
        assert_eq!(expression(b"'' || '' && '' | [0 _ 0]").unwrap(), b"00");
        assert_eq!(expression(b"'' && '' || '' | [0 _ 0]").unwrap(), b"00");
    }

    #[test]
    fn test_pipe_access() {
        let mcd = Value::Map(Map::default().with("c", "d"));
        let mbc = Value::Map(Map::default().with("b", mcd));
        let myz = Value::Map(Map::default().with("y", "z"));
        let mxy = Value::Map(Map::default().with("x", myz));
        let mut map = Map::default().with("a", mbc).with("", mxy);
        assert_eq!(template(b"{a}", &mut map).unwrap(), b"d");
        assert_eq!(template(b"{a.b}", &mut map).unwrap(), b"d");
        assert_eq!(template(b"{a | b}", &mut map).unwrap(), b"d");
        assert_eq!(template(b"{a | a}", &mut map).unwrap(), b"d");
        assert_eq!(template(b"{a | a.b}", &mut map).unwrap(), b"d");
        assert_eq!(template(b"{a | .a}", &mut map).unwrap(), b"d");
        assert_eq!(template(b"{.a | a}", &mut map).unwrap(), b"d");
        assert_eq!(template(b"{.a.b | .c}", &mut map).unwrap(), b"d");
        assert_eq!(template(b"{.}", &mut map).unwrap(), b"z");
        assert_eq!(template(b"{x}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{. | x}", &mut map).unwrap(), b"z");
        assert_eq!(template(b"{. | y}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{. | z}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{{f 1} | f}", &mut map).unwrap(), b"1");
        assert_eq!(template(b"{{a 1} | a}", &mut map).unwrap(), b"1");
        assert_eq!(template(b"{{f 1} | a}", &mut map).unwrap(), b"d");
    }

    #[test]
    fn test_list_index() {
        let list = Value::List(List::default().with("a").with("b"));
        let mut map = Map::default().with("list", list);
        assert_eq!(template(b"{list}", &mut map).unwrap(), b"ab");
        assert_eq!(template(b"{list.0}", &mut map).unwrap(), b"a");
        assert_eq!(template(b"{list.1}", &mut map).unwrap(), b"b");
        assert_eq!(template(b"{list.2}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{list.-1}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{list[-1]}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{list[0]}", &mut map).unwrap(), b"a");
        assert_eq!(template(b"{list[1]}", &mut map).unwrap(), b"b");
        assert_eq!(template(b"{list[2]}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{list(0)}", &mut map).unwrap(), b"a");
        assert_eq!(template(b"{list(1)}", &mut map).unwrap(), b"b");
        assert_eq!(template(b"{list(2)}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{list(-1)}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{list 1}", &mut map).unwrap(), b"ab1");
    }

    #[test]
    fn test_literal_list() {
        let mut map = Map::default();
        assert_eq!(template(b"{[]}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{[1]}", &mut map).unwrap(), b"1");
        assert_eq!(template(b"{[1 2]}", &mut map).unwrap(), b"12");
        assert_eq!(template(b"{[1 2 3]}", &mut map).unwrap(), b"123");
        assert_eq!(template(b"{[1 2] | [3 4]}", &mut map).unwrap(), b"34");
        assert_eq!(template(b"{[3 4].1}", &mut map).unwrap(), b"4");
        assert_eq!(template(b"{[3 4][1]}", &mut map).unwrap(), b"4");
        assert_eq!(template(b"{[3 4](1)}", &mut map).unwrap(), b"4");
        assert_eq!(template(b"{[1 2 3 4].a}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{['x' (x.y)].0}", &mut map).unwrap(), b"x");
        assert_eq!(template(b"{[3 4] [1]}", &mut map).unwrap(), b"341");
        assert_eq!(template(b"{[1] [2] [3]}", &mut map).unwrap(), b"123");
        assert_eq!(template(b"{[1] 2 [3]}", &mut map).unwrap(), b"123");
        assert_eq!(template(b"{1 [2] {a 3}}", &mut map).unwrap(), b"123");
    }

    #[test]
    fn test_literal_map() {
        let myz = Value::Map(Map::default().with("y", "z").with("a", "b"));
        let mut map = Map::default().with("x", myz);
        assert_eq!(template(b"{{}}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{{1 2}}", &mut map).unwrap(), b"2");
        assert_eq!(template(b"{{1 2 3 4}}", &mut map).unwrap(), b"24");
        assert_eq!(template(b"{{f x}}", &mut map).unwrap(), b"zb");
        assert_eq!(template(b"{{w (x.y)}}", &mut map).unwrap(), b"z");
        assert_eq!(template(b"{{w x.y}}", &mut map).unwrap(), b"z");
        assert_eq!(template(b"{{3 4}[3]}", &mut map).unwrap(), b"4");
        assert_eq!(template(b"{{3 4}[4]}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{{3 4}.3}", &mut map).unwrap(), b"4");
        assert_eq!(template(b"{{3 4}.1}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{{a 5}.a}", &mut map).unwrap(), b"5");
        assert_eq!(template(b"{{a 5}.b}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{{a {b 6}}.a.b}", &mut map).unwrap(), b"6");
        assert_eq!(template(b"{{1 2 3 4}.3}", &mut map).unwrap(), b"4");
        assert_eq!(template(b"{1&&{y (x.y)}.y}", &mut map).unwrap(), b"z");
        assert_eq!(template(b"{1&&{y (x.f)}.0}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{1&&{y (x.y)}.0}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{{f x.y}.f}", &mut map).unwrap(), b"z");
        assert_eq!(template(b"{{3 4} [3]}", &mut map).unwrap(), b"43");
        assert_eq!(template(b"{{3 4} {5 6}}", &mut map).unwrap(), b"46");
        assert_eq!(template(b"{{3 4} {5 6} 7}", &mut map).unwrap(), b"467");
    }

    #[test]
    fn test_list_comma() {
        let mut map = Map::default();
        assert_eq!(template(b"{[1,2]}", &mut map).unwrap(), b"12");
        assert_eq!(template(b"{[1, 2 ]}", &mut map).unwrap(), b"12");
        assert_eq!(template(b"{[1,2,3]}", &mut map).unwrap(), b"123");
        assert_eq!(template(b"{[1, 2 3]}", &mut map).unwrap(), b"123");
        assert_eq!(template(b"{[1, 2 3,4]}", &mut map).unwrap(), b"1234");
        assert_eq!(template(b"{[1,2]|length}", &mut map).unwrap(), b"2");
        assert_eq!(template(b"{[1, 2 ]|length}", &mut map).unwrap(), b"2");
        assert_eq!(template(b"{[1,2,3]|length}", &mut map).unwrap(), b"3");
        assert_eq!(template(b"{[1, 2 3]|length}", &mut map).unwrap(), b"3");
        assert_eq!(template(b"{[1, 2 3,4]|length}", &mut map).unwrap(), b"4");
        assert_eq!(template(b"{[1,2 ([3,4])]|length}", &mut map).unwrap(), b"3");
        assert_eq!(template(b"{[([2,3]),4]|length}", &mut map).unwrap(), b"2");
        assert_eq!(template(b"{[1 [2 [3]]]}", &mut map).unwrap(), b"123");
        assert_eq!(template(b"{[1,[2,[3]]]}", &mut map).unwrap(), b"123");
        assert!(template(b"{,}", &mut map).is_err());
        assert!(template(b"{,,}", &mut map).is_err());
        assert!(template(b"{, }", &mut map).is_err());
        assert!(template(b"{  ,}", &mut map).is_err());
        assert!(template(b"{,  ,}", &mut map).is_err());
        assert!(!template(b"{[,]}", &mut map).is_err());
        assert!(!template(b"{[,,]}", &mut map).is_err());
    }

    #[test]
    fn test_map_comma() {
        let mut map = Map::default();
        assert_eq!(template(b"{{,}}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{{,,}}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{{,,,}}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{{1}}}", &mut map).unwrap(), b"1}");
        assert_eq!(template(b"{{{1}}", &mut map).unwrap(), b"{{{1}}");
        assert_eq!(template(b"{{1}}", &mut map).unwrap(), b"1");
        assert_eq!(template(b"{{1,2}}", &mut map).unwrap(), b"12");
        assert_eq!(template(b"{{1,2 3}}", &mut map).unwrap(), b"13");
        assert_eq!(template(b"{{1,2 3,4}}", &mut map).unwrap(), b"134");
        assert_eq!(template(b"{{1}|length}", &mut map).unwrap(), b"1");
        assert_eq!(template(b"{{1 2}|length}", &mut map).unwrap(), b"1");
        assert_eq!(template(b"{{1:2}|length}", &mut map).unwrap(), b"1");
        assert_eq!(template(b"{{1,}|length}", &mut map).unwrap(), b"1");
        assert_eq!(template(b"{{1,2}|length}", &mut map).unwrap(), b"2");
        assert_eq!(template(b"{{1,2,3}|length}", &mut map).unwrap(), b"3");
        assert_eq!(template(b"{{1 {2 3}}}", &mut map).unwrap(), b"3");
        assert_eq!(template(b"{{1 {2,3}}}", &mut map).unwrap(), b"23");
        assert!(template(b"{{{1,2},3}}", &mut map).is_err());
        assert!(template(b"{{1,{2,3}}}", &mut map).is_err());
    }

    #[test]
    fn test_map_colon() {
        let mut map = Map::default();
        assert_eq!(template(b"{{a:1}}", &mut map).unwrap(), b"1");
        assert_eq!(template(b"{{a: 1}}", &mut map).unwrap(), b"1");
        assert_eq!(template(b"{{a: 1,}}", &mut map).unwrap(), b"1");
        assert_eq!(template(b"{{a:1,}}", &mut map).unwrap(), b"1");
        assert_eq!(template(b"{{a:1 2}}", &mut map).unwrap(), b"12");
        assert_eq!(template(b"{{a 1 b 2}}", &mut map).unwrap(), b"12");
        assert_eq!(template(b"{{a: 1 b 2}}", &mut map).unwrap(), b"12");
        assert_eq!(template(b"{{a: 1 b: 2}}", &mut map).unwrap(), b"12");
        assert_eq!(template(b"{{a:1 ,b:2}}", &mut map).unwrap(), b"12");
        assert_eq!(template(b"{{a:1, b:2}}", &mut map).unwrap(), b"12");
        assert_eq!(template(b"{{a:1 , b:2}}", &mut map).unwrap(), b"12");
        assert_eq!(template(b"{{a:1}|keys}", &mut map).unwrap(), b"a");
        assert_eq!(template(b"{{a: 1}|keys}", &mut map).unwrap(), b"a");
        assert!(template(b"{{a::1}}", &mut map).is_err());
        assert!(template(b"{{a:::2}}", &mut map).is_err());
        assert!(template(b"{{a:1 b::2 c:::3}}", &mut map).is_err());
        assert!(template(b"{:}", &mut map).is_err());
        assert!(template(b"{::}", &mut map).is_err());
        assert!(template(b"{:::}", &mut map).is_err());
        assert!(template(b"{{:}}", &mut map).is_err());
        assert!(template(b"{{::}}", &mut map).is_err());
        assert!(template(b"{{:::}}", &mut map).is_err());
        assert!(template(b"{{:{:}:}}", &mut map).is_err());
        assert!(template(b"{{2:}|length}", &mut map).is_err());
    }

    #[test]
    fn test_func_not() {
        let list = Value::List(List::default().with("").with("1"));
        let mut map = Map::default().with("list", list);
        assert_eq!(template(b"{not 0}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{not 1}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{not ''}", &mut map).unwrap(), b"true");
        assert_eq!(template(b"{not []}", &mut map).unwrap(), b"true");
        assert_eq!(template(b"{not [0]}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{not ['']}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{not (not '')}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{not (not 1)}", &mut map).unwrap(), b"true");
        assert_eq!(template(b"{not list.0}", &mut map).unwrap(), b"true");
        assert_eq!(template(b"{not list.1}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{not list.2}", &mut map).unwrap(), b"true");
        assert_eq!(template(b"{not (not list.0)}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{not (not list.1)}", &mut map).unwrap(), b"true");
        assert_eq!(template(b"{not (not list.2)}", &mut map).unwrap(), b"");
        assert!(template(b"{not}", &mut map).is_err());
        assert!(template(b"{not 1 2}", &mut map).is_err());
    }

    #[test]
    fn test_func_get() {
        let myz = Value::Map(Map::default().with("y", "z"));
        let mut map = Map::default().with("x", myz);
        assert_eq!(template(b"{get x.y}", &mut map).unwrap(), b"z");
        assert_eq!(template(b"{get x['y']}", &mut map).unwrap(), b"z");
        assert_eq!(template(b"{get x}", &mut map).unwrap(), b"z");
        assert_eq!(template(b"{get x.y.z}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{get a}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{get a.y}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{get a.y.z}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{get 'a'}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{get 'x'}", &mut map).unwrap(), b"z");
        assert_eq!(template(b"{get x || 1}", &mut map).unwrap(), b"z");
        assert_eq!(template(b"{get x && 1}", &mut map).unwrap(), b"1");
        assert_eq!(template(b"{true && 2}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{'true' && 2}", &mut map).unwrap(), b"2");
        assert_eq!(template(b"{'' && 2}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{get a || get x}", &mut map).unwrap(), b"z");
        assert_eq!(template(b"{get x || get a}", &mut map).unwrap(), b"z");
        assert_eq!(template(b"{get x && get a}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{get a && get x}", &mut map).unwrap(), b"");
    }

    #[test]
    fn test_func_set() {
        let mut map = Map::default();
        assert_eq!(template(b"{set x a}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{set y 'b'}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{set 'z' 'c'}", &mut map).unwrap(), b"");
        assert_eq!(map.get(b"x").cloned().unwrap().join(), b"");
        assert_eq!(map.get(b"y").cloned().unwrap().join(), b"b");
        assert_eq!(map.get(b"z").cloned().unwrap().join(), b"c");
        assert_eq!(map.get(b"_").cloned().map(Value::join), None);
        assert_eq!(template(b"{set ii 123}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{set jj \"123\"}", &mut map).unwrap(), b"");
        assert_eq!(map.get(b"ii").cloned().unwrap().join(), b"123");
        assert_eq!(map.get(b"jj").cloned().unwrap().join(), b"123");
        assert_eq!(template(b"{set a.b.c 321}", &mut map).unwrap(), b"");
        assert_eq!(map.get(b"a").cloned().unwrap().join(), b"321");
        assert_eq!(template(b"{set a['b']c 456}", &mut map).unwrap(), b"");
        assert_eq!(map.get(b"a").cloned().unwrap().join(), b"456");
        assert_eq!(template(b"{set a.b['c'] 789}", &mut map).unwrap(), b"");
        assert_eq!(map.get(b"a").cloned().unwrap().join(), b"789");
    }

    #[test]
    fn test_func_append() {
        let mut map = Map::default();
        assert_eq!(template(b"{12 | append 34}", &mut map).unwrap(), b"1234");
        assert_eq!(
            template(b"{[1 2] | append [3 4]}", &mut map).unwrap(),
            b"1234"
        );
    }

    #[test]
    fn test_func_trim() {
        let mut map = Map::default();
        assert_eq!(template(b"{trim ' '}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{trim '\n'}", &mut map).unwrap(), b"");
        assert_eq!(template(b"{trim ' \n\t\n '}", &mut map).unwrap(), b"");
    }

    #[test]
    fn test_template_value() {
        assert_eq!(eval_template_result("{.}"), Ok(b"".into()));
        assert_eq!(eval_template_result("{f}"), Ok(b"".into()));
        assert_eq!(eval_template_result("{1}"), Ok(b"1".into()));
        assert_eq!(eval_template_result("{'x'}"), Ok(b"x".into()));
    }

    #[test]
    fn test_keys_template() {
        assert_eq!(keys_template_ok("{.}"), keys("."));
        assert_eq!(keys_template_ok("{a}"), keys("a"));
        assert_eq!(keys_template_ok("{abc}"), keys("abc"));
        assert_eq!(keys_template_ok("{\"a b\"}"), keys("a b"));
        assert_eq!(keys_template_ok("{ b}"), keys("b"));
        assert_eq!(keys_template_ok("{ \n c\n# ok\n}"), keys("c"));
        assert_eq!(keys_template_ok("{1}"), keys("1"));
        assert_eq!(keys_template_ok("{'a'}"), keys("a"));
        assert_eq!(keys_template_ok("{a.b}"), keys("a.b"));
        assert_eq!(keys_template("{}").unwrap(), None);
        assert!(keys_template("{a b}").is_err());
    }

    #[test]
    fn test_keys_expression() {
        assert_eq!(keys_expression_ok("a"), keys("a"));
        assert_eq!(keys_expression_ok("ab"), keys("ab"));
        assert_eq!(keys_expression_ok("a_b"), keys("a_b"));
        assert_eq!(keys_expression_ok("a-b"), keys("a-b"));
        assert_eq!(keys_expression_ok(".a"), keys("a"));
        assert_eq!(keys_expression_ok("."), keys(""));
        assert_eq!(keys_expression_ok("true"), keys("true"));
        assert_eq!(keys_expression_ok("false"), keys("false"));
        assert_eq!(keys_expression_ok("0"), keys("0"));
        assert_eq!(keys_expression_ok("1"), keys("1"));
        assert_eq!(keys_expression_ok("-0"), keys("-0"));
        assert_eq!(keys_expression_ok("-1"), keys("-1"));
        assert_eq!(keys_expression_ok("a.b.c"), keys("a.b.c"));
        assert_eq!(keys_expression_ok("a[1]b"), keys("a.1.b"));
        assert_eq!(keys_expression_ok(".a[1]b"), keys("a.1.b"));
        assert_eq!(keys_expression_ok("(1).(2).(-3)"), keys("1.2.-3"));
        assert_eq!(keys_expression_ok("a[1]b"), keys("a.1.b"));
        assert_eq!(keys_expression_ok("a[1].x"), keys("a.1.x"));
        assert_eq!(keys_expression_ok("(\"a b\").(\"d e\")"), keys("a b.d e"));
        assert_eq!(keys_expression_ok("('a')('b').c"), keys("a.b.c"));
        assert_eq!(keys_expression_ok("-123a['b']321c"), keys("-123.a.b.321.c"));
        assert_eq!(keys_expression_ok("1.a"), keys("1.a"));
        assert_eq!(keys_expression_ok("-1.a"), keys("-1.a"));
        assert_eq!(keys_expression_ok("a.[1]"), keys("a..1"));
        assert_eq!(keys_expression_ok("1.2.3"), keys("1.2.3"));
        assert_eq!(keys_expression_ok("_"), keys("_"));
        assert_eq!(keys_expression_ok("_/"), keys("_/"));
        assert_eq!(keys_expression_ok("a/b"), keys("a/b"));
        assert!(keys_expression("").unwrap().is_none());
        assert!(keys_expression(" ").unwrap().is_none());
        assert!(keys_expression("'").is_err());
        assert!(keys_expression("\"").is_err());
        assert!(keys_expression("/").is_err());
        assert!(keys_expression("/a").is_err());
        assert!(keys_expression("]]").is_err());
        assert!(keys_expression("[']").is_err());
        assert!(keys_expression("[[").is_err());
        assert!(keys_expression("{{").is_err());
        assert!(keys_expression("[a]").is_err());
        assert!(keys_expression("[1]a").is_err());
        assert!(keys_expression("[]").is_err());
        assert!(keys_expression("()").is_err());
        assert!(keys_expression("{}").is_err());
        assert!(keys_expression("--").is_err());
    }

    #[test]
    fn test_list_value() {
        let map1 = Value::Map(Map::default().with("a", "b"));
        let map2 = Value::Map(Map::default().with("c", "d"));
        let value = &Value::List(List::default().with(map1).with(map2));
        let keys = keys_expression_ok("(1).c");
        assert_eq!(
            operation::get_value(value, keys.as_slice())
                .cloned()
                .map(Value::join),
            Some("d".into()),
        );
    }

    #[test]
    fn test_map_value() {
        let map1 = Value::Map(Map::default().with("b", "c"));
        let map2 = Value::Map(Map::default().with("a", map1));
        let keys = keys_expression_ok("a.b");
        assert_eq!(
            operation::get_value(&map2, keys.as_slice())
                .cloned()
                .map(Value::join),
            Some("c".into())
        );
    }

    #[test]
    fn test_map() {
        let map1 = Value::Map(Map::default().with("b", "c"));
        let map2 = Map::default().with("a", map1);
        let keys = keys_expression_ok("a.b");
        assert_eq!(
            operation::get_map_value(&map2, &keys).map(Value::join),
            Some("c".into())
        );
    }

    #[test]
    fn test_map_fold() {
        let value = Value::from("x");
        let k0 = keys_expression_ok(".");
        let k1 = keys_expression_ok("a");
        let k2 = keys_expression_ok("a.b");
        let k3 = keys_expression_ok("a.b.c");
        let m1 = map_with("b", "c");
        let mut m2 = map_with("a", Value::Map(m1));
        let m3 = map_with("b", "x");
        fold_map_value(&mut m2, &k2, value.clone());
        assert_eq!(get_map_value(&m2, &k0).map(Value::join), None);
        assert_eq!(get_map_value(&m2, &k1).map(Value::join), Some(m3.join()));
        assert_eq!(get_map_value(&m2, &k2).map(Value::join), Some(value.join()));
        assert_eq!(get_map_value(&m2, &k3).map(Value::join), None);
    }

    #[track_caller]
    fn eval_template_result(s: &str) -> Result<Vec<u8>, Error> {
        let adapter = adapter::Default::default();
        let results = super::eval_template(&adapter, &mut Map::default(), s.as_bytes());
        template::join(results).map(|e| e.result.join())
    }

    #[track_caller]
    fn keys_expression_ok(s: &str) -> Keys {
        keys_expression(s).unwrap().unwrap()
    }

    #[track_caller]
    fn keys_template_ok(s: &str) -> Keys {
        keys_template(s).unwrap().unwrap()
    }

    #[track_caller]
    fn keys_template(s: &str) -> Result<Option<Keys>, Error> {
        super::eval_keys_template(
            &adapter::Default::default(),
            &mut Map::default(),
            s.as_bytes(),
        )
        .map(|e| e.map(|e| e.result))
    }

    #[track_caller]
    fn keys_expression(s: &str) -> Result<Option<Keys>, Error> {
        super::eval_keys_expression(
            &adapter::Default::default(),
            &mut Map::default(),
            s.as_bytes(),
        )
        .map(|e| e.map(|e| e.result))
    }

    #[track_caller]
    fn template(s: &[u8], v: &mut Map) -> Result<Vec<u8>, Error> {
        Ok(super::eval_template(&adapter::Default::default(), v, s)
            .into_iter()
            .map(|e| e.result)
            .collect::<Result<Vec<_>, _>>()?
            .into_iter()
            .map(|e| e.result)
            .flat_map(Value::join)
            .collect())
    }

    #[track_caller]
    fn expression(e: &[u8]) -> Result<Vec<u8>, Error> {
        super::eval_expression(&adapter::Default::default(), &mut Map::default(), e)
            .map(|e| e.result)
            .map(Value::join)
    }

    #[track_caller]
    fn template_ok(s: &[u8]) -> Vec<u8> {
        template(s, &mut Map::default()).unwrap()
    }

    #[track_caller]
    fn template_err(s: &[u8]) -> Result<Vec<u8>, Error> {
        template(s, &mut Map::default())
    }

    #[track_caller]
    fn map_with<K: Into<Vec<u8>>, V: Into<Value>>(key: K, value: V) -> Map {
        Map::default().with(key.into(), value)
    }

    #[track_caller]
    fn keys(s: &str) -> Keys {
        Keys::parse(s.as_bytes())
    }
}