리프트의 반환 값이 모나드로 제한되지 않는 이유는 무엇입니까?

Question

은 왜 대신 현재

class MonadTrans t where 
    lift :: Monad m => m a -> t m a 

이 (Why aren't monad transformers constrained to yield monads?의 제안과는 달리) 하스켈 98의

class MonadTrans t where 
    lift :: (Monad m, Monad (t m)) => m a -> t m a 
--     ^^^^^^^^^^^ 

로 정의하고 그 결과는 항상있을 것이라는 점을 보장하지 MonadTrans한다 모나드. 모나드 변압기가 모나드가 아닌 무언가를 생산하도록 허용되는 이유가 있습니까?

Answer 1

내 생각은 MonadTrans 대신 Monad에 Monad를 변환, 뭔가로 Monad 변환이다. Monad을 변환하는 것을 쓰고 lift을 정의 할 수 있기 때문에 더 일반화되었지만 >>=과 return을 정의 할 수는 없습니다. 대부분의 (전부는 아닐지라도) MonadTrans 인스턴스가 Monad으로 끝나기 때문에 컴파일러가 여전히 잘 처리하므로 실제로는 문제가되지 않습니다.

Answer 2

bheklilr의 대답은 나에게 모나드 변압기는 모나드없는 무언가를 생성하는 예를의 생각을했다. 모나드가 아닌 것으로 잘 알려진 예는 ZipList입니다. 각 레벨에서 모나드 액션을 실행하는 변형을 만들 수 있습니다.

import Control.Applicative 
import Control.Arrow ((***)) 
import Control.Monad 
import Control.Monad.Trans 

-- | A list where each step is produced by a monadic action. 
data ListT m a = Nil | Cons (m (a, ListT m a)) 

실제로 이것은 모나드 스트림입니다. 그리고 그것은 쉽게 Functor로 할 수 있으며, 분명히 Applicative

instance Monad m => Functor (ListT m) where 
    fmap f Nil  = Nil 
    fmap f (Cons k) = Cons $ (f *** fmap f) `liftM` k 
instance Monad m => Applicative (ListT m) where 
    pure x = Cons $ return (x, pure x) 
    Cons mf <*> Cons mx = Cons $ do 
     (f, fs) <- mf 
     (x, xs) <- mx 
     return (f x, fs <*> xs) 
    _  <*> _  = Nil 

하지만 모나드. 따라서 모나드를 Applicative으로 변환하는 MonadTrans 인스턴스가 있습니다.

instance MonadTrans ListT where 
    lift mx = Cons $ (\x -> (x, lift mx)) `liftM` mx 

(이 모든 것은 나를 실험 ZipSink 도관-추가도 좋은 예입니다 것을 깨닫게했다.)

---

그러나, 이것은 또 다른 질문이 제기 : 우리는 원하는 경우 변압기, 그들은 어떤 법칙을 고수해야합니까? MonadTrans에 대한 법률은 그래서 우리의 경우 우리가

lift (f `liftM` x) = fmap f (lift x) 

lift . return  = pure 
lift (m `ap` f)  = lift m <*> lift f 

Answer 3

내가 그 말을 다른 두 답변에 동의하지 않을거야처럼 뭔가를 할 수

lift . return = return 
lift (m >>= f) = lift m >>= (lift . f) 

으로 정의된다 결과는 모나드 여야합니다. 그 이유는 그렇지 않다면 lift이 지켜야 할 합리적인 법칙이 없다는 것입니다.

: 당신은 그들이 두 Kleisli 범주 사이 펑터 법을 깨닫게 될 때 이러한 법률이 더 의미가

lift (return x) = return x 

lift (m >>= f) = lift m >>= \r -> lift (f r) 

:

lift 은 (는) 다음과 같은 두 가지 법을 준수해야 함을 의미하는 모나드 morphisms 있어야하는데

-- i.e. "fmap id = id" 
(lift .) return = return 

-- i.e. "fmap (f . g) = fmap f . fmap g" 
(lift .) (f >=> g) = (lift .) f >=> (lift .) g 

그러나 출력을 모나드로 제한하지 않으면 해당 법칙이 더 이상 유효하지 않으며 을 올바르게 구현했는지 확인할 수있는 합리적인 방법이 없습니다.

진짜 이유는 클래스를 만드는 것이었다는 것입니다.