Question

在haskell wiki的“编程提示”部分，我找到了这个例子：

if (A == SomeValue)
    A = SomeOtherValue;

据说这是

的更好替代品

count :: (a -> Bool) -> [a] -> Int
count p = length . filter p

在可读性方面，我完全同意。

但是，这不是一个双遍历，因此实际上比显式递归函数更糟糕吗？ GHC中的懒惰是否意味着这相当于优化后的单个遍历？哪种实现更快，为什么？

Answer 1

为了看看优化器实际上做了什么，让我们look at the core：

% ghc -O2 -ddump-simpl Temp.hs
[1 of 1] Compiling Temp             ( Temp.hs, Temp.o )

==================== Tidy Core ====================
Result size of Tidy Core = {terms: 29, types: 26, coercions: 0}

Temp.count
  :: forall a_arN.
     (a_arN -> GHC.Types.Bool) -> [a_arN] -> GHC.Types.Int
[GblId,
 Arity=2,
 Caf=NoCafRefs,
 Str=DmdType <L,C(U)><S,1*U>,
 Unf=Unf{Src=<vanilla>, TopLvl=True, Arity=2, Value=True,
         ConLike=True, WorkFree=True, Expandable=True,
         Guidance=IF_ARGS [60 0] 191 0}]
Temp.count =
  \ (@ a_aMA)
    (p_arV :: a_aMA -> GHC.Types.Bool)
    (eta_B1 :: [a_aMA]) ->
    letrec {
      go_aNr [Occ=LoopBreaker]
        :: [a_aMA] -> GHC.Prim.Int# -> GHC.Types.Int
      [LclId, Arity=1, Str=DmdType <S,1*U>]
      go_aNr =
        \ (ds_aNs :: [a_aMA]) ->
          case ds_aNs of _ [Occ=Dead] {
            [] -> GHC.Types.I#;
            : y_aNx ys_aNy ->
              case p_arV y_aNx of _ [Occ=Dead] {
                GHC.Types.False -> go_aNr ys_aNy;
                GHC.Types.True ->
                  let {
                    g_a10B [Dmd=<L,C(U)>] :: GHC.Prim.Int# -> GHC.Types.Int
                    [LclId, Str=DmdType]
                    g_a10B = go_aNr ys_aNy } in
                  \ (x_a10C :: GHC.Prim.Int#) -> g_a10B (GHC.Prim.+# x_a10C 1)
              }
          }; } in
    go_aNr eta_B1 0

稍微清理一下：

Temp.count :: forall aType.  (aType -> Bool) -> [aType] -> Int
Temp.count = \(@ aType) (p :: aType -> Bool) (as :: [aType]) ->
  letrec {
    go :: [aType] -> GHC.Prim.Int# -> Int
    go = \(xs :: [aType]) ->
      case xs of _ {
        [] -> I#; -- constructor to make a GHC.Prim.Int# into an Int
        : y ys ->
          case p y of _ {
            False -> go ys;
            True ->
              let {
                go' :: GHC.Prim.Int# -> Int
                go' = go ys 
              } in \(x :: GHC.Prim.Int#) -> go' (GHC.Prim.+# x 1)
          }
      }; 
  } in go as 0

由于我们正在对未装箱的GHC.Prim.Int#，all the additions are strict进行操作，因此我们只有一个循环数据。

Answer 2

无论哪种方式，您都必须对每个项目执行一次或两次操作。必要的是检查谓词。添加1的第二个取决于谓词的结果。

因此，如果您不考虑缓存等的影响，两种情况都会产生相同数量的操作。

获得的图片是在第一种情况下有两个单独的遍历，一个收集元素，一个计算它们。给定一个大于缓存可以处理的列表，这将减慢处理速度。这实际上是以严格语言发生的。

然而，哈斯克尔的懒惰在这里出现了。 filter生成的列表将逐个元素地计算（生成），因为计数函数length需要它。然后，当length仅将它们用于计数并且不保留对新创建的列表的引用时，元素立即可以自由地被垃圾收集。因此，在任何时候，计算过程中只占用O(1)个内存。

构建结果＆＃34;过滤＆＃34;有一点点开销。在第一个版本中列出。但是，与列表较大时出现的缓存效果相比，这通常可以忽略不计。（对于小列表，它可能很重要;这需要进行测试。）此外，它可能会根据编译器和所选的优化级别进行优化。

更新。第二个版本实际上会消耗内存，正如其中一条评论所指出的那样。为了公平比较，您需要在正确的位置使用累积参数和严格注释器来编写它，因为（我希望）length已经以这种方式编写。

Answer 3

您可以使用profiling测试哪个版本更快，例如：

module Main where


main :: IO ()
main = print countme'

count' :: (a -> Bool) -> [a] -> Int
count' p = length . filter p

count :: (a -> Bool) -> [a] -> Int
count _ [] = 0
count p (x:xs)
   | p x       = 1 + count p xs
   | otherwise =     count p xs


list = [0..93823249]

countme' = count' (\x -> x `mod` 15 == 0) list
countme = count (\x -> x `mod` 15 == 0) list

然后运行ghc -O2 -prof -fprof-auto -rtsopts Main.hs和./Main +RTS -p。它将生成文件 Main.prof 。然后更改main函数以使用countme代替并比较结果。我的是：

4.12s
6.34s 用于显式版本

如果关闭优化，那么隐含的优化仍然会稍微（但不会太快）。

除了其他人已经解释过的融合和懒惰之外，我想另一个原因可能是length和filter是Prelude函数，可以由编译器更好地优化。

这不是一次双遍吗？

3 个答案: