foldTree 逐步评估

Question

假设foldTree、Tree 和函数f 的这些定义：

foldTree : (a -> [b] -> b) -> Tree a -> b
foldTree f = go
    where
        go (Node x ts) = f x (map go ts)

tree :: Tree String
tree = Node
      "Alpha"
      [ Node "Beta" [Node "Epsilon" [], Node "Zeta" [], Node "Eta" []]
      , Node "Gamma" [Node "Theta" []]
      , Node "Delta" [Node "Iota" [], Node "Kappa" [], Node "Lambda" []]
      ]

f x xs = [x] <> (map ('\t' :) (concat xs))

我会尝试评估foldTree f tree：

  foldTree f tree
= go (Node "Alpha" [ Node "Beta" [Node "Epsilon" [], Node "Zeta" [], Node "Eta" []], Node "Gamma" [Node "Theta" []], Node "Delta" [Node "Iota" [], Node "Kappa" [], Node "Lambda" []]]
= f "Alpha" (map go [...])
...

此时，我的问题是：等式推理如何与闭包一起工作？ go的定义有f；但是，这肯定不在其参数之间。是否有一些技巧可以插入该定义？

Answer 1

简单地说，定义可以引用范围内的任何名称。

“闭包” 是一个与突变存在更相关的概念。在没有的 Haskell 中，“范围” 的概念就足够了。

go 的定义嵌套在foldTree 的定义中，因此可以访问其参数f。也就是说，在go的定义中，f在作用域内。

定义可以改写为

{-
foldTree f t = go t
    where
         go (Node x ts) = f x (map go ts)
-}
foldTree f t =
   let { go (Node x ts) = f x (map go ts) } 
   in go t

并且任何调用 foldTree f1 t1 都被评估为

> foldTree f1 t1 
=>
  let { f=f1; t=t1 }
  in
    let { go (Node x ts) = f x (map go ts) } 
    in go t
=>
  ....

这些是简单的嵌套lets，因此内部的可以访问外部定义的每个名称。

为了更容易了解发生了什么，请先尝试使用更简单的示例数据进行评估，例如 Node "Alpha" []、Node "Alpha" [Node "Beta" []] 等。

---

例如，用

f0 x xs = [x] <> (map ('\t' :) (concat xs))

Node "Alpha" [] 的评估结果为

> foldTree f0 (Node "Alpha" []) 
=>
  let { f=f0; t=Node "Alpha" [] }
  in
    let { go (Node x ts) = f x (map go ts) } 
    in go t
=>
  let { f x xs = [x] <> (map ('\t' :) (concat xs))
      ; go (Node x ts) = f x (map go ts) 
      } 
  in go (Node "Alpha" [])
=>
  let { f x xs = [x] <> (map ('\t' :) (concat xs))
      ; go (Node x ts) = f x (map go ts) 
      ; (Node x1 ts1) = (Node "Alpha" [])
      } 
  in f x1 (map go ts1)
=>
  let { f x xs = [x] <> (map ('\t' :) (concat xs))
      ; go (Node x ts) = f x (map go ts) 
      ; x1 = "Alpha"
      ; ts1 = []
      ; xs1 = map go ts1
      } 
  in [x1] <> (map ('\t' :) (concat xs1))
=>
  ["Alpha"] <> (map ('\t' :) (concat []))
=>
  ["Alpha"] <> (map ('\t' :) [])
=>
  ["Alpha"] <> []
=>
  ["Alpha"]