Question

有些情况我不明白 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 []) 的定义（元素和空列表）相比翻转

Answer 1

<块引用>

为什么 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, b, c, d]
==
f (f (f (f z a) b) c) d  -- accumulator on the left (first argument)

Answer 2

那是部分函数应用。

.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。

理解实现 foldr 和 foldl 的函数

2 个答案: