expy 0.0.2

Embeddable & extensible expression evaluator
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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

//! Evaluation errors.

use std::num::TryFromIntError;
use std::ops::Range;

use itertools::Itertools;
use thiserror::Error;

use crate::model::*;


/// Evaluation error.
#[derive(Debug, Error, PartialEq)]
pub enum Error {
    /// Name resolution error.
    #[error("unknown identifier: {ident}")]
    Name {
        ident: Ident,
    },

    /// Type mismatch.
    #[error(
        "type mismatch: expected {expected}; got ({actual})",
        expected = expected.iter().format_with(" or ", |sig, f| {
            f(&format_args!("({})", sig.iter().format(", ")))
        }),
        actual = actual.iter().format(", "),
    )]
    Type {
        expected: Vec<Vec<Type>>,
        actual: Vec<Type>,
    },

    /// Argument error.
    #[error("invalid argument {actual:?}, expected {expected}")]
    Argument {
        expected: String,  // message or description
        actual: Value,
    },

    /// Bounds error.
    #[error("index out of bounds: {actual} is not in {expected:?} range")]
    Bounds {
        expected: Range<usize>,
        actual: usize,
    },

    /// Conversion error.
    #[error("conversion error: {0}")]
    Conversion(ConversionError),  // no #[from], since it's covered by the manual impl below

    /// Custom error, typically from a user-defined function.
    #[error("custom error: {0}")]
    Custom(String),
}

impl Error {
    /// Construct a name error.
    pub fn name(ident: impl Into<Ident>) -> Self {
        Self::Name { ident: ident.into() }
    }

    /// Construct an argument error.
    pub fn argument(expected: impl Into<String>, actual: impl Into<Value>) -> Self {
        Self::Argument { expected: expected.into(), actual: actual.into() }
    }

    /// Construct a bounds error.
    pub fn bounds(expected: Range<usize>, actual: usize) -> Self {
        Self::Bounds { expected, actual }
    }

    /// Construct a custom error.
    pub fn custom(msg: impl Into<String>) -> Self {
        Self::Custom(msg.into())
    }

    /// Construct a type error.
    pub fn type_<E, S, A>(expected: E, actual: A) -> Self
        where E: IntoIterator<Item=S>, S: IntoIterator<Item=Type>,
              A: IntoIterator<Item=Type>
    {
        Self::Type {
            expected: expected.into_iter().map(|sig| sig.into_iter().collect()).collect(),
            actual: actual.into_iter().collect(),
        }
    }
}

impl<E> From<E> for Error
    where ConversionError: From<E>
{
    fn from(err: E) -> Self {
        Self::Conversion(err.into())
    }
}


// Conversion error.
#[derive(Debug, Error, Eq, PartialEq)]
pub enum ConversionError {
    #[error("conversion from integer failed: {0}")]
    FromInt(#[from] TryFromIntError),
}