rain-lang 0.0.1

An implementation of an RVSDG in Rust with a concept of lifetimes
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

/*!
Rain graph errors and error handling
*/

use std::convert::Infallible;
use smallvec::SmallVec;
use crate::graph::region::WeakRegion;
use super::ValId;

/// A `rain` value error
#[derive(Debug, Clone)]
pub enum ValueError {
    /// A non-function value was applied in an S-expression
    NotAFunction(NotAFunction),
    /// Incomparable regions
    IncomparableRegions(IncomparableRegions),
    /// A region has already been fused
    RegionAlreadyFused(RegionAlreadyFused),
    /// Not implemented
    NotImplementedError
}

/// A `rain` region error
#[derive(Debug, Clone)]
pub enum RegionError {
    /// Incomparable regions
    IncomparableRegions(IncomparableRegions),
    /// A region has already been fused
    RegionAlreadyFused(RegionAlreadyFused)
}

impl From<RegionError> for ValueError {
    fn from(err: RegionError) -> ValueError {
        match err {
            RegionError::IncomparableRegions(i) => ValueError::IncomparableRegions(i),
            RegionError::RegionAlreadyFused(r) => ValueError::RegionAlreadyFused(r)
        }
    }
}

/// The size of a small set of incomparable regions
const SMALL_INCOMPARABLE_REGIONS: usize = 2;

/// Region already fused error
#[derive(Debug, Clone)]
pub struct RegionAlreadyFused;

impl From<Infallible> for RegionAlreadyFused {
    fn from(err: Infallible) -> RegionAlreadyFused { match err {} }
}
impl From<RegionAlreadyFused> for ValueError {
    fn from(err: RegionAlreadyFused) -> ValueError { ValueError::RegionAlreadyFused(err) }
}
impl From<RegionAlreadyFused> for RegionError {
    fn from(err: RegionAlreadyFused) -> RegionError { RegionError::RegionAlreadyFused(err) }
}

/// Incomparable region error
#[derive(Debug, Clone)]
pub struct IncomparableRegions(pub SmallVec<[WeakRegion; SMALL_INCOMPARABLE_REGIONS]>);

impl From<Infallible> for IncomparableRegions {
    fn from(err: Infallible) -> IncomparableRegions { match err {} }
}

/// A non-function value was applied in an S-expression
#[derive(Debug, Clone)]
pub struct NotAFunction {
    /// The value applied
    pub applied: Option<ValId>,
    /// The argument
    pub argument: Option<ValId>
}

impl From<Infallible> for ValueError { fn from(i: Infallible) -> ValueError { match i {} } }
impl From<NotAFunction> for ValueError {
    fn from(n: NotAFunction) -> ValueError { ValueError::NotAFunction(n) }
}
impl From<IncomparableRegions> for ValueError {
    fn from(i: IncomparableRegions) -> ValueError { ValueError::IncomparableRegions(i) }
}
impl From<IncomparableRegions> for RegionError {
    fn from(i: IncomparableRegions) -> RegionError { RegionError::IncomparableRegions(i) }
}