Por qué usar MultiParamTypeClasses en un 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... 

¿Por qué una instancia de MonadState necesita un estado y una mónada? ¿Por qué no crear un solo parámetro State class?

Answer 1

Déjame intentar y responder la pregunta de Gert en los comentarios, porque es una pregunta bastante diferente.

La pregunta es, ¿por qué no podemos simplemente escribir

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

Bueno, podríamos escribir esto. Pero ahora la pregunta es, ¿qué podemos hacer con eso? Y la parte difícil es, si tenemos algún código con put x y luego get, ¿cómo enlazamos el get con el put para que se devuelva el mismo valor que el ingresado?

Y el problema es que, con solo los tipos () y s, no hay forma de vincular uno con el otro. Puede intentar implementarlo de varias maneras, pero no funcionará. Simplemente no hay forma de llevar los datos del put al get (tal vez alguien pueda explicar esto mejor, pero la mejor manera de entenderlo es intentar escribirlo).

una mónada no es necesariamente la única manera de hacer las operaciones enlazable, pero es una manera, ya que tiene el operador >> para unir dos estados juntos:

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

por lo que podemos escribir

(put x) >> get 

---

EDIT: Aquí está un ejemplo utilizando 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

Necesita alguna forma de asociar el tipo de estado al tipo de mónada. MultiParamTypeClasses con FunctionalDependencies es de una manera. Sin embargo, también puede hacerlo 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 

    ... 

Este es el enfoque adoptado por el monads-tf package.