rush_pat 0.1.0

Core pattern matching engine for rush shell
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

use regex::Regex;
use subsume::{Subsumes, Subsumption};
use range::{Range};

#[derive(Debug, Clone)]
pub struct RegexEq(pub Regex);

#[derive(Debug, Clone, PartialEq)]
pub enum Pat {
    Tup(Vec<Pat>),
    ID(String),
    Str(String),
    StrList(Vec<String>),
    Wild(Vec<Pat>),
    Bind(String, Box<Pat>),
    Rng(Range),
    Rex(RegexEq),
}

impl Pat {
    pub fn get_id(&self) -> Option<&str> {
        use self::Pat::*;
        match *self {
            ID(ref s) => Some(s),
            _ => None,
        }
    }

    pub fn get_str(&self) -> Option<&str> {
        use self::Pat::*;
        match *self {
            Str(ref s) => Some(s),
            _ => None,
        }
    }

    pub fn get_atom(&self) -> Option<&str> {
        use self::Pat::*;
        match *self {
            ID(ref s) | Str(ref s) => Some(s),
            _ => None,
        }
    }

    pub fn is_wild(&self) -> bool {
        match *self {
            Pat::Wild(_) => true,
            _ => false,
        }
    }
}

impl PartialEq for RegexEq {
    fn eq(&self, other: &Self) -> bool {
        self.0.as_str() == other.0.as_str()
    }
}

impl Subsumes for Vec<Pat> {
    fn subsumes(&self, ov: &Self) -> Subsumption {
        use self::Subsumption::*;
        use self::Pat::*;

        let mut l = self.iter();
        let mut r = ov.iter();
        let mut ret = Same;
        loop {
            let lv = l.next();
            let rv = r.next();
            //println!("Iterate: {:?} ?? {:?}   ({:?})", lv, rv, ret);

            match (lv, rv) {
                (None, None) | (Some(&Wild(..)), None) | (None, Some(&Wild(..))) | (Some(&Wild(..)), Some(&Wild(..))) => return ret,
                (None, _) | (_, None) => return Disjoint,
                (Some(&Wild(..)), _) => return ret & Contains,
                (_, Some(&Wild(..))) => return ret & ContainedBy,
                (Some(lv), Some(rv)) => {
                    let sub = lv.subsumes(rv);
                    //println!("{:?} & {:?} {:?} {:?}", ret, lv, sub, rv);
                    ret &= sub;
                },
            }
        }
    }
}

impl Subsumes for Pat {
    fn subsumes(&self, other: &Pat) -> Subsumption {
        use self::Subsumption::*;
        use self::Pat::*;

        //println!("{:?} ?? {:?}", self, other);
        match (self, other) {
            (&Bind(_, ref sp), &Bind(_, ref op)) => (*sp).subsumes(&**op),
            (_, &Bind(_, ref op)) => self.subsumes(&**op),
            (&Bind(_, ref sp), _) => sp.subsumes(other),

            (&Wild(..), &Wild(..)) => Same,
            (&Wild(..), _) => Contains,
            (_, &Wild(..)) => ContainedBy,

            (&ID(_), &ID(_)) => Same,
            (&ID(_), _) => Contains,
            (_, &ID(_)) => ContainedBy,

            (&Str(ref ss), &Str(ref os)) => if ss == os { Same } else { Disjoint },
            (&Str(ref ss), &StrList(ref ol)) => ss.subsumes(ol),
            (&Str(ref ss), &Rng(ref or)) => ss.subsumes(or),
            (&Str(ref ss), &Rex(ref or)) => ss.subsumes(&or.0),

            (&StrList(ref sl), &StrList(ref ol)) => sl.subsumes(ol),

            (&StrList(ref sl), &Rng(ref or)) => sl.subsumes(or),
            (&StrList(ref sl), &Rex(ref or)) => sl.subsumes(&or.0),
            (&StrList(_), _) => other.subsumes(self).reverse(),

            (&Rng(ref sr), &Rng(ref or)) => sr.subsumes(or),
            (&Rng(ref _sr), &Rex(ref _or)) => Overlaps, // TODO
            (&Rng(_), _) => other.subsumes(self).reverse(),

            (&Rex(ref _sr), &Rex(ref _or)) => Overlaps, // TODO
            (&Rex(_), _) => other.subsumes(self).reverse(),

            (&Tup(ref sv), &Tup(ref ov)) => { sv.subsumes(ov) },

            //(&Tup(ref sv), _) => if sv.len() == 1 { sv[0].subsumes(other) } else { Disjoint },
            (&Tup(_), _) => Disjoint,
            (_, &Tup(_)) => other.subsumes(self).reverse(),
        }
    }
}

#[macro_export]
macro_rules! mk_pat {
    ( ($($x:tt),*) ) => ( Pat::Tup(vec![$(mk_pat!($x)),*]) );
    ( [$($x:tt),*] ) => ( Pat::Wild(vec![$(mk_pat!($x)),*]) );
    ( ... ) => ( Pat::Wild(vec![]) );
    ( {$x:ident = $y:tt} ) => ( Pat::Bind(stringify!($x).to_string(), Box::new(mk_pat!($y))) );
    ( {$x:ident} ) => ( Pat::ID(stringify!($x).to_string()) );
    ( $x:tt ) => ( Pat::Str(stringify!($x).trim_matches('"').to_string()) );
}