Haskell 当使用使用记录语法定义的构造函数时，如何定义Applicative和Monad的实例

我正试图为RWS的Applicative和Monad定义实例，但一定有我遗漏的东西。对于

pure

，我得到一个发生检查错误。这一定与我给出的

RWS f

作为pure的结果有关，尽管f的类型是

a

。我不明白如何访问

RWS

（r、w和s）的其他参数。如果有人能详细解释一些概念，例如

newtype

定义，我将不胜感激。据我所知，我们定义了一个新类型

RWS

，它有4个参数（r、w、s和a）。此类型是使用构造函数（

fromRWS

）定义的，该构造函数对参数执行某些操作。如果我错了，请纠正我。如果这是正确的，

RWS

是由4个参数定义的还是由RWS定义的

进一步说，

的实现会产生一个类型错误。它说fromRWS2应用于太少的参数。不过，我没有看到这个问题，因为我使用了相同的

where

子句方法来解决可变环境中的类似问题。我可以使用什么替代方案

在定义

Monad

时，我刚刚在输入RWS上得到了一个

解析错误

请帮助我定义实例

这是我的密码：

module RWS where

newtype RWS r w s a = RWS { fromRWS :: r -> s -> (a, s, w) }

instance Functor (RWS r w s) where
  fmap f (RWS rws) = RWS $ \r s -> let (a,s',w) = rws r s in (f a, s', w)

instance Monoid w => Applicative (RWS r w s) where
    -- pure a -> RWS r w s a
    pure f = RWS f
    -- (<*>) :: RWS r w s (a -> b) -> RWS r w s a -> RWS r w s b 
    RWS f <*> RWS a = RWS fromRWS2
                            where fromRWS2 r1 s1 = f a

instance Monoid w => Monad (RWS r w s) where
   --return :: a -> RWS r w s a
   return x = RWS x
   --(>>=)  :: (RWS r w s a) -> (a -> (RWS r w s b)) -> (RWS r w s b)
  RWS fr >>= f = f fr

模块RWS，其中
新类型RWS r w s a=RWS{fromRWS:：r->s->（a，s，w）}
实例函子（RWS r w s），其中
fmap f（RWS-RWS）=RWS$\r-s->let（a，s'，w）=RWS-r-s-in（f-a，s'，w）
实例幺半群w=>Applicative（RWS r w s），其中
--纯a->RWS r w s a
纯f=RWS f
--（）：：RWS r w s（a->b）->RWS r w s a->RWS r w s b
RWS f RWS a=RWS2中的RWS
其中fromRWS2 r1 s1=f a
实例幺半群w=>Monad（RWS-RWS）其中
--返回：：a->RWS r w s a
返回x=RWS x
--（>>=）：：（RWS r w s a）->（a->（RWS r w s b））->（RWS r w s b）
RWS fr>>=f=f fr
如果我们把
RWS
写成

newtype RWS r w s a = MakeRWS { fromRWS :: (r -> s -> (a, s, w)) }

这个定义有三个方面：


类型构造函数
RWS
使用四个
rwsa
参数
类型为
（r->s->（A，s，w））->RWS RWS A
RWS
类型为
RWS r w s A->（r->s->（A，s，w））

正如我们所看到的，数据构造函数
MakeRWS
应该应用于函数，以构造
RWS-wa
类型的值

在
pure
实现中，将
MakeRWS
应用于
a
类型的值，而不是函数。这就是纯实现的问题所在

如您在注释中所述，
pure
的类型应为

a -> RWS r w s a

但是，如果您的实现能够工作，那么它将具有这种类型：

(r -> s -> (a, s, w)) -> RWS r w s a

正确的实现是

pure a = MakeRWS (\_r s -> (a, s, mempty)


monad实现解析失败，因为
return
行上的缩进与
RWS
开头的行没有相同的缩进，只需跟随类型即可。我们只能对任何给定的东西做这么多：

-- newtype RWS r w s a  =  RWS { fromRWS :: r -> s -> (a, s, w) }

-- .....

    RWS tf <*> RWS ta  =  RWS tfa
        where 
        tfa r1 s1  =  (f a, s?, w2 ?? w3)  -- what is ?
           where                           -- what is ??
           (f, s2, w2) = tf r1 s1 
           (a, s3, w3) = ta r1 s2 

那么束缚就来了

   --(>>=)  :: (RWS r w s a) -> (a -> (RWS r w s b)) -> (RWS r w s b)
  (RWS f) >>= k  =  RWS g
       where
       -- RWS f :: RWS r w s a
       --     f :: r -> s -> (a, s, w)
       -- RWS g :: RWS r w s b
       --     g :: r -> s -> (b, s, w)
       g r1 s1  =  ???                     -- what is ???
            where
            (a, s2, w2) = f r1 s1
            (RWS h)     = k a
            -- RWS h :: RWS r w s b
            --     h :: r -> s -> (b, s, w)
            (b, s3, w3) = h r1 s????       -- what is ????

我设法修复了
pure
。缩进更改后，
和Monad仍有问题。在进行更改后，在哪里可以更新代码？原始帖子中允许这样做吗？@andy_bruja edits不能使答案无效，所以可能不要编辑它。：）
   --(>>=)  :: (RWS r w s a) -> (a -> (RWS r w s b)) -> (RWS r w s b)
  (RWS f) >>= k  =  RWS g
       where
       -- RWS f :: RWS r w s a
       --     f :: r -> s -> (a, s, w)
       -- RWS g :: RWS r w s b
       --     g :: r -> s -> (b, s, w)
       g r1 s1  =  ???                     -- what is ???
            where
            (a, s2, w2) = f r1 s1
            (RWS h)     = k a
            -- RWS h :: RWS r w s b
            --     h :: r -> s -> (b, s, w)
            (b, s3, w3) = h r1 s????       -- what is ????