Struct rubble_templates::evaluator::functions::FunctionWithAst

pub struct FunctionWithAst<F> where
    F: Fn(&dyn Evaluator, &[SyntaxNode], &mut Context) -> Result<String, SyntaxError>,  { /* fields omitted */ }

A wrapper for a Fn(&dyn Evaluator, &[SyntaxNode], &HashMap<String, String>) -> Result<String, SyntaxError>, to be used in Evaluator.

Example:

use rubble_templates::evaluator::{Evaluator, Function, SyntaxError, Context};
use rubble_templates::evaluator::ast::SyntaxNode;
use std::collections::HashMap;
use rubble_templates::template::Template;
use rubble_templates::compile_template_from_string;
use rubble_templates::evaluator::functions::FunctionWithAst;

fn plus_function(evaluator: &dyn Evaluator, parameters: &[SyntaxNode], context: &mut Context) -> Result<String, SyntaxError> {
    Ok(
        parameters.iter()
            .map(|node|
                evaluator.evaluate(node, context).unwrap().parse::<i32>().unwrap()
            )
            .sum::<i32>()
            .to_string()
    )
}

let mut functions: HashMap<String, Box<dyn Function>> = HashMap::new();
functions.insert("plus".to_string(), FunctionWithAst::new(plus_function)); // will be treated as Box<dyn Function>

let variables: HashMap<String, String> = HashMap::new();

let result = compile_template_from_string("2 + 2 = {{ plus 2 2 }}".to_string(), variables, functions);
assert_eq!(result.ok(), Some("2 + 2 = 4".to_string()));

Implementations

impl<F> FunctionWithAst<F> where
    F: Fn(&dyn Evaluator, &[SyntaxNode], &mut Context) -> Result<String, SyntaxError>, 

pub fn new(function: F) -> Box<FunctionWithAst<F>>

Trait Implementations

impl<F> Function for FunctionWithAst<F> where
    F: Fn(&dyn Evaluator, &[SyntaxNode], &mut Context) -> Result<String, SyntaxError>, 

fn evaluate(
    &self,
    evaluator: &dyn Evaluator,
    parameters: &[SyntaxNode],
    context: &mut Context
) -> Result<String, SyntaxError>