Czy istnieje język programowania z wbudowaną konstrukcją maszyny stanowej?

Jest nowy język maszyn stanowych oparty na XML W3C o nazwie SCXML , oparty na formalizmie StateChart Davida Harela (który obsługuje hierarchiczne i równoległe maszyny stanowe).

Apache Commons ma implementację SCXML opartą na Javie:

Commons SCXML to implementacja mająca na celu stworzenie i utrzymanie Java scxml engine zdolnego do wykonywania maszyny stanowej zdefiniowanej za pomocą dokumentu SCXML, przy jednoczesnym wyodrębnieniu środowiska interfejsy.

SMC jest kompilatorem prostego języka specyficznego dla domeny, który generuje maszyny stanowe dla wielu popularnych języków. Używałem go do generowania utrzymywalnych maszyn stanowych dla wielu różnych rzeczy, takich jak złożone interfejsy użytkownika i niestandardowe protokoły sieciowe.

OTP Erlanga wspiera konstrukcje maszyn stanowych poprzez 'gen_fsm'. Minęło kilka lat od ostatniego spojrzenia na to, więc jestem trochę zardzewiały, ale możesz wygooglować dla "Erlang gen_fsm" i znaleźć mnóstwo materiałów referencyjnych

Nie do końca, ale istnieje moduł maszyny stanowej dla Pythona, który pozwala używać dekoratorów do obsługi implementacji kart stanu w stylu Harel, w tym kontekstów z wieloma stanami, zagnieżdżania podstat z historią i bez niej. Kod kończy się wyglądem jak poniżej. Moduł znajduje się w http://wiki.python.org/moin/State%20Machine%20via%20Decorators

 #!/bin/env/python
"""
This example now works. The state pattern module
allows defining states which are their their own context for 
implementing substates.  Substate Medium (class Medium) shows this here.
"""
"""
Example with 5 buttons. Two ,'up','down' cause state to rotate among the
several states.  The other three, bx,by,bz, invoke state dependent behavior.

Switching into a state causes the labels of the three buttons bx,by,bz to
change.  Pressing one of the buttons causes associated text to appear in
corresponding static text box. An 'onEnter' method changes the text.
"""
import wx
import DecoratorStateMachine as dsm

class MyFrame(wx.Frame, dsm.ContextBase):

   xtable = dsm.TransitionTable('pstate')


   def __init__(self):
      MyFrame.xtable.initialize(self)

      wx.Frame.__init__(self, None, -1, "My Frame", size=(470,220))

      family = wx.SWISS
      style = wx.NORMAL
      weight = wx.BOLD
      font = wx.Font(11,family,style,weight, False, "Verdana")
      self.SetFont(font)

      panel = wx.Panel(self, -1)

      b = wx.Button(panel, -1, "Up", pos=(50,20), size=(80,35))
      self.Bind(wx.EVT_BUTTON, self.OnUp, b)
      b.SetDefault()

      b = wx.Button(panel, -1, "Down", pos=(50,60), size=(80,35))
      self.Bind(wx.EVT_BUTTON, self.OnDown, b)

      self.bx = wx.Button(panel, -1, "xxx", pos=(50,100), size=(110,35))
      self.Bind(wx.EVT_BUTTON, self.OnBA, self.bx)
      self.tx = wx.StaticText(panel, -1, "", pos=(50,140), size=(110,35))

      self.by = wx.Button(panel, -1, "yyy", pos=(180,100), size=(110,35))
      self.Bind(wx.EVT_BUTTON, self.OnBB, self.by)
      self.ty = wx.StaticText(panel, -1, "", pos=(180,140), size=(110,35))

      self.bz = wx.Button(panel, -1, "zzz", pos=(310,100), size=(110,35))
      self.Bind(wx.EVT_BUTTON, self.OnBC, self.bz )
      self.tz = wx.StaticText(panel, -1, "", pos=(310,140), size=(110,35))


   @dsm.transition(xtable)
   def OnUp(self, event):
      pass

   @dsm.transition(xtable)
   def OnDown(self, event):
      pass

   @dsm.event(xtable)
   def OnBA(self, event):
      pass

   @dsm.event(xtable)
   def OnBB(self, event):
      pass

   @dsm.event(xtable)
   def OnBC(self, event):
      self.tz.SetLabel("Bossy")


class Off(MyFrame):
   "This is state Off "

   def onEnter(self):
      self.bx.SetLabel("Chase")
      self.by.SetLabel("Onry")
      self.bz.SetLabel("Cow")

   def OnBA(self, event):
      self.tx.SetLabel("Chase the")

   def OnBB(self, event):
      self.ty.SetLabel("Onry")


class Low(MyFrame):
   "This is state Low "
   items = ["Walk", "Green", "Llama"]

    def onEnter(self):
      self.bx.SetLabel(self.items[0])
      self.by.SetLabel(self.items[1])
      self.bz.SetLabel(self.items[2])

   def OnBA(self, event):
      self.tx.SetLabel("Walk the ")

   def OnBB(self, event):
      self.ty.SetLabel(self.items[1])

   def OnBC(self, event):
      self.tz.SetLabel(self.items[2])


class Medium(MyFrame):
   "This is state Medium "
   ytable = dsm.TransitionTable('qstate')

   def onEnter(self):
      if not hasattr(self, 'qstate'):    #unconditionally initialize for no history
         self.ytable.initialize(self)
      self.doEnter()

   @dsm.event(ytable)
   def doEnter(): pass

   @dsm.transitionevent(ytable)
   def OnBA(self, event):
      pass

   @dsm.transitionevent(ytable)
   def OnBB(self, event):
      pass

   @dsm.transitionevent(ytable)
   def OnBC(self, event):
      pass


class High(Low):
   "This is state High "

   items = ["Pet","Tame", "Dog"]

   def OnBA(self, event):
      self.tx.SetLabel("Pet his")

class MedBlue(Medium):
   """State med blu"""

   items = ["Med BLue","Checkered", "Tractor"]

   def onEnter(self):
      self.bx.SetLabel(self.items[0])
      self.by.SetLabel(self.items[1])
      self.bz.SetLabel(self.items[2])

   def doEnter(self):
      self.onEnter()

   def OnBA(self, event):
      self.tx.SetLabel("Med Blue")
   def OnBB(self, event):
      self.ty.SetLabel("Chekered")
   def OnBC(self, event):
      self.tz.SetLabel("Tractor")


class MedRed(Medium):
   """State med red"""

   items = ["Med Red","Striped", "Combine"]

   def onEnter(self):
      self.bx.SetLabel(self.items[0])
      self.by.SetLabel(self.items[1])
      self.bz.SetLabel(self.items[2])

   def doEnter(self):
      self.onEnter()

   def OnBA(self, event):
      self.tx.SetLabel("Med Red")
   def OnBB(self, event):
      self.ty.SetLabel("Striped")
   def OnBC(self, event):
      self.tz.SetLabel("Combine")


MyFrame.xtable.nextStates(Low, (Medium,Off))
MyFrame.xtable.nextStates(Medium, (High,Low))
MyFrame.xtable.nextStates(High, (Off,Medium))
MyFrame.xtable.nextStates(Off, (Low,High))
MyFrame.xtable.initialstate = Off

Medium.ytable.nextStates(MedBlue, (MedBlue, MedRed, MedRed))
Medium.ytable.nextStates(MedRed,  (MedBlue, MedBlue, MedRed))
Medium.ytable.initialstate = MedBlue


if __name__=='__main__':
   app = wx.PySimpleApp()
   frame = MyFrame()
   frame.Show(True)
   app.MainLoop()

Język programowania Plaid wprowadza " Programowanie Typestate-Oriented, paradygmat, który rozszerza programowanie obiektowe z typestates."

Oto doc: http://www.cs.cmu.edu / ~ aldrich /

Np:

state File {
    public final String filename;
}

state OpenFile extends File {
    private CFilePtr filePtr;
    public int read() { ... }
    public void close() [OpenFile>>ClosedFile]
        { ... }
}

state ClosedFile extends File {
    public void open() [ClosedFile>>OpenFile]
        { ... }
}

Właśnie znalazłem jeden: AsmL (Abstract State Machine Language) .
Oto strona z Więcej informacji na jej temat w CodePlex.

Dość interesujące, jest rozwijany przez Microsoft.

W C# Iteratory (z 'Yield return' i 'Yield break') są konstrukcją języka, która bezpośrednio przekłada się na maszyny stanowe. Nigdy nie używałem go jako takiego, ale myślę, że może być użyteczny w praktyce.

Pojawia się pytanie o stackoverflow tutaj . Najwyżej głosowana odpowiedź zniechęca go jednak ...

Oprócz Ragela istnieje ciekawy technicznie, ale dość niejasny język zwany SL1. Zobacz http://ieeexplore.ieee.org/xpl/freeabs_all.jsp?arnumber=1095580 został stworzony przez Iskratel w Słowenii w celu rozwoju systemów telekomunikacyjnych, w których Maszyny państwowe są podstawowymi blokami.

Sriram Krishnamurthy ma raport i artykuł na temat używania makr do dodawania wbudowanego podjęzyka dla automatów do schematu. Nie jestem jednak pewien, czy jakieś Schematy zawierają jego makra jako standardową bibliotekę.

Microsoft Research opublikował niedawno język P na Githubie. Mają również Framework PSharp, który zapewnia bibliotekę rozszerzeń C# i składnię wysokiego poziomu z kompilatorem dla języka.

Oto fragment z jednego z ich przykładów dla rozszerzeń C#:

internal class Server : Machine
{
    MachineId Client;

    [Start]
    [OnEntry(nameof(InitOnEntry))]
    class Init : MachineState { }

    void InitOnEntry()
    {
        ...
        this.Goto(typeof(Active));
    }

    ...

Oto część składni wysokiego poziomu:

using System;

namespace TheStateMachine
{
  internal machine Client
  {
    private machine Server;
    private start state Init
    {
      entry
      {
        this.Server = (trigger as Config).target;
        jump(Playing);
      }
    }

    private state Playing
    {
      entry
      {
        //execute logic
      }
      on AnotherEvent goto AnotherState;
      on SomeEvent do ProcessSomeLogic;
    }

  ...

Jestem prawie dekadę spóźniony na imprezę, ale ostatnio natknąłem się na niejasny język, który zapożycza pomysły z FSMs o nazwie Hume

Nie jestem pewien, czy jest nadal aktywnie utrzymywany, ale możesz przynajmniej pobrać kompilator i pobawić się nim. Informacje są trudne do zdobycia, ale jest kilka gazet i artykułów online, które pokazują najważniejsze.