State Machines in Rust

Post by mettamage » Wed, Apr 01, 2020, 10:32 AM UTC

Ygg2 wrote: post #15

mettamage wrote: post #8

Advocating for programmer ergonomics is always a good thing. And I think more people should advocate and try to design languages in such a way that the way of programming more closely resembles the actual real thing [1, 2]. As you might recall in cognitive psychology there's a specific idea that translating a problem to a more recognizable problem (or simply changing the symbols) is a good thing [3]. Having less work…

While I love Bret's work I don't think that's scalable. If you can simulate time axis, it means it can simulate only systems that can are hundreds of times smaller than system resource. E.g. can you simulate a Kubernetes swarm with thousands of different settings? It's a great learning tool, but not much else.

Post by derkha » Wed, Apr 01, 2020, 10:38 AM UTC

m90 wrote: post #22

Slightly OT, but: > In Germany traffic lights go green -> yellow -> red -> yellow -> green, but let's pretend they're only green -> yellow -> red -> green. is not correct if I'm not missing something major. Is there any situation where they turn yellow before turning green?

Post by TimNN » Wed, Apr 01, 2020, 10:39 AM UTC

m90 wrote: post #22

Slightly OT, but: > In Germany traffic lights go green -> yellow -> red -> yellow -> green, but let's pretend they're only green -> yellow -> red -> green. is not correct if I'm not missing something major. Is there any situation where they turn yellow before turning green?

Post by Arnavion » Wed, Apr 01, 2020, 10:49 AM UTC

logicchains wrote: post #16

C++20 supports enums as non-type template parameters, so I think it'd be possible to do it with enums there. Something like: enum class Color{Green, Yellow, Red}; template struct State{}; auto newState() -> State {...}; auto next(State ) -> State {...} auto next(State ) -> State {...} auto next(State ) -> State {...} int main(){ const auto state = newState(); // Green const auto state = next(state); // Yellow const a…

    #![feature(const_generics)]
    
    #[derive(PartialEq, Eq)] // enums used as const generics must be Eq
    enum Color { Green, Yellow, Red }
    
    struct State;
    
    impl State { fn next(self) -> State { State } }
    impl std::fmt::Debug for State { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { f.write_str("green") } }
    
    impl State { fn next(self) -> State { State } }
    impl std::fmt::Debug for State { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { f.write_str("yellow") } }
    
    impl State { fn next(self) -> State { State } }
    impl std::fmt::Debug for State { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { f.write_str("red") } }
    
    impl State { fn new() -> Self { State } }
    
    fn main() {
        let state = dbg!(State::::new());
        let state = dbg!(state.next());
        let state = dbg!(state.next());
        let state = dbg!(state.next());
    }

    [src/main.rs:20] State::::new() = green
    [src/main.rs:21] state.next() = yellow
    [src/main.rs:22] state.next() = red
    [src/main.rs:23] state.next() = green

Post by [deleted] » Wed, Apr 01, 2020, 10:52 AM UTC

Dowwie wrote: post #24

juskrey wrote: post #4

Once upon a time I have implemented POP3 server protocol state machine in Clojure. 180 lines in total, of which 40 were FSM declaration, 140 command handling functions. Not sure I'll ever want to approach FSM in any other language, unless no other choice.

Did you iterate to a FSM solution, from many nested conditions, or use it right from the start? I'm fighting the urge to write any FSM without having the absolute certainty that it is needed. There seems no other way than by refactoring to an FSM.