Trong một biến áp đơn nguyên, tại sao đơn vị được biết đến là cái bên trong?

Question

Ví dụ, MaybeT được định nghĩa là:

newtype MaybeT m a = 
    MaybeT { runMaybeT :: m (Maybe a)} 

Nhưng không:

newtype MaybeT m a = 
    MaybeT { runMaybeT :: Maybe (m a) } 

Tại sao điều này?

Answer 1

Sau khi mở rộng kiểu mới, chúng tôi có join :: Monad m => m (Maybe (m (Maybe a))) -> m (Maybe a) trong trường hợp đầu tiên và join :: Monad m => Maybe (m (Maybe (m a))) -> Maybe (m a) trong giây.

Để thực hiện join đầu tiên bạn cần một cách để phân phối Maybe qua m: dist1 :: Monad m => Maybe (m a) -> m (Maybe a):

join1 :: m (Maybe (m (Maybe a))) -> m (Maybe a) 
join1 = fmap join . join . fmap dist1 

Để thực hiện thứ hai join bạn cần luật phân phối đối diện dist2 :: Monad m => m (Maybe a) -> Maybe (m a)

join2 :: Maybe (m (Maybe (m a))) -> Maybe (m a) 
join2 = fmap join . join . fmap dist2 

dist1 rất dễ dàng để thực hiện (tôi sẽ để lại việc chứng minh luật biến áp đơn lẻ cho bạn):

dist1 :: Monad m => Maybe (m a) -> m (Maybe a) 
dist1 = sequenceA 

dist2 không dễ dàng như vậy. Nó không thể được thực hiện cho một tùy ý Monad. Như một phản ví dụ, chúng ta hãy chọn m là "đọc" đơn nguyên (->) r:

dist2 :: (r -> Maybe a) -> Maybe (r -> a) 

Vì bạn không có quyền truy cập vào một r, việc thực hiện duy nhất của dist2 rằng sẽ typecheck là const Nothing, mà thắng rõ ràng' t thỏa mãn luật đơn nguyên.

Answer 2

Nhìn vào StateT có thể là bài học:

newtype StateT s m a = StateT { runStateT :: s -> m (a,s) } 

Ở đây nhà nước không phải là "nội" hay "bên ngoài", nhưng kiểu của nó là xen kẽ với các đơn nguyên nó đang thay đổi, một số bit bên trong, một số bên ngoài. Và thực sự là

newtype ReaderT r m a = ReaderT { runReaderT :: r -> m a } 

là tất cả "bên ngoài". Vì vậy, nó phụ thuộc vào những gì biến nó được. Có lẽ một số lý thuyết thể loại mà ít nhất một phần giải thích xen kẽ này, tôi tò mò muốn biết về nó (trí thức?).

Contrast với functors applicative, mà

newtype Compose f g a = Compose { getCompose :: f (g a) } 

là một applicative là tốt, vì vậy luôn luôn có một rõ ràng "bên trong/bên ngoài" mối quan hệ. Bạn có thể thực hiện một applicative chỉ StateT, và tìm ra cấu trúc của nó bởi Compose (State s):

ApplicativeStateT s f a = s -> (s, f a) 

Trong thực tế, có một số khác nếu bạn soạn ở bên phải:

ApplicativeStateT' s f a = f (s -> (s,a)) 

Nhưng monads không có đều đặn như vậy.