Struct TemplateSystem

pub struct TemplateSystem<Parser, Query> { /* private fields */ }

Implementations

impl<Parser, Query> TemplateSystem<Parser, Query>

pub fn new(parser: Parser) -> Self

impl<'a, Parser, Query> TemplateSystem<Parser, Query>

where Parser: Parse<'a>,

pub fn lazy_parse( &'a self, text: &'a str, ) -> Template<LazyParseIter<'a, Parser>, Query>

Create a Template from a template string.

use lazy_template::{Template, simple_curly_braces};
let system = simple_curly_braces();
let template: Template<_, _> = system.lazy_parse("{name} is a {age} years old {gender}");
let output = template
    .to_string(|query| match query {
        "name" => Ok("Alice"),
        "age" => Ok("20"),
        "gender" => Ok("girl"),
        _ => Err(format!("Can't answer {query:?}")),
    })
    .unwrap();
assert_eq!(output, "Alice is a 20 years old girl");

Template only parses each segment just before it is needed, meaning that even a template with syntax error can produce a partial output:

let template_string = "{name} is a {age} years } old {gender})"; // incorrectly placed closing curly bracket
let mut output = String::new();
let error = lazy_template::simple_curly_braces()
    .lazy_parse(template_string)
    .write_to(&mut output, |query| match query {
        "name" => Ok("Alice"),
        "age" => Ok("20"),
        "gender" => Ok("girl"),
        _ => Err(format!("Can't answer {query:?}")),
    })
    .unwrap_err();
assert_eq!(output, "Alice is a 20 years "); // output is partially written

pub fn eager_parse<SegmentContainer>( &'a self, text: &'a str, ) -> Result<ParsedTemplate<SegmentContainer, Query>, Parser::Error>

where SegmentContainer: FromIterator<Parser::Output>,

Parse the template string ahead of time.

The returned parsed template can be used multiple times with different responders to generate different outputs:

let system = lazy_template::simple_curly_braces();
let parsed_template = system.eager_parse::<Vec<_>>("Hello, {name}!").unwrap();
let output = parsed_template
    .to_template()
    .to_string(|query| (query == "name").then_some("Alice").ok_or("Invalid query"))
    .unwrap();
assert_eq!(output, "Hello, Alice!");
let output = parsed_template
    .to_template()
    .to_string(|query| (query == "name").then_some("Bob").ok_or("Invalid query"))
    .unwrap();
assert_eq!(output, "Hello, Bob!");

Unlike lazy_parse, this function would fail if the template fails to parse (e.g. syntax error):

let template_string = "Hello, {name!"; // missing a closing curly bracket
let error = lazy_template::simple_curly_braces()
    .eager_parse::<Vec<_>>(template_string)
    .unwrap_err();

Trait Implementations

impl<Parser: Clone, Query: Clone> Clone for TemplateSystem<Parser, Query>

fn clone(&self) -> TemplateSystem<Parser, Query>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Parser: Debug, Query: Debug> Debug for TemplateSystem<Parser, Query>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<Parser: Copy, Query: Copy> Copy for TemplateSystem<Parser, Query>