inpt 0.1.5

A derive crate for dumb type-level text parsing.
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

use inpt::split::{Line, Parenthetical};
use inpt::Inpt;

#[derive(Inpt, Debug)]
#[inpt(bounds = "")]
enum Term {
    Par(Parenthetical<Box<Equation>>),
    Lit(f64),
}

#[derive(Inpt, Debug)]
#[inpt(bounds = "")]
enum Equation {
    #[inpt(regex = r"-")]
    Neg(#[inpt(after)] Term),
    #[inpt(regex = r"\+")]
    Add(#[inpt(before)] Term, #[inpt(after)] Box<Equation>),
    #[inpt(regex = r"-")]
    Sub(#[inpt(before)] Term, #[inpt(after)] Box<Equation>),
    #[inpt(regex = r"\*")]
    Mul(#[inpt(before)] Term, #[inpt(after)] Box<Equation>),
    #[inpt(regex = r"/")]
    Div(#[inpt(before)] Term, #[inpt(after)] Box<Equation>),
    #[inpt(regex = r"\^")]
    Pow(#[inpt(before)] Term, #[inpt(after)] Term),
    Ter(Term),
}

impl Equation {
    fn value(self) -> f64 {
        fn v(term: Term) -> f64 {
            match term {
                Term::Par(x) => x.inner.value(),
                Term::Lit(x) => x,
            }
        }

        use Equation::*;
        match self {
            Neg(x) => -v(x),
            Add(a, b) => v(a) + b.value(),
            Sub(a, b) => v(a) - b.value(),
            Mul(a, b) => v(a) * b.value(),
            Div(a, b) => v(a) / b.value(),
            Pow(a, b) => v(a).powf(v(b)),
            Ter(x) => v(x),
        }
    }
}

#[inpt::main]
pub fn main(eqs: Vec<Line<Equation>>) {
    for Line { inner: eq } in eqs {
        println!("=  {}", eq.value())
    }
}