这里计算了多少次（+ 1）？

Question

在我的函数式编程考试中，我有以下问题：

在下面的代码中计算了多少次（+ 1）函数？

(map (+ 1) [1 .. 10]) !! 5

index函数的定义如下：

(h:_) !! 0 = h
(_:t) !! x = t !! (x-1)

我会说6次，但正确的答案似乎是1，我无法理解为什么。 我找不到Haskell中懒惰评估的足够好的解释，所以我想知道什么是正确的答案以及为什么。 先感谢您！

Answer 1

很多次是(+ 1)函数在下面的代码中计算？

它只计算一次 。 map不强制计算结果列表中元素的fx i 。 这些计算被推迟（就像Haskell中的其他所有内容一样），只有当我们需要计算特定项目的值时，我们才会这样做。

map 在Haskell'10报告的第9章中指定为：

 -- Map and append map :: (a -> b) -> [a] -> [b] map f [] = [] map f (x:xs) = fx : map f xs 

这里没有seq ，bang模式等来强制评估fx ，所以map函数确实会“产生”一个fx ，但是没有评估fx ，它会被推迟到必要时（并且可能发生我们不是对这些值中的一些感兴趣，因此可以节省一些CPU周期）。

我们可以看看Haskell将如何评估这个：

   (!!) (map (+ 1) [1 .. 10]) 5
-> (!!) ((+1) 1 : map (+1) [2..10]) 5
-> (!!) (map (+1) [2..10]) 4
-> (!!) ((+1) 1 : map (+1) [3..10]) 4
-> (!!) (map (+1) [3..10]) 3
-> (!!) ((+1) 1 : map (+1) [4..10]) 3
-> (!!) (map (+1) [4..10]) 2
-> (!!) ((+1) 1 : map (+1) [5..10]) 2
-> (!!) (map (+1) [5..10]) 1
-> (!!) ((+1) 1 : map (+1) [6..10]) 1
-> (!!) (map (+1) [6..10]) 0
-> (!!) ((+1) 6 : map (+1) [7..10]) 0
-> (+1) 6
-> 7

这是因为map f [x1, x2, ..., xn]最终映射到一个列表[f x1, f x2, ..., f xn]但它不计算fx i的元素，那就是计算推迟到我们实际需要该列表中的值，然后对它做一些事情（比如引用它）。

如果f是一个昂贵的函数，这可以导致显着的性能提升，并且我们只需要列表中少量元素的值。

Answer 2

让我们通过做一些可怕的事来测试它。 您需要为此导入Debug.Trace模块。

ghci> (map (\x -> trace "Performing..." (x + 1)) [1..10]) !! 5

现在，每次调用lambda表达式时，我们都会得到完全安全的IO动作。 当我们在GHCi中运行时，我们得到了

Performing
7

所以只有一次。

作为一个完整性检查，我们可以删除!! 5 !! 5位

ghci> map (\x -> trace "Performing..." (x + 1)) [1..10]
[Performing
2,Performing
3,Performing
4,Performing
5,Performing
6,Performing
7,Performing
8,Performing
9,Performing
10,Performing
11]

因此，当我们要求整个列表时，肯定会发生10次。