Tại sao sử dụng MultiParamTypeClasses trong 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... 

Tại sao một thể hiện của MonadState cần một trạng thái và một đơn nguyên, tại sao không tạo một lớp Trạng thái thông số duy nhất?

Answer 1

Hãy để tôi thử và trả lời câu hỏi của Gert trong các nhận xét vì đó là một câu hỏi khá khác.

Câu hỏi đặt ra là, tại sao chúng ta không chỉ cần viết

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

Vâng, chúng ta có thể viết những dòng này. Nhưng bây giờ câu hỏi là, chúng ta có thể làm gì với nó? Và phần khó khăn là, nếu chúng ta có một số mã với put x và sau đó get, làm thế nào để chúng ta liên kết các get đến put sao cho cùng một giá trị được trả về như một giá trị được đưa vào?

Và vấn đề là, chỉ với các loại () và s, không có cách nào để liên kết một với nhau. Bạn có thể thử triển khai nó theo nhiều cách khác nhau, nhưng nó sẽ không hoạt động. Không có cách nào để mang dữ liệu từ số put đến số get (có thể ai đó có thể giải thích điều này tốt hơn, nhưng cách tốt nhất để hiểu là thử viết nó).

Một đơn nguyên không nhất thiết phải là cách duy nhất để thực hiện các hoạt động có thể kết nối, nhưng nó là một cách, bởi vì nó có >> điều hành để liên kết hai câu với nhau:

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

vì vậy chúng tôi có thể viết

(put x) >> get 

---

EDIT: Dưới đây là một ví dụ sử dụng 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

Bạn cần một số cách liên kết loại trạng thái với loại đơn nguyên. MultiParamTypeClasses với FunctionalDependencies là một cách. Tuy nhiên, bạn cũng có thể làm điều đó bằng cách sử dụng 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 

    ... 

Đây là phương pháp được thực hiện bởi monads-tf package.