Stany zagnieżdżone w Haskell

Próbuję zdefiniować rodzinę maszyn stanowych z nieco odmiennymi rodzajami stanów. W szczególności bardziej „złożone” maszyny stanów mają stany, które powstają przez połączenie stanów prostszych maszyn stanów.

(Jest to podobne do ustawienia obiektowego, w którym obiekt ma kilka atrybutów, które również są obiektami.)

Oto uproszczony przykład tego, co chcę osiągnąć.

data InnerState = MkInnerState { _innerVal :: Int }

data OuterState = MkOuterState { _outerTrigger :: Bool, _inner :: InnerState }

innerStateFoo :: Monad m => StateT InnerState m Int
innerStateFoo = do
  i <- _innerVal <$> get
  put $ MkInnerState (i + 1)
  return i

outerStateFoo :: Monad m =>  StateT OuterState m Int
outerStateFoo = do
  b <- _outerTrigger <$> get
  if b
    then
       undefined
       -- Here I want to "invoke" innerStateFoo
       -- which should work/mutate things
        -- "as expected" without
       -- having to know about the outerState it
       -- is wrapped in
    else
       return 666

Mówiąc bardziej ogólnie, chcę uogólnionego frameworka, w którym zagnieżdżenia te są bardziej złożone. Oto coś, co chcę wiedzieć, jak to zrobić.

class LegalState s

data StateLess

data StateWithTrigger where
  StateWithTrigger :: LegalState s => Bool -- if this trigger is `True`, I want to use
                                   -> s    -- this state machine
                                   -> StateWithTrigger

data CombinedState where
  CombinedState :: LegalState s => [s] -- Here is a list of state machines.
                                -> CombinedState -- The combinedstate state machine runs each of them

instance LegalState StateLess
instance LegalState StateWithTrigger
instance LegalState CombinedState

liftToTrigger :: Monad m, LegalState s => StateT s m o -> StateT StateWithTrigger m o
liftToCombine :: Monad m, LegalState s => [StateT s m o] -> StateT CombinedState m o

W kontekście chcę to osiągnąć dzięki tej maszynie:

Chcę zaprojektować te rzeczy o nazwie „Transformatory strumieniowe”, które są w zasadzie funkcjami stanowymi: zużywają token, mutują swój stan wewnętrzny i wysyłają coś. W szczególności interesuje mnie klasa transformatorów strumieniowych, w której dane wyjściowe są wartością logiczną; nazywamy te „monitorami”.

Teraz próbuję zaprojektować kombinatory dla tych obiektów. Niektórzy z nich są:

• preSyntezatora. Załóżmy, że monto monitor. Następnie pre monjest monitorem, który zawsze produkuje Falsepo zużyciu pierwszego tokena, a następnie naśladuje zachowanie montak, jakby poprzedni token był wstawiany teraz. Chciałbym modelować stan pre monz StateWithTriggerw powyższym przykładzie, ponieważ nowy stan jest wartością logiczną wraz ze stanem oryginalnym.
• andSyntezatora. Załóżmy, że m1i m2są monitory. Następnie m1 `and` m2jest monitorem, który podaje token do m1, a następnie do m2, a następnie generuje, Truejeśli obie odpowiedzi są prawdziwe. Chciałbym modelować stan m1 `and` m2z CombinedStatew powyższym przykładzie, ponieważ stan obu monitorów musi być utrzymany.

Na swoim pierwszym pytaniu, jak Carl wspomniano, zoomze lensrobi dokładnie to, co chcesz. Twój kod z soczewkami można zapisać w następujący sposób:

{-# LANGUAGE TemplateHaskell #-}

import Control.Lens
import Control.Monad.State.Lazy

newtype InnerState = MkInnerState { _innerVal :: Int }
  deriving (Eq, Ord, Read, Show)

data OuterState = MkOuterState
  { _outerTrigger :: Bool
  , _inner        :: InnerState
  } deriving (Eq, Ord, Read, Show)

makeLenses ''InnerState
makeLenses ''OuterState

innerStateFoo :: Monad m => StateT InnerState m Int
innerStateFoo = do
  i <- gets _innerVal
  put $ MkInnerState (i + 1)
  return i

outerStateFoo :: Monad m =>  StateT OuterState m Int
outerStateFoo = do
  b <- gets _outerTrigger
  if b
    then zoom inner $ innerStateFoo
    else pure 666

Edit: Skoro już jesteśmy przy nim, jeśli jesteś już przynosząc lensnastępnie innerStateFoomożna zapisać tak:

innerStateFoo :: Monad m => StateT InnerState m Int
innerStateFoo = innerVal <<+= 1

W kontekście chcę to osiągnąć dzięki tej maszynie:

Chcę zaprojektować te rzeczy o nazwie „Transformatory strumieniowe”, które są w zasadzie funkcjami stanowymi: zużywają token, mutują swój stan wewnętrzny i wysyłają coś. W szczególności interesuje mnie klasa transformatorów strumieniowych, w której dane wyjściowe są wartością logiczną; nazywamy te „monitorami”.

Myślę, że to, co chcesz osiągnąć, nie wymaga wiele maszyn.

newtype StreamTransformer input output = StreamTransformer
  { runStreamTransformer :: input -> (output, StreamTransformer input output)
  }

type Monitor input = StreamTransformer input Bool

pre :: Monitor input -> Monitor input
pre st = StreamTransformer $ \i ->
  -- NB: the first output of the stream transformer vanishes.
  -- Is that OK? Maybe this representation doesn't fit the spec?
  let (_, st') = runStreamTransformer st i
  in  (False, st')

and :: Monitor input -> Monitor input -> Monitor input
and left right = StreamTransformer $ \i ->
  let (bleft,  mleft)  = runStreamTransformer left  i
      (bright, mright) = runStreamTransformer right i
  in  (bleft && bright, mleft `and` mright)

To StreamTransformernie jest koniecznie stanowe, ale przyznaje te stanowe. Nie musisz (a IMO nie powinno! W większości przypadków !!) sięgać po typy, aby je zdefiniować (a nawet kiedykolwiek! :), ale to już inny temat).

notStateful :: StreamTransformer input ()
notStateful = StreamTransformer $ \_ -> ((), notStateful)

stateful :: s -> (input -> s -> (output, s)) -> StreamTransformer input output
stateful s k = StreamTransformer $ \input ->
  let (output, s') = k input s
  in  (output, stateful s' k)

alternateBool :: Monitor anything
alternateBool = stateful True $ \_ s -> (s, not s)