问题描述
有些情况我不明白 foldr
和 foldl
在函数中是如何使用的。
这里有几个例子,然后我解释为什么我不理解它们:
-- Two implementation of filter and map
map' f = foldr (\x acc -> (f x):acc) []
map'' f xs = foldl (\acc x -> acc ++ [(f x)]) [] xs
filter' f xs = foldr(\x acc -> if(f x) then x:acc else acc) [] xs
filter'' f = foldl(\acc x -> if(f x) then acc++[x] else acc) []
为什么 map''
使用 xs
而不是 map'
? map'
难道不应该也需要列表推导公式的列表吗?
filter'
与 filter''
的情况相同。
这是一个按排序顺序插入元素的实现:
insert e [] = [e]
insert e (x:xs)
| e > x = x: insert e xs
| otherwise = e:x:xs
sortInsertion xs = foldr insert [] xs
sortInsertion'' xs = foldl (flip insert) [] xs
为什么 insert
的参数在 sortInsertion
([] xs
)(空列表和列表)中与 insert(e []) 的定义(元素和空列表)相比翻转
解决方法
为什么 map''
使用 xs
而不是 map'
? map'
不应该也需要列表理解公式的列表吗? filter'
与 filter''
的情况相同。
这被称为“eta-reduction”,它是一种省略冗余参数名称的常用方法(“point-free style”)。基本上只要你有一个函数,它的主体只是一个函数对其参数的应用,你可以减少参数:
add :: Int -> Int -> Int
add x y = x + y
-- “To add x and y,call (+) on x and y.”
add :: (Int) -> (Int) -> (Int)
add x y = ((+) x) y
-- “To add x,call (+) on x.”
add :: (Int) -> (Int -> Int)
add x = (+) x
-- “To add,call (+).”
add :: (Int -> Int -> Int)
add = (+)
更准确地说,如果您有 f x = g x
,其中 x
没有出现在 g
中,那么您可以写成 f = g
。
一个常见的错误是想知道为什么 f x = g . h x
不能写成 f = g . h
。它不符合模式,因为 (.)
运算符是 f
主体中的顶级表达式:它实际上是 f x = (.) g (h x)
。您可以将其写为 f x = (((.) g) . h) x
,然后使用 f = (.) g . h
的 f = fmap g . h
实例将其缩减为 Functor
或 ->
,但是这被认为不太可读。
为什么插入的参数在 sortInsertion
中翻转了
foldr
和 foldl
的函数参数有不同的参数顺序:
foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b
foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b
或者,使用更详细的类型变量名称:
foldr
:: (Foldable container)
=> (element -> accumulator -> accumulator)
-> accumulator -> container element -> accumulator
foldl
:: (Foldable container)
=> (accumulator -> element -> accumulator)
-> accumulator -> container element -> accumulator
这只是折叠关联方向的助记符:
foldr f z [a,b,c,d]
==
f a (f b (f c (f d z))) -- accumulator on the right (second argument)
foldl f z [a,d]
==
f (f (f (f z a) b) c) d -- accumulator on the left (first argument)
,
那是部分函数应用。
.ProjectTitle1 {
padding-right: 9px;
padding-left: 9px;
padding-bottom: 4px;
padding-top: 4px;
color: white;
font-weight: 700;
z-index: 1;
position: absolute;
top: -84px;
right: 0px;
background-color: #aa1a18;
backdrop-filter: blur(20px);
-webkit-backdrop-filter: blur(20px);
box-shadow: var(--main-top-shadow);
box-shadow: var(--main-shadow);
}
和
一样map' f = foldr (\x acc -> (f x):acc) []
如果两边都省略 map' f xs = foldr (\x acc -> (f x):acc) [] xs
。
然而,除了这个解释,我认为你需要一本 Haskell 的初学者书籍。考虑LYAH。