Equivalente funzionale del modello di progettazione stato

Question

Quale sarebbe l'equivalente di programmazione funzionale del modello di progettazione stato? O più concretamente, in che modo lo this Wikipedia example di pattern di progettazione dello stato verrà convertito in FP?

Answer 1

Forse con una monade State combinata con modificatori e accessori personalizzati?

Answer 2

Non penso che ci sia un equivalente funzionale puro per il modello di stato. Perché la pura programmazione funzionale non ha il concetto di stato e tempo. Lo schema di stato riguarda intrinsecamente lo stato e il tempo. Ma penso che esista un equivalente funzionale non puro, è un flusso infinito e pigro valutato. Puoi implementarlo con resa C#.

Answer 3

Questo modello è un esempio dell'uso dello State monad, un ambiente computazionale che aumenta il codice con stato.

Ecco un'implementazione in Haskell.

Alcuni aiutanti:

import Control.Monad.Trans.State 
import Control.Monad.IO.Class 
import Data.Char 

le due modalità di funzionamento del programma

data Mode = A | B 

Il tipo di computazioni stateful con questa modalità, aumentata con un contatore.

type StateM a = StateT (Int, Mode) IO a 

La funzione di scrittura, una funzione nel contesto econom, cambia il suo comportamento in base alla modalità stateful:

writeName :: String -> StateM() 
writeName s = do 
    (n,mode) <- get 
    case mode of 
     A -> do liftIO (putStrLn (map toLower s)) 
       put (0,B) 
     B -> do let n' = n + 1 
       liftIO (putStrLn (map toUpper s)) 
       if n' > 1 then put (n', A) 
          else put (n', B) 

Eseguire il programma, lanciando un calcolo stateful inizialmente nello Stato A

main = flip runStateT (0, A) $ do 
    writeName "Monday" 
    writeName "Tuesday" 
    writeName "Wednesday" 
    writeName "Thursday" 
    writeName "Saturday" 
    writeName "Sunday" 

dal codice precedente, l'uscita principale è:

monday 
TUESDAY 
WEDNESDAY 
thursday 
SATURDAY 
SUNDAY 

Si noti che questa è una soluzione puramente funzionale. Non ci sono aggiornamenti mutevoli o distruttivi in ​​questo programma. Invece, la monade di stato filtra la modalità desiderata attraverso il calcolo.

Answer 4

una codifica:

import Data.Char (toUpper, toLower) 

newtype State = State { unState :: String -> IO State } 

stateA :: State 
stateA = State $ \name -> do 
    putStrLn (map toLower name) 
    return stateB 

stateB :: State 
stateB = go 2 
    where 
    go 0 = stateA 
    go n = State $ \name -> do 
       putStrLn (map toUpper name) 
       return $ go (n-1) 

Non lasciatevi ingannare dal IO, questa è una pura traduzione di quel modello (non stiamo usando un IORef per memorizzare lo stato o qualsiasi cosa). Ampliare il newtype, vediamo ciò che questo tipo significa:

State = String -> IO (String -> IO (String -> IO (String -> ... 

Si prende una stringa, fa qualche I/O e chiede un'altra stringa, ecc

Questo è il mio preferito di codifica dei modelli di classe astratta a OO: classe astratta -> tipo, sottoclassi -> elementi di quel tipo.

La dichiarazione newtype State sostituisce la dichiarazione astratta writeName e la sua firma. Invece di passare uno StateContext in cui assegniamo un nuovo stato, abbiamo semplicemente restituito il nuovo stato.L'incorporamento del valore restituito in IO dice che il nuovo stato può dipendere dall'I/O. Dal momento che non è tecnicamente necessario in questo esempio, si potrebbe utilizzare il tipo più spinto

newtype State = State { unState :: String -> (State, IO()) } 

in cui possiamo ancora esprimere questo calcolo, ma la sequenza di stati è fisso e non è permesso dipendere ingresso. Ma atteniamoci al tipo originale, più indulgente.

E per il "client di prova":

runState :: State -> [String] -> IO() 
runState s [] = return() 
runState s (x:xs) = do 
    s' <- unState s x 
    runState s' xs 

testClientState :: IO() 
testClientState = runState stateA 
        [ "Monday" 
        , "Tuesday" 
        , "Wednesday" 
        , "Thursday" 
        , "Saturday" 
        , "Sunday" ]