ripin 0.1.2

A library that handle Reverse Polish notated expressions, compiles, and evaluate them.
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

use std::convert::From;
use std::str::FromStr;
use convert_ref::TryFromRef;

/// Default variable keeping an index on an [`Indexable`] variable container.
/// Like a [`Vec`] or an [`HashMap`] for example.
///
/// [`Indexable`]: https://doc.rust-lang.org/std/ops/trait.Index.html
/// [`Vec`]: https://doc.rust-lang.org/std/vec/struct.Vec.html
/// [`hashMap`]: https://doc.rust-lang.org/nightly/std/collections/struct.HashMap.html
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub struct IndexVar(usize);

#[derive(Debug)]
pub enum VarIdxErr<'a, E> {
    InvalidVariableName(&'a str),
    ConvertErr(E),
}

impl<'a> TryFromRef<&'a str> for IndexVar {
    type Err = VarIdxErr<'a, <usize as FromStr>::Err>;

    fn try_from_ref(s: &&'a str) -> Result<Self, Self::Err> {
        match s.chars().next() {
            Some('$') => {
                match FromStr::from_str(&s[1..]) {
                    Ok(n) => Ok(IndexVar(n)),
                    Err(err) => Err(VarIdxErr::ConvertErr(err)),
                }
            }
            _ => Err(VarIdxErr::InvalidVariableName(s)),
        }
    }
}

impl From<IndexVar> for usize {
    fn from(var_idx: IndexVar) -> Self {
        var_idx.0
    }
}