anchor.diff:      //
       member __.Iterate (action : int -> 'T -> unit) : unit =
           trie.Iterate action
  +
  +    //
  +    member __.IterateBack (action : int -> 'T -> unit) : unit =
  +        trie.IterateBack action
  +
  +    //
  +    member __.Fold (folder : 'State -> int -> 'T -> 'State, state : 'State) : 'State =
  +        trie.Fold (folder, state)
  +
  +    //
  +    member __.FoldBack (folder : int -> 'T -> 'State -> 'State, state : 'State) : 'State =
  +        trie.FoldBack (folder, state)
   
   //
   and [<Sealed>]
  
positive.code:             // Add the initial tree to the stack.
              stack.Push t
  
              /// Recursively processes the tree using the mutable stack.
              // OPTIMIZE : We don't really need to use a recursive function here -- we could just
              // use a mutable variable for 'acc' and change this to a while loop.
              let rec fastCount acc =
                  if stack.Count = 0 then acc
                  else
                      match stack.Pop () with
                      | Empty ->
                          fastCount acc
                      | Lf (_,_) ->
                          fastCount (acc + 1u)
                      
                      (* OPTIMIZATION :   When one or both children of this node are leaves, we handle
                                          them directly since it's a little faster. *)
                      | Br (_, _, Lf (_,_), Lf (_,_)) ->
                          fastCount (acc + 2u)
                      
                      | Br (_, _, Lf (_,_), child)
                      | Br (_, _, child, Lf (_,_)) ->
                          stack.Push child
                          fastCount (acc + 1u)
  
                      | Br (_, _, left, right) ->
                          // Push both children onto the stack and recurse to process them.
                          stack.Push left
                          stack.Push right
                          fastCount acc
  
              fastCount 0u
  
      //
      static member Remove (key, map : PatriciaMap<'T>) =
  
negative.code:             | Br (p, m, t0, t1) as t ->
                  if matchPrefix (key, p, m) then
                      if zeroBit (key, m) then
                          let left = ins t0
                          Br (p, m, left, t1)
                      else
                          let right = ins t1
                          Br (p, m, t0, right)
                  else
                      PatriciaMap.Join (key, Lf (key, value), p, t)
  
  