列表长度的 Haskell 函数

Question

要使用折叠器计算列表的长度，可以执行以下操作：

foldr (\_ acc -> acc + 1) 0

进一步扩展折叠函数需要增加第二个参数的想法，我想出了这个（这是错误的）：

foldr ((+1) . (flip const)) 0`

对类型的进一步检查揭示了这一点：

(+1) . (flip const) :: Num (c -> c) => a -> c -> c

Haskell higher order function to calculate length 该页面上有一条有趣的评论，我真的无法理解

foldr (((+1).).(flip const)) 0

有人能解释一下这个组合是如何工作的吗？

Answer 1

首先，让我们关注为什么foldr ((+1) . (flip const)) 0 是错误的。您只想增加第二个参数而忘记第一个参数。从语义上讲，就是

\_ a -> a + 1

但是，您写了以下内容：

(+1) . flip const
= (+1) . (\_ a -> a)
= \x -> (+1) . (\_ a -> a) $ x
= \x -> (+1) $ (\_ a -> a) $ x
= \x -> (+1) $ \a -> a
= \_ -> (+1) (\a -> a)
= const ( (+1) (\a -> a))

这就是为什么你突然需要Num (c -> c)，因为你试图在id 上应用(+1)。

但实际上你的意思是：

\_ a -> a + 1
= \_ a -> (+1) a
= \_   -> (+1)
= const (+1)

毕竟，您想忘记第一个参数并在第二个参数上使用函数f。您所要做的就是使用const f。

组合((+1).).(flip const)过于冗长，可能由pointfree生成：

((+1).).(flip const)
= ((\x -> x + 1).) . (\a _ -> a)
= \c -> ((\x -> x + 1).) . (\a _ -> a) $ c
= \c -> ((\x -> x + 1).) $ \_ -> c
= \c -> \f -> (\x -> x + 1) . f $ \_ -> c
= \c ->   (\x -> x + 1) . \_ -> c
= \_ c -> (\x -> x + 1) $ c
= \_ c -> c + 1

Answer 2

这确实是一个评论，但对一个人来说太长了。

除非你正在处理像懒惰的Nats 这样的奇怪数字，否则你真的想要

length xs = foldl' (\acc _ -> 1 + acc) 0 xs

让这毫无意义，

length = foldl' (\acc -> const ((1+) acc)) 0
length = foldl' (const . (1+)) 0

如果您愿意，可以将原来的foldl' 表达式转换为foldr 形式，如下所示：

length xs = foldr go id xs 0 where
  go _ r acc = r $! 1 + acc

咀嚼go，

go _ r acc = ($!) r $ (+) 1 acc
go _ r = ($!) r . (+1)
go _ r = (. (+1)) (($!) r)
go _ = (. (+1)) . ($!)
go = const ((. (+1)) . ($!))

咀嚼length，

length = flip (foldr go id) 0

把它们放在一起，

length = flip (foldr (const ((. (+1)) . ($!))) id) 0

首先，我发现这种无点形式完全不透明。