resl 0.1.0

A modern configuration and serialization language with variables, expressions, and dynamic runtime evaluation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

use winnow::{
    ModalResult, Parser,
    combinator::{cut_err, preceded, separated_pair},
};

use crate::{
    StatefulInput,
    expr::Expr,
    macros::{exp_char, label},
    state::{EvalState, FmtState},
    value::Value,
};

/// Ternary if-else expression.
#[derive(Debug, Clone)]
pub struct IfElse {
    if_expr: Box<Expr>,
    then_expr: Box<Expr>,
    else_expr: Box<Expr>,
}

impl IfElse {
    pub(crate) fn parse(input: &mut StatefulInput) -> ModalResult<Expr> {
        separated_pair(
            preceded('?', Expr::require_parse.map(Box::new)),
            cut_err(':').context(exp_char!(':')),
            separated_pair(
                Expr::require_parse.map(Box::new),
                cut_err('|').context(exp_char!('|')),
                Expr::require_parse.map(Box::new),
            ),
        )
        .context(label!("conditional expression"))
        .map(|(if_expr, (then_expr, else_expr))| Self {
            if_expr,
            then_expr,
            else_expr,
        })
        .map(Expr::IfElse)
        .parse_next(input)
    }

    pub(crate) fn evaluate(self, state: &mut EvalState) -> Value {
        match self.if_expr.evaluate(state) {
            Value::Boolean(bool) => match bool {
                true => self.then_expr.evaluate(state),
                false => self.else_expr.evaluate(state),
            },
            _ => Value::Null,
        }
    }

    pub(crate) fn format<W: std::fmt::Write>(
        &self,
        writer: &mut W,
        state: FmtState,
    ) -> std::fmt::Result {
        let pretty = state.pretty();

        write!(writer, "?")?;
        if pretty {
            write!(writer, " ")?;
        };

        self.if_expr.format(writer, state)?;

        write!(writer, ":")?;
        if pretty {
            write!(writer, " ")?;
        };

        self.then_expr.format(writer, state)?;

        write!(writer, "|")?;
        if pretty {
            write!(writer, " ")?;
        };

        self.else_expr.format(writer, state)?;
        Ok(())
    }
}