[英]Recursive variable definitions in Python and F# (probably OCaml, too)
Given these F# type declarations... 给定这些F#类型声明...
type Message =
| MessageA
| MessageB
| MessageC
| MessageD
type State = {
Name:string
NextStateMap: Map<Message,State>
}
...is there an equally expressive definition of this specific state machine... 对这个特定状态机是否有同样表达的定义
let rec state0 = { Name = "0"; NextStateMap = Map.ofList [ (MessageA,state1); (MessageB,state2)] }
and state1 = { Name = "1"; NextStateMap = Map.ofList [ (MessageB,state3)] }
and state2 = { Name = "2"; NextStateMap = Map.ofList [ (MessageA,state3)] }
and state3 = { Name = "3"; NextStateMap = Map.ofList [ (MessageC,state4)] }
and state4 = { Name = "4"; NextStateMap = Map.ofList [ (MessageD,state5)] }
and state5 = { Name = "5"; NextStateMap = Map.empty}
...with Python? ...使用Python?
Note that via the "rec", we didn't have to do assignments in an order defined by a topological sort... (eg state0 is defined in terms of state1, even though state1 is defined later on). 请注意,通过“ rec”,我们不必按照拓扑排序定义的顺序进行分配...(例如,状态0是根据状态1定义的,即使状态1是稍后定义的)。
PS The option of using strings as state identifiers... PS使用字符串作为状态标识符的选项...
stateMachine = {
"0" : { "A":"1", "B":"2"},
"1" : { "B":"3" },
...
...leaves open the case of invalid keys (ie invalid message specifiers in the state machine). ...打开无效键的情况(即状态机中无效的消息说明符)。
In Python I think you'd define the states and then set the map. 在Python中,我认为您应该先定义状态,然后设置地图。 Pseudo-code like:
伪代码,例如:
state0 = State("0")
state1 = State("1")
... and so on ...
state0.next_states = {message_a: state1, message_b: state2 }
state1.next_states = {message_b: state3}
... and so on ...
## a generic state machine framework ###################
class Message(object):
"""
This represents a message being passed to the
state machine.
"""
def __init__(self, name):
self.name = name
def __str__(self):
return "Message(%r)" % self.name
def __call__(self, smap):
try:
return smap[self]
except KeyError:
raise Exception("invalid message: %s vs %s"
% (self, smap))
class MessageFactory(object):
"""
Since python doesn't have symbols, this automagically
creates the messages for you. (It's purely for
convenience, and you could just as easily instantiate
each message by hand.
"""
cache = {}
def __getattr__(self, name):
return self.cache.setdefault(name, Message(name))
class StateMachine(object):
"""
This keeps track of the state, of course. :)
"""
def __init__(self, state):
self.state = state
def __call__(self, msg):
self.state = self.state(msg)
## how to set it up: ###################################
msg = MessageFactory()
state =\
{
0 : lambda m: m({ msg.A : state[1],
msg.B : state[2] }),
1 : lambda m: m({ msg.B : state[3] }),
2 : lambda m: m({ msg.A : state[3] }),
3 : lambda m: m({ msg.C : state[4] }),
4 : lambda m: m({ msg.D : state[5] }),
5 : lambda m: m({ }),
}
## how to use it: ######################################
s = StateMachine(state[0])
s(msg.A)
assert s.state is state[1]
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.