2

使用时Data.Traversable，我经常需要一些代码，例如

import Control.Applicative (Applicative,(<*>),pure)
import Data.Traversable (Traversable,traverse,sequenceA)
import Control.Monad.State (state,runState)

traverseF :: Traversable t => ((a,s) -> (b,s)) -> (t a, s) -> (t b, s)
traverseF f (t,s) = runState (traverse (state.curry f) t) s

遍历结构并建立一个由某种状态驱动的新结构。我注意到类型签名模式并相信它可以概括为

fmapInner :: (Applicative f,Traversable t) => (f a -> f b) -> f (t a) -> f (t b)
fmapInner f t = ???

traverse但我无法用, sequenceA,fmap和<*>来实现这一点pure。也许我需要更强的类型类约束？我绝对需要Monad这里吗？

更新

具体来说，我想知道我是否可以定义fmapInner适用f于任何Traversable t适用于直觉的法则和一些适用于直觉的法则（我还不知道法则应该是什么），这是否暗示f事物是 a Monad？因为，对于Monads，实现是微不足道的：

--Monad m implies Applicative m but we still 
--  have to say it unless we use mapM instead
fmapInner :: (Monad m,Traversable t) => (m a -> m b) -> m (t a) -> m (t b)
fmapInner f t = t >>= Data.Traversable.mapM (\a -> f (return a))

更新

感谢您的出色回答。我发现我traverseF的只是

import Data.Traversable (mapAccumL)
traverseF1 :: Traversable t => ((a, b) -> (a, c)) -> (a, t b) -> (a, t c)
traverseF1 =uncurry.mapAccumL.curry

没有明确使用 Monad.State 并且所有对都翻转了。以前我虽然是这样，mapAccumR但实际上它是mapAccumL这样工作的traverseF。

4

1 回答 1

2

我现在已经说服自己这是不可能的。这就是为什么，

 tF ::(Applicative f, Traversable t) => (f a -> f b) -> f (t a) -> f (t b)

所以我们有这个返回的副作用计算，t a我们想用它来确定会发生什么副作用。换句话说， type 的值t a将决定我们 apply 时会发生什么副作用traverse。

但是，这对于应用类型类是不可能的。我们可以动态选择值，但输出计算的副作用是静态的。要明白我的意思，

pure :: a -> f a -- No side effects
(<*>) :: f (a -> b) -> f a -> f b -- The side effects of `f a` can't
                                  -- decide based on `f (a -> b)`.

现在有两种可能的方法可以根据先前的值确定副作用，

smash :: f (f a) -> f a

因为那时我们可以简单地做

smash $ (f :: a -> f a) <$> (fa :: f a) :: f a

现在你的功能变成

traverseF f t = smash $ traverse (f . pure) <$> t

或者我们可以有

bind :: m a -> (a -> m b) -> m b -- and it's obvious how `a -> m b`
                                 -- can choose side effects.

和

traverseF f t = bind t (traverse $ f . pure)

但它们join分别>>=是类型类的成员Monad。所以是的，你需要一个单子。:(

此外，具有 monad 约束的函数的一个很好的、无点的实现是

traverseM = (=<<) . mapM . (.return)

编辑，

我想值得注意的是

traverseF :: (Applicative f,Traversable t) => (f a -> f b) -> t a -> f (t a)
traverseF = traverse . (.pure)
于 2013-10-11T02:53:39.770 回答