谁能解释foldr
工作原理?
请看以下示例:
Prelude> foldr (-) 54 [10, 11]
53
Prelude> foldr (\x y -> (x+y)/2) 54 [12, 4, 10, 6]
12.0
我对这些处决感到困惑。有什么建议?
Answers:
foldr
从列表的右端开始,并使用您提供的函数将每个列表条目与累加器值组合在一起。结果是在所有列表元素中“折叠”之后累加器的最终值。它的类型是:
foldr :: (a -> b -> b) -> b -> [a] -> b
从中可以看到list元素(类型为a
)是给定函数的第一个参数,而accumulator(类型为b
)是第二个。
对于第一个示例:
Starting accumulator = 54
11 - 54 = -43
10 - (-43) = 53
^ Result from the previous line
^ Next list item
因此,您得到的答案是53。
第二个例子:
Starting accumulator = 54
(6 + 54) / 2 = 30
(10 + 30) / 2 = 20
(4 + 20) / 2 = 12
(12 + 12) / 2 = 12
所以结果是12。
编辑:我的意思是要添加,这是针对有限列表的。 foldr
也可以在无限列表上使用,但我认为最好是先绕开有限情况。
foldr
不是“从右边开始”。它是右关联的。您可以通过阅读hackage.haskell.org/package/base-4.10.0.0/docs/src/…的[]
实例的源代码进行验证Foldable
理解文件夹的最简单方法是不用糖就重写要折叠的列表。
[1,2,3,4,5] => 1:(2:(3:(4:(5:[]))))
现在的foldr f x
作用是:
用f
infix形式替换[]
,x
然后评估结果。
例如:
sum [1,2,3] = foldr (+) 0 [1,2,3]
[1,2,3] === 1:(2:(3:[]))
所以
sum [1,2,3] === 1+(2+(3+0)) = 6
[]
和cons
与您选择的蓄电池和功能操作。
foldr
,因此用户可以决定如何处理“缺点”和“零”情况
它有助于理解之间的区别foldr
和foldl
。为什么foldr
叫“向右折”?
最初我以为是因为它从右到左消耗了元素。不过,两人都foldr
和foldl
消费清单由左到右。
foldl
从左到右评估(左关联)foldr
从右到左评估(右关联)我们可以通过一个使用关联性很重要的运算符的示例来明确区分。我们可以使用人类示例,例如运算符“ eats”:
foodChain = (human : (shark : (fish : (algae : []))))
foldl step [] foodChain
where step eater food = eater `eats` food -- note that "eater" is the accumulator and "food" is the element
foldl `eats` [] (human : (shark : (fish : (algae : []))))
== foldl eats (human `eats` shark) (fish : (algae : []))
== foldl eats ((human `eats` shark) `eats` fish) (algae : [])
== foldl eats (((human `eats` shark) `eats` fish) `eats` algae) []
== (((human `eats` shark) `eats` fish) `eats` algae)
这样做的语义foldl
是:一个人吃鲨鱼,然后那个吃了鲨鱼的人又吃了一些鱼,等等。吃者是蓄积者。
将此与:
foldr step [] foodChain
where step food eater = eater `eats` food. -- note that "eater" is the element and "food" is the accumulator
foldr `eats` [] (human : (shark : (fish : (algae : []))))
== foldr eats (human `eats` shark) (fish : (algae : []))))
== foldr eats (human `eats` (shark `eats` (fish)) (algae : [])
== foldr eats (human `eats` (shark `eats` (fish `eats` algae))) []
== (human `eats` (shark `eats` (fish `eats` algae)
这样做的含义foldr
是:一个人吃了已经吃了一条鱼的鲨鱼,而这条鱼已经吃了一些藻类。食物是蓄积者。
这两个foldl
和foldr
“剥离”食由左到右,所以这不是我们所说的与foldl为理由“左折”。相反,评估的顺序很重要。
考虑一下foldr
的非常定义:
-- if the list is empty, the result is the initial value z
foldr f z [] = z
-- if not, apply f to the first element and the result of folding the rest
foldr f z (x:xs) = f x (foldr f z xs)
因此,例如foldr (-) 54 [10,11]
必须等于(-) 10 (foldr (-) 54 [11])
,即再次扩展等于(-) 10 ((-) 11 54)
。因此内部运算是11 - 54
,即-43; 并且外部操作是10 - (-43)
,即10 + 43
,因此53
如您所观察。对于第二种情况,请执行类似的步骤,然后您将再次看到结果的形式!
我一直认为http://foldr.com是一个有趣的例子。参见Lambda Ultimate帖子。
1+(1+(1+(1+(1+(1+(1+(1+(1+(…)))))))))=∞
等等。链接对我有用,但数学笑话无效。
我认为以简单的方式实现map,foldl和foldr有助于解释它们的工作方式。实例有助于我们的理解。
myMap f [] = []
myMap f (x:xs) = f x : myMap f xs
myFoldL f i [] = i
myFoldL f i (x:xs) = myFoldL f (f i x) xs
> tail [1,2,3,4] ==> [2,3,4]
> last [1,2,3,4] ==> 4
> head [1,2,3,4] ==> 1
> init [1,2,3,4] ==> [1,2,3]
-- where f is a function,
-- acc is an accumulator which is given initially
-- l is a list.
--
myFoldR' f acc [] = acc
myFoldR' f acc l = myFoldR' f (f acc (last l)) (init l)
myFoldR f z [] = z
myFoldR f z (x:xs) = f x (myFoldR f z xs)
> map (\x -> x/2) [12,4,10,6] ==> [6.0,2.0,5.0,3.0]
> myMap (\x -> x/2) [12,4,10,6] ==> [6.0,2.0,5.0,3.0]
> foldl (\x y -> (x+y)/2) 54 [12, 4, 10, 6] ==> 10.125
> myFoldL (\x y -> (x+y)/2) 54 [12, 4, 10, 6] ==> 10.125
foldl from above: Starting accumulator = 54
(12 + 54) / 2 = 33
(4 + 33) / 2 = 18.5
(10 + 18.5) / 2 = 14.25
(6 + 14.25) / 2 = 10.125`
> foldr (++) "5" ["1", "2", "3", "4"] ==> "12345"
> foldl (++) "5" ["1", "2", "3", "4"] ==> “51234"
> foldr (\x y -> (x+y)/2) 54 [12,4,10,6] ==> 12
> myFoldR' (\x y -> (x+y)/2) 54 [12,4,10,6] ==> 12
> myFoldR (\x y -> (x+y)/2) 54 [12,4,10,6] ==> 12
foldr from above: Starting accumulator = 54
(6 + 54) / 2 = 30
(10 + 30) / 2 = 20
(4 + 20) / 2 = 12
(12 + 12) / 2 = 12
好吧,让我们看一下参数:
返回值:
它首先将函数应用于列表中的最后一个元素和空列表结果。然后,它将此结果和上一个元素重新应用到函数中,依此类推,直到它获取一些当前结果和列表的第一个元素以返回最终结果。
Fold使用带有一个元素的函数和一些先前的折叠结果,在初始结果周围“折叠”一个列表。对每个元素重复此操作。因此,foldr从列表的末尾或右侧开始执行此操作。
folr f emptyresult [1,2,3,4]
变成
f(1, f(2, f(3, f(4, emptyresult) ) ) )
。现在只需在评估中遵循括号即可,仅此而已。
需要注意的重要一件事是,提供的函数f
必须处理其自己的返回值作为其第二个参数,这意味着两个函数必须具有相同的类型。
资料来源:我的文章,如果您认为这可能会有所帮助,那么我将从命令性的未经处理的javascript角度进行研究。
仔细阅读此处提供的其他答案并进行比较,应该已经清楚了这一点,但值得注意的是,被接受的答案可能会对初学者产生误导。正如其他评论者所指出的那样,在Haskell中执行的计算文件夹并不“位于列表的右端”;否则,foldr
就永远无法在无限列表上工作(在正确的条件下,它可以在Haskell中完成)。
Haskell函数的源代码foldr
应明确说明:
foldr k z = go
where
go [] = z
go (y:ys) = y `k` go ys
每个递归计算将最左侧的原子列表项与列表尾部的递归计算结合在一起,即:
a\[1\] `f` (a[2] `f` (a[3] `f` ... (a[n-1] `f` a[n]) ...))
a[n]
初始累加器在哪里。
因为还原是“在Haskell中懒惰地完成的”,所以实际上是从左侧开始的。这就是我们所说的“惰性评估”,这是Haskell的显着特征。这对于理解Haskell的运作非常重要foldr
;因为实际上是从左开始递归地foldr
建立和减少计算,所以会短路的二进制运算符有机会这样做,允许在适当的情况下减少无限列表。foldr
它会导致远不如混乱初学者说相当的r
(“正确”)和l
(“左”)中foldr
,并foldl
指右联和左结合,要么离开它,或者试着解释Haskell的懒惰的影响评估机制。
为了处理您的示例,遵循foldr
源代码,我们构建以下表达式:
Prelude> foldr (-) 54 [10, 11]
->
10 - [11 - 54] = 53
然后再次:
foldr (\x y -> (x + y) / 2) 54 [12, 4, 10, 6]
->
(12 + (4 + (10 + (6 + 54) / 2) / 2) / 2) / 2 = 12