如何编写一个函数,该函数接受类型为ai -> b -> ai
的函数元组,并返回一个函数,该函数接受类型为ai
的元素元组,一个类型为b
的元素,并将每个元素组合成一个新的ai
:
这就是签名应该像
f :: (a1 -> b -> a1, a2 -> b -> a2, ... , an -> b -> an) ->
(a1, a2, ... , an) ->
b ->
(a1, a2, ... , an)
这样:
f (min, max, (+), (*)) (1,2,3,4) 5 = (1, 5, 8, 20)
关键是我可以写:
foldlMult' t = foldl' (f t)
然后执行以下操作:
foldlMult' (min, max, (+), (*)) (head x, head x, 0, 0) x
一次完成多次折叠。 GHC扩展是可以的。
答案 0 :(得分:10)
如果我理解您的示例,那么类型为ai -> b -> ai
,而不是ai -> b -> a
。让我们将类型重写为a -> ri -> ri
,只是因为它有助于我思考。
首先要注意的是这种对应关系:
(a -> r1 -> r1, ..., a -> rn -> rn) ~ a -> (r1 -> r1, ..., rn -> rn)
这允许您编写这两个函数,它们是反转的:
pullArg :: (a -> r1 -> r1, a -> r2 -> r2) -> a -> (r1 -> r1, r2 -> r2)
pullArg (f, g) = \a -> (f a, g a)
pushArg :: (a -> (r1 -> r1, r2 -> r2)) -> (a -> r1 -> r1, a -> r2 -> r2)
pushArg f = (\a -> fst (f a), \a -> snd (f a))
第二个观察:ri -> ri
形式的类型有时被称为 endomorphisms ,并且这些类型中的每一个都具有作为关联操作的组合的monoid和作为标识的标识函数。 Data.Monoid
包具有以下包装:
newtype Endo a = Endo { appEndo :: a -> a }
instance Monoid (Endo a) where
mempty = id
mappend = (.)
这允许您将之前的pullArg
重写为:
pullArg :: (a -> r1 -> r1, a -> r2 -> r2) -> a -> (Endo r1, Endo r2)
pullArg (f, g) = \a -> (Endo $ f a, Endo $ g a)
第三个观察:两个幺半群的乘积也是一个幺半群,根据这个例子也来自Data.Monoid
:
instance (Monoid a, Monoid b) => Monoid (a, b) where
mempty = (mempty, mempty)
(a, b) `mappend` (c, d) = (a `mappend` c, b `mappend d)
同样适用于任意数量的参数。
第四次观察:What are folds made of?答案:folds are made of monoids!
import Data.Monoid
fold :: Monoid m => (a -> m) -> [a] -> m
fold f = mconcat . map f
此fold
只是来自foldMap
的{{1}}的特化,所以实际上我们不需要定义它,我们只需导入其更通用的版本:
Data.Foldable
如果您foldMap :: (Foldable t, Monoid m) => (a -> m) -> t a -> m
fold
,则与右侧折叠相同。要从左侧折叠,您需要使用Endo
幺半群折叠:
Dual (Endo r)
还记得我们的myfoldl :: (a -> Dual (Endo r)) -> r -> -> [a] -> r
myfoldl f z xs = appEndo (getDual (fold f xs)) z
-- From `Data.Monoid`. This just flips the order of `mappend`.
newtype Dual m = Dual { getDual :: m }
instance Monoid m => Monoid (Dual m) where
mempty = Dual mempty
Dual a `mappend` Dual b = Dual $ b `mappend` a
功能吗?让我们再修改一下,因为你是从左边折叠的:
pullArg
我声称,这是你pullArg :: (a -> r1 -> r1, a -> r2 -> r2) -> a -> Dual (Endo r1, Endo r2)
pullArg (f, g) = \a -> Dual (Endo $ f a, Endo $ g a)
的2元组版本,或至少与它同构。您可以将折叠函数重构为f
形式,然后执行:
a -> Endo ri
另外值得一看:Composable Streaming Folds,这是对这些想法的进一步阐述。
答案 1 :(得分:5)
对于直接方法,您可以为每个Control.Arrow
明确定义(***)
的{{1}}和(&&&)
的等效项(例如N
) :
N == 4
然后,
prod4 (f1,f2,f3,f4) (x1,x2,x3,x4) = (f1 x1,f2 x2,f3 x3,f4 x4) -- cf (***)
call4 (f1,f2,f3,f4) x = (f1 x, f2 x, f3 x, f4 x ) -- cf (&&&)
uncurry4 f (x1,x2,x3,x4) = f x1 x2 x3 x4
因此foldr4 :: (b -> a1 -> a1, b -> a2 -> a2,
b -> a3 -> a3, b -> a4 -> a4)
-> (a1, a2, a3, a4) -> [b]
-> (a1, a2, a3, a4) -- (f .: g) x y = f (g x y)
foldr4 t z xs = foldr (prod4 . call4 t) z xs -- foldr . (prod4 .: call4)
-- f x1 (f x2 (... (f xn z) ...)) -- foldr . (($) .: ($))
中的元组函数是您想要的翻转版本。测试:
前奏> g xs = foldr4(min,max,(+),(*))(头部xs,头部xs,0,1)xs
前奏> g [1..5]
(1,5,15,120)
foldr4
是一个调整。由于
foldl4'
我们有
foldr f z xs == foldl (\k x r-> k (f x r)) id xs z
foldl f z xs == foldr (\x k a-> k (f a x)) id xs z
我们甚至为元组的功能提供了你想要的类型。
必须使用更严格的foldl4, foldl4' :: (t -> a -> t, t1 -> a -> t1,
t2 -> a -> t2, t3 -> a -> t3)
-> (t, t1, t2, t3) -> [a]
-> (t, t1, t2, t3)
foldl4 t z xs = foldr (\x k a-> k (call4 (prod4 t a) x))
(prod4 (id,id,id,id)) xs z
foldl4' t z xs = foldr (\x k a-> k (call4 (prod4' t a) x))
(prod4 (id,id,id,id)) xs z
prod4' (f1,f2,f3,f4) (x1,x2,x3,x4) = (f1 $! x1,f2 $! x2,f3 $! x3,f4 $! x4)
版本来强制prod4
中的参数。