Haskell

Question

我正在尝试使用 foldr 为函数 all 创建一个函数定义。 p 是谓词。我知道这是可以做到的：

all p = and . foldr (\x xs -> p x : xs) []

但我想做的是将函数 and 移入 foldr 方程。这能做到吗？

我尝试了以下方法，但都失败了：

all p = foldr (\x p -> \ys -> and (p x) ys) True
all p = foldr (\x and -> (\ys -> (p x and ys))) True
all p = foldr (\x ys -> and . (p x) ys) True

我对如何申请的理解是否不够foldr？

Answer 1

我们有

all p = and 
         . foldr (\x xs -> p x :  xs) []    
      = foldr                 (&&)   True   -- {y : ys} -> y && {ys}      2-3
         . foldr (\x xs -> p x :  xs) []    -- {x , xs} -> p x : {xs}   1-2
      =    foldr (\x xs -> p x && xs) True  -- {x , xs} -> p x && {xs}  1---3

因为折叠用指定的组合操作（aka reducer）替换每个构造函数，并用 cons 替换元素的 cons =26=]cons 修改后的元素，然后将 cons 替换为 (&&)，只是替换 cons 元素的 (&&) 立即被修改的元素：

    a  : (  b  : (  c  : (  d  : ( ... ))))   _OR_   []      --   |       |   1
                                                             --   |       |
  p a  : (p b  : (p c  : (p d  : ( ... ))))   _OR_   []      --   ↓   |   |   2
                                                             --       |   |
  p a && (p b && (p c && (p d && ( ... ))))   _OR_  True     --       ↓   ↓   3

换句话说，折叠通过融合它们的 reducer 函数来组合，而 reducer 函数通过将{他们使用的构造函数}替换为折叠链中下一个折叠的 reducer 来融合，以便它们相应的 转换器 组合（如在 Clojure 的转换器中）；因此，

 = foldr              (reducingWith (&&)) True
     . foldr ((mapping p)    (:))           []
 = foldr ((mapping p) (reducingWith (&&))) True
 = foldr ((mapping p . reducingWith) (&&) ) True
   -- first map p, then reduce with (&&)

对于reducingWith和mapping的适当定义：

reducingWith cons x xs = cons x xs
mapping f cons x xs = cons (f x) xs
filtering p cons x xs | p x = cons x xs
                      | otherwise = xs
concatting t cons x xs = foldr cons xs (t x)

Haskell - 使用 foldr 为函数 `all` 创建函数定义

Haskell - creating a function definition for the function `all` using foldr

predicate

fold