小编Ste*_*zel的帖子

假设我有两个功能

f :: Monad m => a -> m a
g :: a -> a

我想连续应用于某些元素，如下所示：

(return x) >>= f >>= g

这不起作用，因为 g 是纯的，所以我首先需要“人为地”将它变成 monadic。一种可能性是

(return x) >>= f >>= (return . g)

这对我来说不是很直观。另一种可能性是使用 Monad 是 Applicative：

(return g) <*> ((return x) >>= f)

但这不是很直观，因为函数和参数的顺序不同：

(>>=) :: Monad m => m a -> (a -> m b) -> m b
(<*>) :: Applicative f => f (a -> b) -> f a -> f b

处理这个问题的规范方法是什么？如果(>>==) = (flip …

假设,在Haskell中,我有一堆函数都依赖于相同的参数类型:

f :: Par -> a -> b
g :: Par -> b -> c

由于我正在编写更多依赖于此参数类型的函数,我可以执行类似的操作

h :: Par -> a -> c
h par = myg . myf
    where myf = f par
          myg = g par

但是我不得不写这些where线.问题是:这可以避免吗？

[编辑:我试图提供一个最小的例子来说明问题,但显然这个例子太小而无法说明我想要的东西.在实际问题中,h当然不仅仅是f和g的组成.所以这是一些实际的代码:

有功能

apply :: ChamberLattice -> ChLatword -> ChLatWord
reduce :: ChamberLattice -> ChLatWord -> ChLatWord

我正在定义一个函数

chaseTurn :: ChamberLattice -> Turn -> Parity -> ChLatWord -> ChLatWord
chaseTurn cl Straight _ xs = xs
chaseTurn cl t parity …