हास्केल में नेस्टेड स्टेट्स

Question

मैं कुछ अलग तरह के राज्यों के साथ राज्य मशीनों के एक परिवार को परिभाषित करने की कोशिश कर रहा हूं। विशेष रूप से, अधिक "जटिल" राज्य मशीनों में राज्य होते हैं जो सरल राज्य मशीनों के राज्यों को मिलाकर बनते हैं।

(यह ऑब्जेक्ट ओरिएंटेड सेटिंग के समान है जहां किसी ऑब्जेक्ट में कई विशेषताएँ होती हैं जो ऑब्जेक्ट भी होती हैं।)

यहाँ एक सरल उदाहरण है कि मैं क्या हासिल करना चाहता हूँ।

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

अधिक आम तौर पर, मैं एक सामान्यीकृत ढांचा चाहता हूं जहां ये घोंसले अधिक जटिल हैं। यहाँ कुछ मैं जानना चाहता हूँ कि कैसे करना है।

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

---

संदर्भ के लिए, यह वही है जो मैं इस मशीनरी के साथ हासिल करना चाहता हूं:

मैं "स्ट्रीम ट्रांसफॉर्मर" नामक इन चीजों को डिजाइन करना चाहता हूं, जो मूल रूप से स्टेटफुल फ़ंक्शन हैं: वे टोकन का उपभोग करते हैं, अपनी आंतरिक स्थिति को म्यूट करते हैं और कुछ को आउटपुट करते हैं। विशेष रूप से, मुझे स्ट्रीम ट्रांसफ़ॉर्मर्स के एक वर्ग में दिलचस्पी है जहां आउटपुट एक बूलियन मूल्य है; हम इन्हें "मॉनिटर" कहेंगे।

अब, मैं इन ऑब्जेक्ट्स के लिए कॉम्बिनेटर डिजाइन करने का प्रयास कर रहा हूं। उनमें से कुछ हैं:

• एक preकंघी बनानेवाला। मान लीजिए कि monएक मॉनिटर है। फिर, pre monएक मॉनीटर है जो हमेशा Falseपहले टोकन के उपभोग के बाद पैदा होता है और फिर उसके व्यवहार की नकल करता है monजैसे कि पिछले टोकन को अब डाला जा रहा है। मैं के राज्य का मॉडल बनाना चाहते हैं pre monके साथ StateWithTriggerऊपर के बाद से नए राज्य मूल राज्य के साथ-साथ एक बूलियन है उदाहरण में।
• एक andकंघी बनानेवाला। मान लीजिए कि m1और m2मॉनिटर हैं। फिर, m1 `and` m2एक मॉनिटर है जो एम 1 को टोकन खिलाता है, और फिर एम 2 के लिए, और फिर उत्पादन करता है Trueयदि दोनों उत्तर सही थे। मैं के राज्य का मॉडल बनाना चाहते हैं m1 `and` m2के साथ CombinedStateऊपर के बाद से दोनों पर नज़र रखता है की राज्य बनाए रखा जाना चाहिए उदाहरण में।

Comments

FYI करें, _innerVal <$> getबस gets _innerVal(के रूप में gets f == liftM f get, और liftMसिर्फ fmapसाधुओं के लिए विशेष है)।

— ३० पर चेपनेर

आपको StateT InnerState m Intपहले स्थान पर कहाँ मूल्य मिल रहा है outerStateFoo?

— चेंपनर

क्या आप लेंस के साथ सहज हैं? यह उपयोग मामला ठीक वैसा ही प्रतीत होता है जैसा इसके zoomलिए है।

— कार्ल

@ कार्ल मैंने कुछ लेंस देखे हैं, लेकिन उन्हें बहुत अच्छी तरह से नहीं समझा। शायद आप एक उत्तर में बता सकते हैं कि ज़ूम का उपयोग कैसे करें?

— अग्निष्टोम चट्टोपाध्याय 18

अवलोकन: इस प्रविष्टि में एक भी प्रश्न नहीं है।

— शमौन शाइन

Answer 1

अपने पहले प्रश्न के लिए, कार्ल उल्लेख किया, zoomसे lensवास्तव में क्या करता है आप चाहते हैं। लेंस के साथ आपका कोड इस तरह लिखा जा सकता है:

{-# 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

संपादित करें: जब तक हम उस पर हैं, यदि आप पहले से ही ला रहे हैं lensतो innerStateFooऐसा लिखा जा सकता है:

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

Answer 2

संदर्भ के लिए, यह वही है जो मैं इस मशीनरी के साथ हासिल करना चाहता हूं:

मैं "स्ट्रीम ट्रांसफॉर्मर" नामक इन चीजों को डिजाइन करना चाहता हूं, जो मूल रूप से स्टेटफुल फ़ंक्शन हैं: वे टोकन का उपभोग करते हैं, अपनी आंतरिक स्थिति को म्यूट करते हैं और कुछ को आउटपुट करते हैं। विशेष रूप से, मुझे स्ट्रीम ट्रांसफ़ॉर्मर्स के एक वर्ग में दिलचस्पी है जहां आउटपुट एक बूलियन मूल्य है; हम इन्हें "मॉनिटर" कहेंगे।

मुझे लगता है कि आप जो हासिल करना चाहते हैं, उसके लिए बहुत ज्यादा मशीनरी की जरूरत नहीं है।

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)

यह आवश्यक रूप से स्टेटफुल StreamTransformerनहीं है , लेकिन स्टेटफुल को स्वीकार करता है। आपको (और IMO को नहीं चाहिए! ज्यादातर मामलों में !!) इन या (वास्तव में कभी भी!) को परिभाषित करने के लिए टाइपकास्ट के लिए पहुंचना चाहिए! लेकिन यह एक और विषय है)।

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)

Comments

यह बहुत अच्छा है, धन्यवाद! क्या इस पैटर्न को कुछ कहा जाता है?

— अग्निष्टोम चट्टोपाध्याय

मैं इसे केवल शुद्ध कार्यात्मक प्रोग्रामिंग कहूँगा! लेकिन मुझे पता है कि इस सवाल का जवाब आप देख रहे हैं नहीं है :) StreamTransformer वास्तव में एक "आटे मशीन" hackage.haskell.org/package/machines-0.7/docs/...

— अलेक्जेंडर Vieth

नहीं, पहला आउटपुट गायब हो रहा है जो मैंने इरादा नहीं किया है। मैं पहले आउटपुट को दूसरे के होने में देरी करना चाहूंगा ।

— अग्निष्टोम चट्टोपाध्याय

और इतने पर कि हर उत्पादन में एक कदम की देरी है? वह किया जा सकता है।

— अलेक्जेंडर विथ

बहुत अच्छा, पोस्ट करने के लिए धन्यवाद! (बिना ठीक से पढ़े पूर्व में टिप्पणी करने पर खेद है कि क्यू ठीक से पढ़ा गया है)। मुझे लगता है कि ओपी का मतलब था pre st = stateful (Nothing, st) k where k i (s,st) = let (o, st') = runStreamTransformer st i in ( maybe False id s , (Just o, st'))।

— विल नेस