斯卡拉的一般有限状态机(传感器)

发布时间：2020-12-16 19:07:38 所属栏目：安全来源：网络整理

导读：在 Scala中实现有限状态机(或有限状态传感器)的一般方法是什么？我经常发现自己需要状态机实现.我的典型实现看起来像 object TypicalFSM { // actually — finite state transducer type State case object State1 extends State case object State2 extend

在 Scala中实现有限状态机(或有限状态传感器)的一般方法是什么？

我经常发现自己需要状态机实现.我的典型实现看起来像

object TypicalFSM { // actually — finite state transducer
  type State
  case object State1 extends State
  case object State2 extends State
  type Message
  case object Message1 extends Message
  type ResultMessage
  case object ResultMessage1 extends ResultMessage
}

import TypicalFSM._

class TypicalFSM extends ((Message) =>Seq[ResultMessage]){
  var state:State = State1

  def apply(message:Message):Seq[ResultMessage] = (state,message) match {
    case (State1,Message1) =>
      state = State2
      Seq(ResultMessage1,ResultMessage2)
  }
}

我不喜欢的是可变的var,这使得解决方案线程不安全. FSM拓扑结构也不清楚.

>如何以功能方式创建FSM？
>在.dot format绘制FSM图表也是非常好的
> Akka FSM有一个很好的属性允许将一些数据与一个状态相关联,不仅给出一个对象名称.这也是赞赏.
(但是,Akka FSM并不总是方便使用,因为它是异步的,有时候有点重.)

解决方法

这可能不是你想要的,但我认为这是一个有趣的概念.

object TypicalFSM {

  sealed trait State
  final class State1 extends State
  final class State2 extends State

  sealed trait Message
  case class Message1(s: String) extends Message
  case class Message2(s: String) extends Message

  sealed trait ResultMessage
  object ResultMessage1 extends ResultMessage
  object ResultMessage2 extends ResultMessage
}

import TypicalFSM._

case class Transformation[M <: Message,From <: State,To <: State](
    f:M => Seq[ResultMessage]) {

  def apply(m:M) = f(m)
}

object Transformation {

  implicit def `message1 in state1` =
    Transformation[Message1,State1,State2] { m =>
      Seq(ResultMessage1,ResultMessage2)
    }

  implicit def `message1 in state2` =
    Transformation[Message1,State2,State2] { m =>
      Seq(ResultMessage1)
    }

  implicit def `message2 in state2` =
    Transformation[Message2,State1] { m =>
      Seq(ResultMessage2)
    }
}

class TypicalFSM[CurrentState <: State] {

  def apply[M <: Message,NewState <: State](message: M)(
    implicit transformWith: Transformation[M,CurrentState,NewState]) = {

    this.asInstanceOf[TypicalFSM[NewState]] -> transformWith(message)
  }
}

用法就是这样的：

def test() = {
  val s1 = new TypicalFSM[State1]
  // type of s1: TypicalFSM[State1]

  val (s2,r1) = s1(Message1("m1"))
  // type of s2: TypicalFSM[State2]

  val (s3,r2) = s2(Message1("m1"))
  // type of s2: TypicalFSM[State2]

  val (s4,r3) = s2(Message2("m2"))
  // type of s2: TypicalFSM[State1]

  // val (s5,r4) = s4(Message2("m2"))
  // Fails with:
  // 'No transformation available for TypicalFSM.Message2 in TypicalFSM.State1'
  // type of s5: TypicalFSM[State1]
}

您的用例将强烈地确定此概念中代码的结构.用例真的确定了您要保留多少类型的信息.

我是这个概念,因为状态是使用类型系统,并且在编译时报告非法转换.

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!