스칼라의 일반적인 유한 상태 기계 (변환기)

Question

스칼라에서 유한 상태 기계 (또는 유한 상태 변환기)를 구현하는 일반적인 방법은 무엇입니까?

종종 나는 상태 머신 구현을 필요로합니다. 내가 싫어하는 것은 솔루션 스레드가 안전하지 않은하게 변경할 수 var입니다

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) 
    } 
} 

처럼 내 전형적인 구현 보인다. 또한 FSM 토폴로지가 명확하지 않습니다.

1. FSM을 기능적으로 만드는 방법은 무엇입니까?

2. 또한 아주 좋은 것은 .dot format

3. Akka FSM뿐만 아니라 객체 이름을주는 국가로 일부 데이터를 연결할 수의 좋은 특성을 가지고에 FSM-그래프를 그립니다. 이것도 인정합니다. 이 당신을 위해 무엇을 찾고있는 아마하지

Answer 1

(가끔 조금 무거운 무게 비동기 및 그러나, 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, State2, 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] 
} 

사용 사례가 강력하게이 개념의 코드의 구조를 결정한다. 유스 케이스는 얼마나 많은 유형 정보를 유지할지 결정합니다.

이 개념은 형식 시스템을 사용하여 상태가 유지되고 컴파일 타임에 불법적 인 전환이보고되기 때문에이 개념입니다.