foldTree 分步评估

简单地说，一个定义可以指代范围内的任何名称。

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

go的定义嵌套在 的 中，因此可以访问其参数。换句话说，在 的定义中，在范围内。foldTreefgof

定义可以改写为

{-
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
=>
  ....

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

为了更容易地了解发生了什么，请尝试首先使用更简单的示例数据（如 、 等）对其进行评估。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"]