fairjax 0.1.0

Fair join pattern matching
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

use crate::analyse::groups::SubPatternGroups;
use crate::analyse::partition::Partitioning;
use crate::analyse::strategy::Strategy;
use crate::parse::context::Context;
use crate::parse::pattern::PatternDefinition;
use crate::parse::sub_pattern::SubPatternDefinition;
use proc_macro2::Span;
use syn::{Expr, Ident};

pub trait Definition {
    fn context(&self) -> Context;
    fn cases(&self) -> Vec<&dyn CaseBundle>;
}

impl Definition for crate::analyse::definition::JoinDefinition {
    fn context(&self) -> Context {
        self.context.clone()
    }

    fn cases(&self) -> Vec<&dyn CaseBundle> {
        self.cases.iter().map(|cb| cb as &dyn CaseBundle).collect()
    }
}

pub trait CaseBundle {
    fn case(&self) -> &dyn Case;
    fn strategy(&self) -> &Strategy;
    fn partitioning(&self) -> &Option<Partitioning>;
    fn sub_pattern_groups(&self) -> &SubPatternGroups;
    fn sub_pattern_at_index(&self, index: usize) -> &dyn SubPattern;
}

impl CaseBundle for crate::analyse::bundle::CaseBundleDefinition {
    fn case(&self) -> &dyn Case {
        &self.case as &dyn Case
    }

    fn strategy(&self) -> &Strategy {
        &self.strategy
    }

    fn partitioning(&self) -> &Option<Partitioning> {
        &self.partitioning
    }

    fn sub_pattern_groups(&self) -> &SubPatternGroups {
        &self.groups
    }

    fn sub_pattern_at_index(&self, index: usize) -> &dyn SubPattern {
        self.case
            .pattern
            .sub_patterns
            .get(index)
            .expect("index provided must be valid")
    }
}

pub trait Case {
    fn index(&self) -> usize;
    fn pattern(&self) -> &dyn Pattern;
    fn guard(&self) -> Option<Expr>;
    fn body(&self) -> Expr;
    fn span(&self) -> Span;
    fn ident_with_case_id(&self, name: &'static str) -> Ident;
}

impl Case for crate::parse::case::CaseDefinition {
    fn index(&self) -> usize {
        self.index
    }

    fn pattern(&self) -> &dyn Pattern {
        &self.pattern
    }

    fn guard(&self) -> Option<Expr> {
        self.guard.clone()
    }

    fn body(&self) -> Expr {
        self.body.clone()
    }

    fn span(&self) -> Span {
        self.span
    }
    fn ident_with_case_id(&self, name: &'static str) -> Ident {
        Ident::new(&format!("{}{}", name, self.index()), self.span())
    }
}

pub trait Pattern {
    fn sub_patterns(&self) -> Vec<&dyn SubPattern>;
    fn len(&self) -> usize;
    fn span(&self) -> Span;
}

impl Pattern for PatternDefinition {
    fn sub_patterns(&self) -> Vec<&dyn SubPattern> {
        self.sub_patterns
            .iter()
            .map(|sp| sp as &dyn SubPattern)
            .collect()
    }

    fn len(&self) -> usize {
        self.sub_patterns.len()
    }

    fn span(&self) -> Span {
        self.span
    }
}

pub trait SubPattern {
    fn get(&self) -> SubPatternDefinition;
    fn get_identifier(&self) -> &Ident;
}

impl SubPattern for SubPatternDefinition {
    fn get(&self) -> SubPatternDefinition {
        self.clone()
    }

    /// Get identifier that can be used to determine if two sub-patterns are of the same type.
    fn get_identifier(&self) -> &Ident {
        match self {
            SubPatternDefinition::Ident(ident) => &ident.ident,
            SubPatternDefinition::Path(p) => &p.path.segments.last().unwrap().ident,
            SubPatternDefinition::TupleStruct(p) => &p.path.segments.last().unwrap().ident,
            SubPatternDefinition::Struct(p) => &p.path.segments.last().unwrap().ident,
        }
    }
}