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

use std::hash::Hash;

/// Input character validator
pub type Predicate = fn(ch: char) -> bool;

/// Transition to next state which is validated by condition
pub struct Transition<State, Effect> 
    where State: Eq + PartialEq + Copy,
          Effect: Copy
{
    /// Predicate that validates current character of stream.
    /// If None then transition is unconditional (i.e. succeeds for every input character)
    pub condition: Option<Predicate>,
    /// Next state
    pub to: State,
    /// Side effect that is generated after successful validation of transition
    /// If None then no effect is generated
    pub effect: Option<Effect>
}

/// Pair of states ("from", "to")
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
pub struct StatesConnection<State> 
    where State: Eq + PartialEq + Copy + Hash,
{
    pub from: State,
    pub to: State
}

impl<State, Effect> Transition<State, Effect> 
    where State: Eq + PartialEq + Copy,
          Effect: Copy
{
    /// Creates new transition
    /// - to: next state,
    /// - condition: predicate for character,
    /// - effect: side effect
    pub fn new(to: State, condition: Option<Predicate>, effect: Option<Effect>) -> Self {
        Self {
            to,
            condition,
            effect
        }
    }

    /// Matches next state and side effect for current character
    /// - ch: current character (of stream) 
    pub fn transit(&self, ch: char) -> (Option<State>, Option<Effect>) {
        match self.condition {
            Some(condition) => {
                if condition(ch) {
                    (Some(self.to), self.effect)
                } else {
                    (None, None)
                }
            },
            None => (Some(self.to), self.effect)
        }
    }
}

/// Information for debugging and effects
#[derive(Copy, Clone, Debug)]
pub struct StreamData<'a> {
    /// Reference to input string
    pub string: &'a String,
    /// Current character position in input string
    pub index: usize,
    /// Current character in input string
    pub character: char
}

/// Generic type for executor of side effects 
/// applied to some persistent data
pub trait Effector<Effect> 
    where Effect: Copy
{
    /// Applies side effect to mutate some data
    /// - effect: side effect,
    /// - input_data: additional dependencies for effects
    fn dispatch(&mut self, effect: Effect, input_data: StreamData);
}