非二进制的foldl和foldr在球拍中是如何工作的？
在球拍中，非二进制的foldl和foldr是指在处理球拍的元素时，不仅仅考虑二进制的操作，而是根据特定的规则对元素进行处理和组合。
foldl（左折叠）和foldr（右折叠）是函数式编程中常用的高阶函数，用于对一个列表或集合中的元素进行迭代和聚合操作。
- foldl（左折叠）：
- 左折叠从列表或集合的左侧开始，逐个取出元素，并将其与累积值进行操作。
- 操作的结果将作为下一次迭代的累积值。
- 最终返回最后一次迭代的累积值作为结果。
- foldr（右折叠）：
- 右折叠从列表或集合的右侧开始，逐个取出元素，并将其与累积值进行操作。
- 操作的结果将作为下一次迭代的累积值。
- 最终返回第一次迭代的累积值作为结果。
在球拍中，非二进制的foldl和foldr可以用于处理球拍的元素，例如计算球拍中所有球的总重量或平均重量。具体实现方式取决于编程语言和球拍数据结构的特点。
以下是一些腾讯云相关产品和产品介绍链接地址，可用于处理和存储球拍数据：
- 云数据库 TencentDB：https://cloud.tencent.com/product/cdb
- 云存储对象存储 COS：https://cloud.tencent.com/product/cos
- 云函数 SCF：https://cloud.tencent.com/product/scf
- 人工智能平台 AI Lab：https://cloud.tencent.com/product/ailab
- 物联网平台 IoT Explorer：https://cloud.tencent.com/product/iotexplorer
请注意，以上链接仅供参考，具体选择产品应根据实际需求和技术要求进行评估和决策。
相关·内容
2回答
来自的示例：
(foldr / 7 (list 34 56 12 4 23))
(foldl / 7 (list 34 56 12 4 23))
球拍输出：
5 193/196
5 193/196
在这种情况下，foldl和foldr的完整(扩展)形式是什么？它不是这样的：
> (/ (/ (/ (/ (/ 7 34) 56) 12) 4) 23)
1/300288
编辑:我已经修改了上面的问题，因为执行折叠在球拍对哈斯克尔已经解释在另一个问题，。
编辑:如果我清楚地理解了答案，扩展的表单可以使用“线程”模块非常清晰地显示，其中语句按执行顺序出现(_表示前面语句的输出)：
折页：
(re
浏览 0提问于2016-08-18得票数 0
回答已采纳
我熟悉foldl和foldr在单个列表中的底层工作原理和差异。但是，在球拍中，您可以在多个列表上使用折叠。例如，您可以通过以下方式找出两个列表中元素的差异
; (mapMinus '(3 4) '(1 2)) => '(2 2)
(define (mapMinus lst0 lst1)
(foldl (λ (hd0 hd1 acc) (cons (- hd0 hd1) acc)) '() lst0 lst1))
exactly的foldl和foldr实现到底是如何处理多个列表的？GitHub 上提供了foldl的球拍源代码，但我对Chez Scheme
浏览 17提问于2020-02-28得票数 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
回答已采纳
5回答
我已经研究了和以及其他一些工具，他们很好地解释了这一点。
在这种情况下，我仍然不知道lambda是如何工作的。
foldr (\y ys -> ys ++ [y]) [] [1,2,3]
有没有人能一步一步地给我解释一下？
还有，foldl是如何工作的？
浏览 0提问于2010-10-17得票数 15
回答已采纳
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
回答已采纳
7回答
首先，我正在阅读的Real World Haskell建议永远不要使用foldl，而要使用foldl'。所以我相信它。
但我不清楚什么时候使用foldr，什么时候使用foldl'。虽然我可以看到它们的不同工作结构摆在我面前，但我太愚蠢了，不知道什么时候“哪个更好”。我猜在我看来，使用哪一个并不重要，因为它们都产生了相同的答案(不是吗？)。事实上，我之前使用这个结构的经验来自于Ruby的inject和reduce，它们似乎没有“左”和“右”版本。(附带问题:他们使用的是哪个版本？)
任何可以帮助像我这样的聪明挑战的人的洞察力都将不胜感激！
浏览 94提问于2008-12-21得票数 164
回答已采纳
第一件事，我理解(几乎)折叠功能。考虑到这个函数，我可以很容易地计算出会发生什么以及如何使用它。
问题在于它是如何实现的，这导致了函数定义上的细微差异--需要一些时间才能完成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
回答已采纳
运行以下程序将打印"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
回答已采纳
2回答
我两天前才开始使用Haskell，所以我还不确定如何优化我的代码。
作为练习，我重写了foldl和foldr (我将在这里提供foldl，但foldr是相同的，用head替换last，用tail替换init )。
代码是：
module Main where
myFoldl :: ( a -> ( b -> a ) ) -> a -> ( [b] -> a )
myFoldl func = ( \x -> (\theList
-> if (length theList == 0) then
x
浏览 0提问于2012-06-22得票数 7
回答已采纳
我很难理解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
回答已采纳
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
回答已采纳
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，我面临着以下问题：
我想用foldl‘和foldr重写++函数。我已经用foldr做到了：
myConcat xs ys = foldr (:) ys xs
我不能用foldl来做这件事。我在上读到foldr对做这类事情很有用。好的，但是我不能用foldl写一个++的等价物吗？谁能告诉我如何做到这一点(如果它可以做到…这本书没有提到任何关于它的内容)……
Haskell的类型机制会阻止我这样做吗？每次我尝试的时候都会得到一个类型错误...
浏览 0提问于2011-06-17得票数 4
回答已采纳
所以，我真的在绞尽脑汁试图理解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
回答已采纳
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
回答已采纳
我有以下代码：
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
回答已采纳
在DrRacket中，若要返回列表而不通过使用foldr进行更改，请按以下方式完成：
(foldr cons '() '(1 2 3))
然而，在Clojure中，还原是左折叠的，所以我如何才能做到这一点？
首先我尝试了这个：
(reduce cons '() '(1 2 3))
=> IllegalArgumentException Don't know how to create ISeq from: java.lang.Long clojure.lang.RT.seqFrom (RT.java:542)
后来我试了一下：
(reduce
浏览 11提问于2016-05-04得票数 0
回答已采纳
我最近一直在学习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
回答已采纳
4回答
理解Haskell中的Folds
、、、、
根据我对Haskell中褶皱的理解，foldl (-) 0 [1..5]通过计算0-1-2-3-4-5给出了-15的结果，foldr (-) 0 [1..5]通过计算5-4-3-2-1-0给出了-5的结果。为什么foldl (++) "" ["a", "b", "c"]和foldr (++) "" ["a", "b", "c"]都给出了"abc"的结果，而foldr的结果却不是"cba"
在理解foldl和foldr之间的区别时，我是否
浏览 0提问于2018-08-27得票数 2
回答已采纳
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
回答已采纳
我正在看哈斯克尔的Foldable课程。两个方法fold，foldMap需要一个Monoid实例。但是foldr或foldl没有任何这样的约束。
fold :: Monoid m => t m -> m
foldMap :: Monoid m => (a -> m) -> t a -> m
foldr :: (a -> b -> b) -> b -> t a -> b
foldl :: (b -> a -> b) -> b -> t a -> b
如果foldr/foldl的结果是等价的，它不应该限
浏览 2提问于2016-06-22得票数 6
回答已采纳
11回答
有人能解释一下是如何工作的吗？
以这些例子为例：
Prelude> foldr (-) 54 [10, 11]
53
Prelude> foldr (\x y -> (x+y)/2) 54 [12, 4, 10, 6]
12.0
我对这些行刑感到困惑。有什么建议吗？
浏览 2提问于2009-11-19得票数 84
回答已采纳
2回答
我想用Foldr函数定义min函数来获得列表中的最小数目。
min xs = foldr (\ x y -> if x<y then x else y) xs
虽然我理解Foldr对于下面这样的简单函数的逻辑
sum = foldr (+) 0
我搞不懂如何像敏那样做这件事。
浏览 2提问于2014-07-11得票数 0
回答已采纳
4回答
在Haskell中，像在许多其他函数式语言中一样，函数foldl被定义为例如foldl (-) 0 [1,2,3,4] = -10。
这是可以的，因为根据定义，foldl (-) 0 [1, 2,3,4]是((((0 - 1) - 2) - 3) - 4)。
但是，在球拍中，(foldl - 0 '(1 2 3 4))是2，因为球拍“智能”是这样计算的：(4 - (3 - (2 - (1 - 0))))，实际上是2。
当然，如果我们定义辅助函数翻转，如下所示：
(define (flip bin-fn)
(lambda (x y)
(bin-fn y x)))
然后，我们可
浏览 7提问于2012-01-08得票数 48
2回答
我正在使用haskell学习一些函数编程，并试图通过重新实现一些库函数来了解一些概念。
我有一个问题，主要是关于什么时候选择递归而不是迭代。例如，当重新实现"all“函数时，我可以选择：
all1 :: (a -> Bool) -> [a] -> Bool
all1 p xs = foldr (\x acc -> acc && p x) True xs
all2 :: (a -> Bool) -> [a] -> Bool
all2 p (x:xs)
| p x == False = False
| otherwis
浏览 0提问于2019-03-27得票数 4
回答已采纳
5回答
在无限列表上左和右折叠
、、、、
我对 (伟大的书imo，而不是反驳它)的以下段落有异议：
一个很大的区别是右折叠在无限大的列表上工作，而左边的则不工作！直截了当地说，如果你在某个时候取了一个无限的列表，然后从右边折叠起来，你最终会到达列表的开头。然而，如果你在一个点上取了一个无限的列表，然后你试图把它从左边折叠起来，你就永远不会到达终点！
我只是不明白。如果你把一个无限的列表从右边折叠起来，那么你就必须从无穷远处开始，这是不可能发生的(如果有人知道你可以这样做的语言，那就说明:p)。至少，根据Haskell的实现，您必须从那里开始，因为在Haskell中，foldr和foldl不采用确定列表中应该从何处开始折叠的参数
浏览 0提问于2011-09-13得票数 73
回答已采纳
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
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
回答已采纳
我相信我用foldr写了foldl：
myFoldl :: (a -> b -> a) -> a -> [b] -> a
myFoldl f base xs = foldr (flip f) base (reverse xs)
这是一个惯用的实现吗？
浏览 0提问于2014-10-10得票数 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
回答已采纳
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
回答已采纳
我已经写了下面的代码，它创建了一个无限的斐波那契数列表：
fibs = 1:1:fib 1 1
where fib a b = a+b:fib b (a+b)
上面的代码可以用foldl或foldr编写来避免递归吗？
浏览 2提问于2012-09-06得票数 7
回答已采纳
我们有那个。这一点在中有详细的解释。该文件指出：
相反，不可能从fold的角度重新定义foldl，因为foldl的list参数的尾部很严格，而fold则不是。
然而，我看不出这是如何证明用foldr定义foldl是不可能的(请注意，在最初的文章中，fold是foldr的同义词)。我很困惑，想弄明白严格在这里起着怎样的作用。有人能详细解释一下这个解释吗？
浏览 5提问于2017-01-16得票数 5
回答已采纳
有一段时间以来，我一直试图把脑袋绕在折叠式和折叠式上，我已经决定了下面的问题应该为我解决。假设将以下列表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
回答已采纳
在我的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
回答已采纳
1回答
当使用foldr时，递归发生在函数内部，因此，当给定的函数不严格计算双方，并且可以根据第一方返回时，foldr必须是一个很好的解决方案，因为它将在无穷大列表上工作。
findInt :: Int -> [Int] -> Bool
findInt z [] = False
-- The recursion occours inside de given function
findInt z (x:xs)
| z == x = True
| otherwise = findInt z xs
相当于：
findInt' :: Int -> [Int] ->
浏览 2提问于2015-07-09得票数 1
回答已采纳
我知道在Haskell中，有intercalate函数连接两个列表。
intercalate ", " ["Hello", "world"]
会给："Hello, world"
我正在尝试使用foldr连接两个列表。
但既然我是哈斯克尔的新手，我不知道该怎么做。
我相信这个函数应该是这样的：
inters n xs = foldr (\x acc -> x ++ str ++ acc) "" xs
这给出了结果："Hello, world, "，其中逗号和空格也被添加到末尾。
如何使函数只在列
浏览 0提问于2018-06-09得票数 0
回答已采纳
1回答
好的，我对方案/球拍/lisp是新手。我正在练习创建自己的函数、语法和递归，所以我想制作自己的foldl和foldr函数，它们的功能与预定义的版本完全相同。我不能这样做，因为我不明白这些函数是如何工作的。我在这里看到了类似的问题，但我仍然不明白。一些分解的例子会有所帮助！下面是我的(不正确的)过程：
我做0 -(4-3-2-1)并得到2，这是正确的答案
我做了0-(1-2-3-4)，得到了8，但应该是-2。
我做了0-(1-2-3-4)，又得到了8，但它应该是-2。
我做0-(4-3-2-1)，得到2，这是正确的答案。
我做错了什么？
浏览 2提问于2017-02-10得票数 6
回答已采纳
3回答
假设我有以下函数：
sumAll :: [(Int,Int)] -> Int
sumAll xs = foldr (+) 0 (map f xs)
where f (x,y) = x+y
sumAll [(1,1),(2,2),(3,3)]的结果将是12。
我不明白的是(x,y)的值是从哪里来的。好吧，我知道它们来自xs变量，但我不明白是怎么回事。我的意思是，在没有where关键字的情况下直接执行上面的代码，应该是这样的：
sumAll xs = foldr (+) 0 (map (\(x,y) -> x+y) xs)
我不明白，在上面的代码中，f变量和(x,y)变量是如何表示
浏览 1提问于2008-12-18得票数 3
回答已采纳
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
回答已采纳
我看过不同的褶皱和折叠，以及其他一些，他们解释得相当好。
在这种情况下，我仍然很难理解它的工作原理。
length :: [t] -> Int
length list = foldr (+) 0 (map (\x ->1) list)
能不能有人一步一步地试着向我解释。
还有折叠式也会如何工作。
浏览 2提问于2017-01-18得票数 0
回答已采纳
我想测试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
回答已采纳
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
回答已采纳
我们被要求回答foldr或foldl是否更有效。
我不确定，但这不取决于我正在做什么，特别是我想达到我的职能？
是否有不同的情况或可以说foldr或foldl更好，因为.
有一般的答案吗？
提前感谢！
浏览 3提问于2013-12-03得票数 15
回答已采纳
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更普遍，但这是我要用的语言。)
foldl和foldr之间的区别似乎取决于列表是有序的。也就是说，foldl和foldl通过将函数应用于起始值和第一个或最后一个元素，然后应用于第一个应用程序和第二个或第二个到最后元素的结果，然后将第二个应用程序的结果应用到第三个或第三个到最后元素，从而折叠列表，等等。
但是，Haskell的Data.Set和Data.Map库定义了它们自己的foldl和foldr版本。例如，对于地图，它们是：
foldr :: (a -> b -> b) -> b -> Map k a -> b
foldl :: (b
浏览 1提问于2018-12-07得票数 5
回答已采纳
2回答
foldr (折叠-右)基本上是按列表中存储的值从右到左顺序执行的递归计算。而foldl与foldr正好相反。我想知道人们能使用foldr实现foldl函数吗？任何想法都是感激的，谢谢。
浏览 0提问于2018-10-20得票数 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
回答已采纳
我想看看这两个函数之间的区别：
dupli = foldl (\acc x -> acc ++ [x,x]) []
dupli = foldr (\ x xs -> x : x : xs) []
我知道foldl和foldr之间的区别，但是对于我看过的关于它如何工作的例子(使用(+) )，除了求和方法之外，它看起来是一样的。
为什么
dupli = foldr (\acc x -> acc ++ [x,x]) []
给出
/workspaces/hask_exercises/exercises/src/Lib.hs:142:27: error:
* Occurs ch
浏览 3提问于2021-05-19得票数 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
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
