foldl/foldr不命中stackoverflow
foldl和foldr是函数式编程中的两个高阶函数，用于遍历一个列表并进行累积操作。
foldl（也叫做foldl'）是从左到右进行遍历和累积操作的函数。它接受一个二元函数和一个初始累积值作为参数，并将初始累积值与列表中的第一个元素组合，然后将结果与下一个元素组合，以此类推，直到遍历完整个列表。这个函数会一直保持中间累积结果，因此对于较大的列表或者需要进行严格求值的情况下，建议使用foldl'。foldl'是foldl的严格版本，它避免了由于惰性求值带来的性能问题。
foldr是从右到左进行遍历和累积操作的函数。它与foldl相似，但是它先对列表的最后一个元素和初始累积值进行组合，然后是倒数第二个元素和结果组合，以此类推，直到遍历完整个列表。
这两个函数的主要区别在于它们对列表元素的组合顺序不同，这可能导致在某些情况下得到不同的结果。
优势：
- 灵活性：foldl和foldr是函数式编程中非常常用的函数，它们可以用于各种类型的累积操作，例如求和、求积、连接字符串等。通过灵活地定义二元函数，我们可以根据具体需求进行累积操作。
- 简洁性：使用foldl和foldr可以将复杂的遍历和累积逻辑简化为一个简洁的表达式，提高代码的可读性和可维护性。
- 性能：当处理大型列表时，使用foldl'可以避免惰性求值带来的性能问题，并且可以利用尾递归优化，减少函数调用的开销。
应用场景：
- 数据处理：foldl和foldr在函数式编程中常被用于处理各种数据结构，如列表、树等。通过定义不同的累积函数，可以进行各种复杂的数据处理操作。
- 函数组合：foldr在函数组合中起到重要的作用，可以将一组函数依次组合起来，形成一个新的函数。
- 编程语言实现：foldl和foldr在很多编程语言的标准库中都有提供，并且是一些其他高阶函数的基础。
腾讯云相关产品推荐：
- 云函数（Serverless）：腾讯云云函数是一种事件驱动的无服务器计算服务，可以通过编写简单的代码来响应各种事件，实现灵活的应用逻辑。 链接：https://cloud.tencent.com/product/scf
- 云数据库 TencentDB：腾讯云数据库是一种高性能、可扩展、全托管的云数据库服务，提供了多种数据库引擎（如MySQL、MongoDB等），支持自动备份、数据恢复等功能。 链接：https://cloud.tencent.com/product/cdb
- 云存储 COS：腾讯云对象存储（COS）是一种高可用性、高可扩展性的云存储服务，可以存储和检索任意类型的文件，支持海量数据存储和访问。 链接：https://cloud.tencent.com/product/cos
请注意，以上推荐的腾讯云产品仅供参考，具体选择应根据实际需求进行。
相关·内容
我的foldl有什么具体的问题，使它无法终止或产生输出？
首先，我实现了质数的筛选。它不是最好的，但它就像(例如) take 20 primesA一样工作得很好。
primesA :: [Integer]
primesA = sieve 2 []
sieve :: Integral a => a -> [a] -> [a]
sieve i [] = (i:) $ sieve (i + 1) $ map (*i) [i ..]
sieve i composites@(h : t)
| i == h = sieve (i + 1) t
| otherw
浏览 0提问于2013-04-29得票数 5
回答已采纳
所以，我真的在绞尽脑汁试图理解foldl.foldr的组成。下面是一个示例：
(foldl.foldr) (+) 1 [[1,2,3],[4,5,6]]
结果是22，但是这里到底发生了什么呢？
在我看来，这就是正在发生的事情：foldl (+) 1 [6,15]。我的疑问与foldr部分有关。它不应该将1添加到所有子列表中吗？像这样：foldr (+) 1 [1,2,3]。在我的脑海里，1只加了一次，对吗？(可能不是，但我想知道是怎么做到的/为什么！)
我很困惑(也许是把所有的困惑都搞乱了，哈哈)。谢谢!
浏览 4提问于2013-01-28得票数 8
回答已采纳
我相信我用foldr写了foldl：
myFoldl :: (a -> b -> a) -> a -> [b] -> a
myFoldl f base xs = foldr (flip f) base (reverse xs)
这是一个惯用的实现吗？
浏览 0提问于2014-10-10得票数 3
如果没有，如果我既想用一个预定义的函数修改列表中的元素，又想用一行代码返回一个列表，该怎么办呢？
例如: fun upperClass是一个预定义的函数string -> string，它使字符串中的所有字符都成为upperclass，这里我有一个列表"a"，"B"，"C“，我想以非递归的方式编写这个函数，并使用foldr返回”pre“，"b"，"c”。
我之前的尝试是foldr upperClass()，结果正如预期的那样类型不匹配，因为我通常使用OP:：将这些元素放回列表中。
浏览 4提问于2018-10-03得票数 3
1回答
考虑一下对像last这样工作的东西的各种尝试
Prelude> import Data.Foldable
Prelude Data.Foldable> foldr const undefined (reverse [1,2,3])
3
Prelude Data.Foldable> foldr' const undefined (reverse [1,2,3])
3
Prelude Data.Foldable> foldl (flip const) undefined [1,2,3]
3
Prelude Data.Foldable> foldl' (
浏览 1提问于2020-08-06得票数 5
回答已采纳
我认为两个代码应该可以正常运行
foldr (:) [] [1..5]
foldl (:) [] [1..5]
但我在使用foldl时出错：
Occurs check: cannot construct the infinite type: a ~ [a]
Expected type: [a] -> [a] -> [a]
Actual type: a -> [a] -> [a]
Relevant bindings include it :: [a] (bound at <interactive>:253:1)
In the first argument of
浏览 11提问于2017-12-24得票数 1
回答已采纳
所以我正在阅读，在中，有一个名为search的函数的定义，它检查列表是否包含子列表。
my_search :: Eq a => [a] -> [a] -> Bool
my_search sub l =
let
len = length sub
eqTest = (\acc x -> if take len x == sub then True else acc)
in foldl eqTest False $ tails l
现在，我想知道为什么不使用本章前面提到的foldl'，它运行得更快：
my_search' :: E
浏览 5提问于2016-05-04得票数 1
回答已采纳
这是一个非常非常简单的foldl函数:它接受一个列表，并返回相同的列表：
identityL :: (Integral a) => [a] -> [a]
identityL xs = foldl (\ acc x -> acc ++ [x]) [] xs
我试着用foldr做同样的事情，认为我所要做的就是将foldl改为foldr，并在"++“周围翻转"acc”和"x“。但是很明显，你也需要翻转参数：
identityR :: (Integral a) => [a] -> [a]
identityR xs = foldr (\ x acc
浏览 3提问于2015-01-13得票数 2
回答已采纳
我们被要求回答foldr或foldl是否更有效。
我不确定，但这不取决于我正在做什么，特别是我想达到我的职能？
是否有不同的情况或可以说foldr或foldl更好，因为.
有一般的答案吗？
提前感谢！
浏览 3提问于2013-12-03得票数 15
回答已采纳
1回答
我从上读到，由于严格性，foldl'对于长有限列表更有效。我知道这是不适合无限列表的。
因此，我只对有限长的列表进行比较。
concatMap
是使用foldr实现的，这给它带来了惰性。然而，使用它与长有限列表将建立一个长的，不缩减的链，根据文章。
concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
concatMap f xs = build (\c n -> foldr (\x b -> foldr c b (f x)) n xs)
因此，我提出了以下使用foldl'的实现。
conc
浏览 0提问于2017-03-26得票数 2
回答已采纳
运行以下程序将打印"space overflow: current size 8388608 bytes“。我已经阅读了和，但仍然不知道如何解决我的问题。我使用的是foldr，难道不应该保证它是“尾递归”的吗？
到目前为止，我对Haskell感觉很好，直到我知道我应该在使用强大的递归时防止“空间溢出”。:)
module Main where
import Data.List
value a b =
let l = length $ takeWhile (isPrime) $ map (\n->n^2 + a * n + b) [0..]
in (l, a ,b)
浏览 0提问于2009-08-18得票数 4
回答已采纳
3回答
我正在尝试创建一个长度函数，类似于ML中已经包含的函数。我的限制是，它必须在一行，使用地图，折页，或折页。
现在，我的代码行看起来如下：
val mylength = foldr ( fn(x,y) => 1+y) 0;
我绝不是ML的专家，但到目前为止我的推理是：
据我理解，foldr将从列表中的最后一项开始，将它作为函数中的x参数传递，并使用0作为初始的y值。然后它应该把y值加1，基本上忽略x。理论上，我相信这会给我总长度。但是，我有以下错误：
stdIn:136.5-136.37 Warning: type vars not generalized because of
v
浏览 7提问于2015-11-02得票数 4
回答已采纳
2回答
不带无限列表返回
、、
我读过和其他几篇关于foldl和foldr之间的区别的博客文章。现在，我试图将fibonacci序列写成一个具有foldr的无限列表，并提出了以下解决方案：
fibs2 :: [Integer]
fibs2 = foldr buildFibs [] [1..]
where
buildFibs :: Integer -> [Integer] -> [Integer]
buildFibs _ [] = [0]
buildFibs _ [0] = [1,0]
buildFibs _ l@(x:s:z) = (x + s):l
但是当我执行take 3
浏览 3提问于2015-01-09得票数 1
回答已采纳
为什么你可以用折页反转一个列表？
reverse' :: [a] -> [a]
reverse' xs = foldl (\acc x-> x : acc) [] xs
但是这次给了我一个编译错误。
reverse' :: [a] -> [a]
reverse' xs = foldr (\acc x-> x : acc) [] xs
错误
Couldn't match expected type `a' with actual type `[a]'
`a' is a rigid type variable
浏览 4提问于2014-09-24得票数 15
回答已采纳
2回答
我想用foldr来验证下面的foldl实现是否正确：
foldl4 = foldr . flip
我在拥抱中使用了以下测试：
foldl4 (+) 3 []
foldl4 (+) 3 [1,2,3]
他们成功了。
请建议我可以做更多的测试。
谢谢
浏览 3提问于2015-12-19得票数 1
3回答
在Scala的foldLeft中，我知道如何访问Scala中的accumulator和element值，但不知道Haskell。
我可以使用foldLeft来找出，在1到100之间，当除以3时，有多少个数有1的余数：
scala> List.range(1, 101).foldLeft(0){ (acc, elem) =>
| if (elem % 3 == 1) acc + 1
| else acc
| }
res2: Int = 33
我怎么能在Haskell做同样的事呢？
浏览 2提问于2014-04-14得票数 0
回答已采纳
2回答
我不明白为什么下面的函数会导致无限循环：
import Data.List
isTrue = foldl' (&&) False (repeat False)
浏览 3提问于2013-03-11得票数 1
回答已采纳
在我的GHCi foldr和foldl上有这样的签名：
Prelude> :t foldr
foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b
Prelude> :t foldl
foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b
折叠的替代类型签名(特别是t a部件)之间有什么区别？
fr :: (a -> b -> b) -> b -> [a] -> b
fl ::
浏览 0提问于2018-03-01得票数 2
回答已采纳
2回答
foldr (折叠-右)基本上是按列表中存储的值从右到左顺序执行的递归计算。而foldl与foldr正好相反。我想知道人们能使用foldr实现foldl函数吗？任何想法都是感激的，谢谢。
浏览 0提问于2018-10-20得票数 1
我有以下代码：
function foldr0(list, func) {
if (list.length == 0) {
return 0;
} else {
return func(list[0], foldr0(list.slice(1), func));
}
}
function foldl0(list, func) {
if (list.length == 0) {
return 0;
} else {
return ?
}
}
我知道通过定义助手方法foldl0来实现带有迭代逻辑的递归iter(list, func, par
浏览 11提问于2017-11-17得票数 1
回答已采纳
2回答
我有这样的代码：
import Data.List
newList_bad lst = foldl' (\acc x -> acc ++ [x*2]) [] lst
newList_good lst = foldl' (\acc x -> x*2 : acc) [] lst
这些函数返回每个元素乘以2的列表：
*Main> newList_bad [1..10]
[2,4,6,8,10,12,14,16,18,20]
*Main> newList_good [1..10]
[20,18,16,14,12,10,8,6,4,2]
在ghci中：
*Ma
浏览 5提问于2013-02-18得票数 4
回答已采纳
1回答
这里是 ，但我的具体例子是逃避我，因为我觉得无论是从右到左还是从左到右，我的折叠都不应该被关心。这是2016年第一天的解决方案，它可以归结为记下一系列指令(右转/左转，向前走x步)，然后应用这些指令，并给出你的终点和起点之间的距离。
我编写了一个apply函数来处理这个过程的一个步骤，它具有签名：
data Direction = North | East | South | West deriving (Enum, Show)
type Location = (Int, Int)
type Instruction = String
apply :: Direction ->
浏览 5提问于2017-11-10得票数 4
回答已采纳
我最近一直在学习Haskell，遇到了一些我不太理解的东西: lambda函数的参数。
在“为伟大的好书学习一本Haskell”第5章中，有以下两个功能：
elem' :: (Eq a) => a -> [a] -> Bool
elem' y ys = foldr (\x acc -> if x == y then True else acc) False ys
reverse' :: [a] -> [a]
reverse' = foldl (\acc x -> x : acc) []
在第一个函数中，累加器被列出为lambd
浏览 3提问于2021-09-20得票数 5
回答已采纳
1回答
我的理解是，foldl和foldr的执行方式如下：
foldl f a [1..30] => (f (f (f ... (f a 1) 2) 3) ... 30)
和
foldr f a [1..30] => (f 1 (f 2 (f 3 (f ....(f 30 a)))))..)
所以..。foldr (&&) False (repeat False)可以简化，因为最外层的f认为(&&) False ((&&) False (....))认为第一个参数是假的，而不需要计算第二个参数(这是一个很大的提示)。
所以发生了什么
andF
浏览 3提问于2016-06-22得票数 6
回答已采纳
1回答
作为一项小小的练习，我正在尝试重新计算所有的内容。这段代码似乎有效(除了无限列表之外)：
allComp f acc x = acc && f x
all :: (a -> Bool) -> [a] -> Bool
all f xs = foldl (allComp f) True xs
但是，如果我保留相同的签名，这个就不会编译：
allComp f acc x = acc && f x
all :: (a -> Bool) -> [a] -> Bool
all f xs = foldr (allComp f) True
浏览 3提问于2015-12-07得票数 1
回答已采纳
我已经写了下面的代码，它创建了一个无限的斐波那契数列表：
fibs = 1:1:fib 1 1
where fib a b = a+b:fib b (a+b)
上面的代码可以用foldl或foldr编写来避免递归吗？
浏览 2提问于2012-09-06得票数 7
回答已采纳
2回答
我知道Haskell中的尾递归有一些困难，因为它是懒惰的。也就是说，在Haskell中使用尾递归是否明智？
浏览 0提问于2013-11-03得票数 2
1回答
给予：
data NonEmpty a = NonEmpty a (Array a)
我从PureScript为例完成了以下练习：
为NonEmpty编写一个可折叠实例。提示:对数组重用可折叠实例。
instance foldableNonEmpty :: Foldable NonEmpty where
foldr f acc (NonEmpty a as) = foldr f (f a acc) as
foldl f acc nonEmpty = foldr (flip f) acc nonEmpty
foldMap f (NonEmpty a as) = f
浏览 0提问于2017-12-10得票数 1
有一段时间以来，我一直试图把脑袋绕在折叠式和折叠式上，我已经决定了下面的问题应该为我解决。假设将以下列表1、2、3传递给以下四个函数：
a = foldl (\xs y -> 10*xs -y) 0
b = foldl (\xs y -> y - 10 * xs) 0
c = foldr (\y xs -> y - 10 * xs) 0
d = foldr (\y xs -> 10 * xs -y) 0
结果分别为-123、83、281和-321。
为什么是这种情况？我知道当您将1,2,3,4传递到定义为
f = foldl (xs x -> xs ++ [f x
浏览 2提问于2014-11-12得票数 0
回答已采纳
在深入研究fold与的过程中，我发现了foldl使用foldr的惊人定义
-- I used one lambda function inside another only to improve reading
foldl :: (b -> a -> b) -> b -> [a] -> b
foldl f z xs = foldr (\x g -> (\a -> g (f a x))) id xs z
在了解了发生了什么之后，我想我甚至可以使用foldr来定义foldl'，如下所示：
foldl' :: (b -> a ->
浏览 3提问于2015-11-19得票数 3
回答已采纳
1回答
foldr :: (a -> b -> b) -> b -> [a] -> b
foldr f v [] = v
foldr f v (x:xs) = f x (foldr f v xs)
foldl :: (a -> b -> a) -> a -> [b] -> a
foldl f v [] = v
foldl f v (x:xs) = foldl f (f v x) xs
我正试着把我的注意力集中在这两个功能上。我有两个问题。一个关于函数f。总体而言,
foldr f v xs
f可以访问xs的第一个元素和递归处理的尾。在此：
f
浏览 6提问于2022-05-15得票数 2
回答已采纳
新手呼叫Haskell。
试图找出原因：
foldr (\_ _ -> 1) 2 [1..]
但是，立即返回1：
foldl (\_ _ -> 1) 2 [1..]
永远跑。
阅读一些，但却停留在一些#.上。
帮帮我。(在Windows GHC 7.10.3上运行测试)
浏览 1提问于2016-01-11得票数 4
回答已采纳
我们有那个。这一点在中有详细的解释。该文件指出：
相反，不可能从fold的角度重新定义foldl，因为foldl的list参数的尾部很严格，而fold则不是。
然而，我看不出这是如何证明用foldr定义foldl是不可能的(请注意，在最初的文章中，fold是foldr的同义词)。我很困惑，想弄明白严格在这里起着怎样的作用。有人能详细解释一下这个解释吗？
浏览 5提问于2017-01-16得票数 5
回答已采纳
1回答
缺失的褶皱
、、、、
如果你想折叠一个列表，我看到了四种方法。
从列表的右侧折叠，右侧为递归项。
(-) 100 1.10=1- (2 - (3 - (4 - (5 - (6 - (7 - (8 - (9 - (10 -(100)= 95
foldrr :: (a -> b -> b) -> b -> [a] -> b
foldrr step zero (x:xs) = step x (foldrr step zero xs)
foldrr _ zero [] = zero
从列表的右边折叠，左边是递归项。
( 100 ))- 9) - 8) - 7) - 6)
浏览 2提问于2017-07-02得票数 9
回答已采纳
我很难理解foldr和foldl，使用两者都有什么主要的好处，foldl应该是尾递归的，但是什么是foldr，通常是递归的呢？
我有一个简单的函数，它取int的列表，并返回第一个元素和最后一个元素之间的平方和。
sumSquare :: [Int] -> Int
sumSquare xs = if length xs == 2 then sum $ map (^2) [head xs..last xs] else error "bad input"
我想要做的是使用foldr或foldl来实现这个函数，我看了几个例子，但遗憾的是，它一无所获。
如果有人能演示如何使用f
浏览 10提问于2015-02-13得票数 1
回答已采纳
我定义了一个二叉树，并使用我的函数创建了一个新树。
data Tree a = EmptyTree | Node a (Tree a) (Tree a) deriving (Show)
singleton :: a -> Tree a
singleton x = Node x EmptyTree EmptyTree
treeInsert :: (Ord a) => a -> Tree a -> Tree a
treeInsert x EmptyTree = singleton x
treeInsert x (Node a left right)
| x &l
浏览 0提问于2018-09-22得票数 0
回答已采纳
7回答
首先，我正在阅读的Real World Haskell建议永远不要使用foldl，而要使用foldl'。所以我相信它。
但我不清楚什么时候使用foldr，什么时候使用foldl'。虽然我可以看到它们的不同工作结构摆在我面前，但我太愚蠢了，不知道什么时候“哪个更好”。我猜在我看来，使用哪一个并不重要，因为它们都产生了相同的答案(不是吗？)。事实上，我之前使用这个结构的经验来自于Ruby的inject和reduce，它们似乎没有“左”和“右”版本。(附带问题:他们使用的是哪个版本？)
任何可以帮助像我这样的聪明挑战的人的洞察力都将不胜感激！
浏览 94提问于2008-12-21得票数 164
回答已采纳
我想测试foldl和foldr。在我看来，由于尾部递归优化，你应该尽可能地使用foldl而不是foldr。
这是有道理的。然而，在运行这个测试之后，我感到困惑：
foldr (使用time命令时需要0.057s )：
a::a -> [a] -> [a]
a x = ([x] ++ )
main = putStrLn(show ( sum (foldr a [] [0.. 100000])))
foldl (使用time命令时需要0.089s )：
b::[b] -> b -> [b]
b xs = ( ++ xs). (\y->[y])
main = put
浏览 1提问于2010-08-07得票数 80
回答已采纳
1回答
我是Haskell的新手，在从事小程序的工作时，我发现对lambda函数的功能几乎没有什么混淆。
lastThat :: (a -> Bool) -> a -> [a] -> a
lastThat f = foldl (\x acc -> if f x then x else acc)
执行lastThat (>0) 100 [-1,-4,5,7,9,-10]我得到了100。使用下列定义时
lastThat :: (a -> Bool) -> a -> [a] -> a
lastThat f = foldl (\acc x
浏览 4提问于2019-12-14得票数 0
4回答
以下语句是否等效？
foldr (++) [ ] = foldl (++) [ ]
我知道foldr (+) 0 = fold (+) 0是等价的，对于运算符(-)不是，但是(++)操作符怎么样？我认为结果是一个具有相同内容的列表，但顺序不同。名单的顺序相关吗？
浏览 8提问于2022-08-10得票数 0
第一件事，我理解(几乎)折叠功能。考虑到这个函数，我可以很容易地计算出会发生什么以及如何使用它。
问题在于它是如何实现的，这导致了函数定义上的细微差异--需要一些时间才能完成understand.To --这使得情况变得更糟--大多数折叠都有相同类型的列表和默认情况，这无助于下绞线，因为它们可能有所不同。
Usage:
foldr f a xs
foldl f a xs
where a is the default case
definition:
foldr: (a -> b -> b) -> b -> [a] -> b
foldl: (a
浏览 0提问于2018-03-13得票数 2
回答已采纳
4回答
我正在尝试编写一个在JavaScript中实现foldl的函数。我试图在函数中使用递归，但无法实现它。
var foldl = function(f, acc, array) {
if (array.length == 0) {
return acc;
} else {
return f(array[0], foldl(f, acc, array.slice(-1)));
}
}
console.log(foldl(function(x, y) {
return x + y
}, 0, [1, 2, 3]));
console.log(foldl(fun
浏览 0提问于2018-04-15得票数 1
回答已采纳
1回答
我试着将简单的文件解析器从pythonto重写到haskell上，但发现它非常慢(在同一台机器上大约慢了15倍)。用ghc -O2编译的代码。
目标是计算正则表达式匹配的行数。示例文本文件很大(几个GiBs)。
代码如下：
import Text.Regex.Posix
import qualified Data.ByteString as BS
import qualified Data.ByteString.Char8 as BC
filename = "sample.dat"
mcount' :: String -> [BS.ByteString] -&
浏览 0提问于2012-09-23得票数 1
回答已采纳
众所周知，我们可以像这样使用foldr找到列表的标题：
head'' :: [a] -> a
head'' = foldr (\x _ -> x) undefined
但是，有没有办法使用foldl获得相同的结果？
类似地，我们可以像这样使用foldl找到list的最后一个元素：
last'' :: [a] -> a
last'' = foldl (\_ x -> x) undefined
有没有任何方法可以使用foldr获得相同的结果？
浏览 1提问于2019-05-02得票数 2
5回答
我已经研究了和以及其他一些工具，他们很好地解释了这一点。
在这种情况下，我仍然不知道lambda是如何工作的。
foldr (\y ys -> ys ++ [y]) [] [1,2,3]
有没有人能一步一步地给我解释一下？
还有，foldl是如何工作的？
浏览 0提问于2010-10-17得票数 15
回答已采纳
1回答
据我所知，因为Haskell使用了惰性计算，它允许在有限的时间内对无限列表的操作进行计算。
作为测试，我定义了以下函数
X Boolean
Y Int
f(X,Y) = (Y == 3) OR X
因此，fold left应用于以False为初始值的无限整数列表[1..]和上面定义的函数，应该返回True，因为当它到达n=3时，计算f(n==3,False)将返回True，因此此True将通过该函数传播。
我用Haskell代码实现了这个函数
myfunc :: Bool -> Int -> Bool
myfunc True _ = True
myfunc _ n
| (n
浏览 5提问于2020-01-13得票数 0
我正在研究"Haskell编程从首要原则“。在折叠列表一章中，练习5f，
当我评估
foldr const 'a' [1..5]
我得到了
没有从字面“1”中产生(Num Char)的实例
然而，与
foldl const 'a' [1..5]
我得到了'a'。
我知道褶皱很懒，foldr不会穿过脊柱，foldl也会。但即使看了叶酸和叶酸的定义，
foldr f z [] = z
foldr f z (x:xs) = f x (foldr f z xs)
foldl f z [] = z
浏览 7提问于2016-03-16得票数 1
回答已采纳
5回答
在无限列表上左和右折叠
、、、、
我对 (伟大的书imo，而不是反驳它)的以下段落有异议：
一个很大的区别是右折叠在无限大的列表上工作，而左边的则不工作！直截了当地说，如果你在某个时候取了一个无限的列表，然后从右边折叠起来，你最终会到达列表的开头。然而，如果你在一个点上取了一个无限的列表，然后你试图把它从左边折叠起来，你就永远不会到达终点！
我只是不明白。如果你把一个无限的列表从右边折叠起来，那么你就必须从无穷远处开始，这是不可能发生的(如果有人知道你可以这样做的语言，那就说明:p)。至少，根据Haskell的实现，您必须从那里开始，因为在Haskell中，foldr和foldl不采用确定列表中应该从何处开始折叠的参数
浏览 0提问于2011-09-13得票数 73
回答已采纳
2回答
我目前正在为考试做准备，我认为用foldr写foldl将是一个很好的测试问题。
无论如何，我知道(foldl f基lst)返回(f xn (f (n-1))。。。(f x1基)第一(x1 )。。。( xn)
我现在要说的是：
(define (foldl/w/foldr f base lst)
(foldr (lambda (x y) (f y (f x base))) base lst)))
这不太管用，我也不知道该怎么做。
浏览 4提问于2017-12-17得票数 3
回答已采纳
4回答
在中，我发现foldl (op -) 2 [1] = foldr (op -) 2 [1]的关系成立。但是当我在Haskell中尝试上面的内容时，我发现上面的关系在Haskell中重写为foldl (-) 2 [1] == foldr (-) 2 [1]不成立。为什么会这样呢？Haskell对折叠的定义是否与SML/NJ不同？
谢谢
浏览 2提问于2013-12-08得票数 4
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
云直播
对象存储活动推荐
腾讯云开发者
