python - 以静态类型语言实现干净且类型安全的状态机？

Question

我用 Python 实现了一个简单的状态机:

import time

def a():
    print "a()"
    return b

def b():
    print "b()"
    return c

def c():
    print "c()"
    return a


if __name__ == "__main__":
    state = a
    while True:
        state = state()
        time.sleep(1)

我想将它移植到 C，因为它不够快。但是 C 不允许我创建一个返回相同类型函数的函数。我尝试制作这种类型的函数:typedef *fn(fn)()，但它不起作用，所以我不得不使用结构来代替。现在代码很丑!

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

typedef struct fn {
    struct fn (*f)(void);
} fn_t;

fn_t a(void);
fn_t b(void);
fn_t c(void);

fn_t a(void)
{
    fn_t f = {b};

    (void)printf("a()\n");

    return f;
}

fn_t b(void)
{
    fn_t f = {c};

    (void)printf("b()\n");

    return f;
}

fn_t c(void)
{
    fn_t f = {a};

    (void)printf("c()\n");

    return f;
}

int main(void)
{
    fn_t state = {a};

    for(;; (void)sleep(1)) state = state.f();

    return EXIT_SUCCESS;
}

所以我认为这是 C 的类型系统损坏的问题。所以我使用了一种具有真实类型系统的语言(Haskell)，但同样的问题发生了。我不能只做这样的事情:

type Fn = IO Fn
a :: Fn
a = print "a()" >> return b
b :: Fn
b = print "b()" >> return c
c :: Fn
c = print "c()" >> return a

我收到错误，类型同义词声明中的循环。

所以我必须像对 C 代码那样做一些包装器:

import Control.Monad
import System.Posix

data Fn = Fn (IO Fn)

a :: IO Fn
a = print "a()" >> return (Fn b)

b :: IO Fn
b = print "b()" >> return (Fn c)

c :: IO Fn
c = print "c()" >> return (Fn a)

run = foldM (\(Fn f) () -> sleep 1 >> f) (Fn a) (repeat ())

为什么用静态类型语言制作状态机这么难？我还必须在静态类型语言中产生不必要的开销。动态类型语言没有这个问题。有没有更简单的方法来使用静态类型语言？

Answer 1

在 Haskell 中，这个习惯用法就是继续执行下一个状态:

type StateMachine = IO ()
a, b, c :: StateMachine
a = print "a()" >> b
b = print "b()" >> c
c = print "c()" >> a

您不必担心这会溢出堆栈或类似的东西。如果你坚持有状态，那么你应该使数据类型更明确:

data PossibleStates = A | B | C
type StateMachine = PossibleStates -> IO PossibleStates
machine A = print "a()" >> return B
machine B = print "b()" >> return C
machine C = print "c()" >> return A

然后，您可以获得关于任何忘记某些状态的 StateMachine 的编译器警告。