Perché utilizzare MultiParamTypeClasses in MonadState

Question

class Monad m => MonadState s m | m -> s where 
    -- | Return the state from the internals of the monad. 
    get :: m s 
    get = state (\s -> (s, s)) 

    -- | Replace the state inside the monad. 
    put :: s -> m() 
    put s = state (\_ -> ((), s)) 

    -- | Embed a simple state action into the monad. 
    state :: (s -> (a, s)) -> m a 
    state f = do 
     s <- get 
     let ~(a, s') = f s 
     put s' 
     return a 

instance MonadState s m => MonadState s (MaybeT m) where... 

Perché un'istanza di MonadState necessita di uno stato e di una monade, perché non creare una classe di stato a parametro singolo?

Answer 1

Lasciatemi provare a rispondere alla domanda di Gert nei commenti, perché è una domanda piuttosto diversa.

La domanda è: perché non possiamo solo scrivere

class State s where 
    get :: s 
    put :: s ->() 

Beh, potremmo scrivere questo. Ma ora la domanda è: cosa possiamo farci? E la parte difficile è che se abbiamo un codice con put x e successivamente get, come possiamo collegare lo get allo put in modo che lo stesso valore venga restituito come quello inserito?

E il problema è che, con i tipi () e s, non c'è modo di collegare l'uno all'altro. Puoi provare a implementarlo in vari modi, ma non funzionerà. Non c'è modo di trasportare i dati dallo put allo get (forse qualcuno può spiegarlo meglio, ma il modo migliore per capire è provare a scriverlo).

una monade non è necessariamente l'unico modo per fare operazioni reticolabile, ma è un modo, perché ha all'operatore >> collegare due affermazioni insieme:

(>>) :: m a -> m b -> m b 

modo da poter scrivere

(put x) >> get 

---

EDIT: Ecco un esempio di utilizzo the StateT instance defined in the package

foo :: StateT Int IO() 
foo = do 
    put 3 
    x <- get 
    lift $ print x 

main = evalStateT foo 0 

Answer 2

È necessario un modo per associare il tipo di stato al tipo di monade. MultiParamTypeClasses con FunctionalDependencies è a senso unico. Tuttavia, puoi farlo anche usando TypeFamilies.

class (Monad m) => MonadState m where 
    type StateType m 

    -- | Return the state from the internals of the monad. 
    get :: m (StateType m) 
    get = state (\s -> (s, s)) 

    -- | Replace the state inside the monad. 
    put :: StateType m -> m() 
    put s = state (\_ -> ((), s)) 

    -- | Embed a simple state action into the monad. 
    state :: (StateType m -> (a, StateType m)) -> m a 
    state f = do 
     s <- get 
     let ~(a, s') = f s 
     put s' 
     return a 

instance MonadState m => MonadState (MaybeT m) where 
    type StateType (MaybeT m) = StateType m 

    ... 

Questo è l'approccio adottato dallo monads-tf package.