Dlaczego warto używać MultiParamTypeClasses w 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... 

Dlaczego instancja MonadState potrzebuje stanu i monady, dlaczego nie utworzyć pojedynczego parametru State class?

Answer 1

Pozwól mi spróbować odpowiedzieć na pytanie Gert w komentarzach, ponieważ jest to całkiem inne pytanie.

Pytanie brzmi, dlaczego nie możemy po prostu napisać

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

Cóż, moglibyśmy napisać to. Ale teraz pytanie brzmi: co możemy z tym zrobić? A najtrudniejsze jest to, że jeśli mamy jakiś kod z put x, a później get, w jaki sposób możemy połączyć get z put, aby ta sama wartość została zwrócona, jak ta wprowadzona? Ten problem dotyczy tylko typów () i s. Możesz spróbować wdrożyć go na różne sposoby, ale to nie zadziała. Nie ma sposobu, aby przenieść dane z put do get (może ktoś może to wyjaśnić lepiej, ale najlepszym sposobem na zrozumienie jest próba napisania tego).

monady niekoniecznie jest jedynym sposobem, aby operacje skorelowane, ale jest to sposób, ponieważ ma operatora >> aby połączyć dwa oświadczenia ze sobą:

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

więc możemy napisać

(put x) >> get 

---

Edycja: Poniżej przedstawiono przykład użycia 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

Potrzebujesz jakiegoś sposobu powiązania typu stanu z typem monady. MultiParamTypeClasses z FunctionalDependencies jest jednym ze sposobów. Możesz jednak zrobić to również za pomocą TypeFamilies. Jest to podejście przyjęte przez monads-tf package.