machine 0.0.1

compiler checked state machine development
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

/// State A    => {
///   tr1 => State B(x),
/// }
///
/// State B(x) => {
///   tr2 => State C
///   tr3 => State A
/// }
///
/// State C    => {
///   tr4 => State A
/// }
///
/// generates following interface


#[derive(PartialEq,Eq,Debug)]
pub struct SA;
#[derive(PartialEq,Eq,Debug)]
pub struct SB { b: u8 }
#[derive(PartialEq,Eq,Debug)]
pub struct SC;

#[derive(PartialEq,Eq,Debug)]
struct Machine<T> {
  state: T,
  counter: u8
}

impl<T> Machine<T> {
  pub fn cnt(&self) -> u8 {
    self.counter
  }
}

impl Machine<SA> {
  fn tr1(&self) -> Machine<SB> {
    println!("go to SB");
    return Machine {
      state: SB { b: 1 },
      counter: self.counter
    }
  }
}

impl Machine<SB> {
  fn tr2(&self) -> Machine<SC> {
    println!("go to SC");
    return Machine {
      state: SC,
      counter: 0
    }
  }

  fn tr3(&self) -> Machine<SA> {
    println!("go to SA");
    return Machine {
      state: SA,
      counter: 0
    }
  }
}

impl Machine<SC> {
  fn tr4(&self) -> Machine<SA> {
    println!("go to SA");
    return Machine {
      state: SA,
      counter: 0
    }
  }
}

fn main() {
  let m = Machine { state: SA, counter: 1 };
  let m = m.tr1();
  let m = m.tr2();
  let m = m.tr4();

  println!("counter: {}", m.cnt());
/*
  let m = Machine { state: SA };
  let m = m.tr1();
  let m = m.tr4();
*/
}