foldr在Haskell中返回列表

我正在阅读并理解当我们返回一个数字时，

foldr

是如何工作的

sum' :: (Num a) => [a] -> a  
sum' xs = foldl (\acc x -> acc + x) 0 xs 

ghci> sum' [3,5,2,1]  
11

现在我需要

foldr

返回一个列表，但我无法运行此代码

map' :: (a -> b) -> [a] -> [b]  
map' f xs = foldr (\x acc -> f x : acc) [] xs 

我不知道什么是

f

。

也许这有帮助：

map' succ [1,2,3]
= foldr (\x acc -> succ x : acc) [] [1,2,3]
= foldr (\x acc -> succ x : acc) [] [1,2,3]
= (\x acc -> succ x : acc) 1 (foldr (\x acc -> succ x : acc) [] [2,3])
= succ x : acc  where x=1 ; acc=foldr (\x acc -> succ x : acc) [] [2,3]
= succ 1 : foldr (\x acc -> succ x : acc) [] [2,3]
= succ 1 : (\x acc -> succ x : acc) 2 (foldr (\x acc -> succ x : acc) [] [3])
= succ 1 : succ 2 : foldr (\x acc -> succ x : acc) [] [3]
= succ 1 : succ 2 : (\x acc -> succ x : acc) 3 (foldr (\x acc -> succ x : acc) [] [])
= succ 1 : succ 2 : succ 3 : foldr (\x acc -> succ x : acc) [] []
= succ 1 : succ 2 : succ 3 : []
= 2 : 3 : 4 : []
= [2,3,4]

也许这有助于：

map' succ [1,2,3]
= foldr (\x acc -> succ x : acc) [] [1,2,3]
= foldr (\x acc -> succ x : acc) [] [1,2,3]
= (\x acc -> succ x : acc) 1 (foldr (\x acc -> succ x : acc) [] [2,3])
= succ x : acc  where x=1 ; acc=foldr (\x acc -> succ x : acc) [] [2,3]
= succ 1 : foldr (\x acc -> succ x : acc) [] [2,3]
= succ 1 : (\x acc -> succ x : acc) 2 (foldr (\x acc -> succ x : acc) [] [3])
= succ 1 : succ 2 : foldr (\x acc -> succ x : acc) [] [3]
= succ 1 : succ 2 : (\x acc -> succ x : acc) 3 (foldr (\x acc -> succ x : acc) [] [])
= succ 1 : succ 2 : succ 3 : foldr (\x acc -> succ x : acc) [] []
= succ 1 : succ 2 : succ 3 : []
= 2 : 3 : 4 : []
= [2,3,4]

也许这有助于：

map' succ [1,2,3]
= foldr (\x acc -> succ x : acc) [] [1,2,3]
= foldr (\x acc -> succ x : acc) [] [1,2,3]
= (\x acc -> succ x : acc) 1 (foldr (\x acc -> succ x : acc) [] [2,3])
= succ x : acc  where x=1 ; acc=foldr (\x acc -> succ x : acc) [] [2,3]
= succ 1 : foldr (\x acc -> succ x : acc) [] [2,3]
= succ 1 : (\x acc -> succ x : acc) 2 (foldr (\x acc -> succ x : acc) [] [3])
= succ 1 : succ 2 : foldr (\x acc -> succ x : acc) [] [3]
= succ 1 : succ 2 : (\x acc -> succ x : acc) 3 (foldr (\x acc -> succ x : acc) [] [])
= succ 1 : succ 2 : succ 3 : foldr (\x acc -> succ x : acc) [] []
= succ 1 : succ 2 : succ 3 : []
= 2 : 3 : 4 : []
= [2,3,4]

也许这有助于：

map' succ [1,2,3]
= foldr (\x acc -> succ x : acc) [] [1,2,3]
= foldr (\x acc -> succ x : acc) [] [1,2,3]
= (\x acc -> succ x : acc) 1 (foldr (\x acc -> succ x : acc) [] [2,3])
= succ x : acc  where x=1 ; acc=foldr (\x acc -> succ x : acc) [] [2,3]
= succ 1 : foldr (\x acc -> succ x : acc) [] [2,3]
= succ 1 : (\x acc -> succ x : acc) 2 (foldr (\x acc -> succ x : acc) [] [3])
= succ 1 : succ 2 : foldr (\x acc -> succ x : acc) [] [3]
= succ 1 : succ 2 : (\x acc -> succ x : acc) 3 (foldr (\x acc -> succ x : acc) [] [])
= succ 1 : succ 2 : succ 3 : foldr (\x acc -> succ x : acc) [] []
= succ 1 : succ 2 : succ 3 : []
= 2 : 3 : 4 : []
= [2,3,4]

看看类型：

map' :: (a -> b) -> [a] -> [b] 
map'       f        xs  =  ys   where ys = ...

f

是类型为

a->b

的函数：

f :: a -> b
f    x =  y   where y = ...

也就是说，给定

a

类型的

x

，它会产生

b

类型的

y

。所以

map'f

有一个类型

[a]->[b]

map' :: (a -> b) -> [a] -> [b] 
map'       f        xs  =  ys   where ys = ...
map'       f     :: [a] -> [b]

也就是说，给定类型为

[a]

的列表

xs

，它将生成类型为

[b]

的列表

ys

因此，无论您使用的是什么

f

，它都必须对应于要使用

map'f

的列表

xs

：它必须接受

xs

的元素作为参数。

查看类型：

map' :: (a -> b) -> [a] -> [b] 
map'       f        xs  =  ys   where ys = ...

f

是类型为

a->b

的函数：

f :: a -> b
f    x =  y   where y = ...

也就是说，给定

a

类型的

x

，它会产生

b

类型的

y

。所以

map'f

有一个类型

[a]->[b]

map' :: (a -> b) -> [a] -> [b] 
map'       f        xs  =  ys   where ys = ...
map'       f     :: [a] -> [b]

也就是说，给定类型为

[a]

的列表

xs

，它将生成类型为

[b]

的列表

ys

因此，无论您使用的是什么

f

，它都必须对应于要使用

map'f

的列表

xs

：它必须接受

xs

的元素作为参数。

查看类型：

map' :: (a -> b) -> [a] -> [b] 
map'       f        xs  =  ys   where ys = ...

f

是类型为

a->b

的函数：

f :: a -> b
f    x =  y   where y = ...

也就是说，给定

a

类型的

x

，它会产生

b

类型的

y

。所以

map'f

有一个类型

[a]->[b]

map' :: (a -> b) -> [a] -> [b] 
map'       f        xs  =  ys   where ys = ...
map'       f     :: [a] -> [b]

也就是说，给定类型为

[a]

的列表

xs

，它将生成类型为

[b]

的列表

ys

因此，无论您使用的是什么

f

，它都必须对应于要使用

map'f

的列表

xs

：它必须接受

xs

的元素作为参数。

查看类型：

map' :: (a -> b) -> [a] -> [b] 
map'       f        xs  =  ys   where ys = ...

f

是类型为

a->b

的函数：

f :: a -> b
f    x =  y   where y = ...

也就是说，给定

a

类型的

x

，它会产生

b

类型的

y

。所以

map'f

有一个类型

[a]->[b]

map' :: (a -> b) -> [a] -> [b] 
map'       f        xs  =  ys   where ys = ...
map'       f     :: [a] -> [b]

也就是说，给定类型为

[a]

的列表

xs

，它将生成类型为

[b]

的列表

ys

---

因此，无论您使用的是什么

f

，它都必须对应于您打算使用

map'f

的列表

xs

：它必须接受

xs

的元素作为参数。

您知道如何使用

map

？那个

map'

是普通

map

的重新实现，可以用同样的方式使用。你的实际问题是什么？既然你正在阅读指南，你应该知道

map

和一般的高阶函数。@Zeta，我只是不明白

\x acc->fx:acc

\x acc->fx:acc

的意思是：将

f

应用于

x

，以及

cons

对

acc

的回答。因此，如果例如，

f

是

（+1）

，

x

是

0

，

acc

是

[2,3]

，那么

f x:acc=>（+1）0:[2,3]=>1:[1,2,3]

@MaksimDmitriev也就是说，并且作为匿名函数运行。你知道如何使用

map

？那个

map'

是普通

map

的重新实现，可以用同样的方式使用。你的实际问题是什么？既然你正在阅读指南，你应该知道

map

和一般的高阶函数。@Zeta，我只是不明白

\x acc->fx:acc

\x acc->fx:acc

的意思是：将

f

应用于

x

，以及

cons

对

acc

的回答。因此，如果例如，

f

是

（+1）

，

x

是

0

，

acc

是

[2,3]

，那么

f x:acc=>（+1）0:[2,3]=>1:[1,2,3]

@MaksimDmitriev也就是说，并且作为匿名函数运行。你知道如何使用

map

？那个

map'

是普通

map

的重新实现，可以用同样的方式使用。你的实际问题是什么？既然你正在阅读指南，你应该知道

map

和一般的高阶函数。@Zeta，我只是不明白

\x acc->fx:acc

\x acc->fx:acc

的意思是：将

f

应用于

x

，以及

cons

对

acc

的回答。因此，如果例如，

f

是

（+1）

，

x

是

0

，

acc

是

[2,3]

，那么

f x:acc=>（+1）0:[2,3]=>1:[1,2,3]

@MaksimDmitriev也就是说，并且作为匿名函数运行。你知道如何使用

map

？那个

map'

是普通

map

的重新实现，可以用同样的方式使用。你的实际问题是什么？既然你正在阅读指南，你应该知道

map

和一般的高阶函数。@Zeta，我只是不明白

\x acc->fx:acc

\x acc->fx:acc

的意思是：将

f

应用于

x

，以及

cons

对

acc

的回答。因此，如果例如，

f

是

（+1）

，

x

是

0

，

acc

是

[2,3]

，那么

f x:acc=>（+1）0:[2,3]=>1:[1,2,3]=>。