anchor.diff:                          code, go (Array.ofSeq deals) fts
                       )
                       |> conf.BuildMap
  -                Tree.Node {
  -                    Level = level; 
  -                    AllElements = Some [|items|]; 
  -                    Children = children
  -                }
  +                Tree.Node {Level = level; Children = children}
           go (Array.ofSeq elements) levels
   
       /// Extract all elements from a tree.
       let elements (tree: Tree<'K,'L,'T>) =
  -        match tree with
  -        | Leaf x -> 
  -            [|x|]
  -        | Node n ->
  -            // Check if elements are accumulated.
  -            match n.AllElements with
  -            | Some xs   ->
  -                xs
  -            | None      ->
  -                // Collect all elements
  -                let rec go = function
  -                    | Tree.Leaf x   ->
  -                        [|x|]
  -                    | Tree.Node n   -> 
  -                        Array.collect (snd >> go) <| n.Children.Elements()
  -                go tree
  -
  -
  +        let rec go = function
  +            | Tree.Leaf x   ->
  +                [|x|]
  +            | Tree.Node n   -> 
  +                Array.collect (snd >> go) <| n.Children.Elements()
  +        go tree
positive.code:         {
              /// Filter type
              Level : 'L
  
              /// All items
              AllElements : option<'T []>
  
              /// Child nodes
              Children : IRangeMap<'K, Tree<'K,'L,'T>>
  
negative.code:                 ]
          go >> P.run
  
      /// Configurations for building a tree.    
      type IBuildTreeConfiguration =
          abstract BuildMap<'K,'V when 'K : comparison> : seq<'K * 'V> -> IRangeMap<'K,'V>
  
  