anchor.diff:      //
       member __.FoldBack (folder : int -> 'T -> 'State -> 'State, state : 'State) : 'State =
           trie.FoldBack (folder, state)
  -
  -
   
   
   //
  
positive.code:         map.FoldBack (folder, state)
  
  
      // TODO
      // choose
      // exists
      // filter
      // findKey
      // map
      // partition
      // pick
      // toSeq
      // tryFindKey
  
negative.code: 
  //
  module internal BitOps =
      //
      let inline zeroBit (k, m) : bool =
          k &&& m = GenericZero
  
      //
      let inline mask (k, m) =
          (k ||| (m - GenericOne)) &&& ~~~m
  
      //
      let inline matchPrefix (k, p, m) =
          mask (k, m) = p
  
      //
      let inline lowestBit (x : int) : uint32 =
          uint32 (x &&& -x)
  
      // Returns the greatest power-of-two value contained within 'x'.
      let inline private highestBit (x, m) =
          // Zero all bits below m
          let x' = x &&& ~~~(m - 1u)
  
          let rec highb x =
              let m = lowestBit (int x)
              if x = m then m
              else highb (x - m)
  
          highb x'
  
      /// Finds the first bit at which p0 and p1 disagree.
      /// Returns a power-of-two value containing this (and only this) bit.
      let inline branchingBit (p0, p1) : uint32 =
          highestBit (p0 ^^^ p1, 1u)
  
  
      (* TODO :   Re-implement the 'highestBit' function using the Count Leading Zeros (clz) operation.
                  This should be significantly faster than our current implementation (or even Okasaki's
                  original implementation, since 'clz' can be implemented by just a few operations
  