anchor.diff:          | Bin(p, m, l, r) when m < 0 -> let (result, r) = go r in Some(result, bin p m l r)
           | _ -> Some(go t)
   
  +    ///O(log n). Update the value at the maximal key. Credit: Haskell.org
       let updateMax f = updateMaxWithKey (konst f)
   
  +    ///O(log n). Update the value at the minimal key. Credit: Haskell.org
       let updateMin f = updateMinWithKey (konst f)
   
       let private first f (x, y) = (f x, y)
   
  +    ///O(min(n,W)). Retrieves the maximal key of the map, and the map stripped of that element, or Nothing if passed an empty map. Credit: Haskell.org
       let maxView t = Option.map (first snd) (maxViewWithKey t)
   
  +    ///O(min(n,W)). Retrieves the minimal key of the map, and the map stripped of that element, or Nothing if passed an empty map. Credit: Haskell.org
       let minView t = Option.map (first snd) (minViewWithKey t)
   
  +    ///O(log n). Retrieves the maximal key of the map, and the map stripped from that element. Credit: Haskell.org
       let deleteFindMax t = Option.getOrElseF (fun _ -> failwith "deleteFindMax: empty map has no maximal element") << maxViewWithKey <| t
   
  +    ///O(log n). Retrieves the minimal key of the map, and the map stripped from that element. Credit: Haskell.org
       let deleteFindMin t = Option.getOrElseF (fun _ -> failwith "deleteFindMin: empty map has no minimal element") << minViewWithKey <| t
   
  +    ///O(log n). The minimal key of the map. Credit: Haskell.org
       let findMin t =
           let rec go =
               function
  
positive.code:             else let (lt, fnd, gt) = go k r in let gt = append gt l in (lt, fnd, gt)
          | _ -> go k t
  
      let foldBack f z =
          let rec go z =
              function
  
negative.code:             else let (lt, gt) = go k r in let gt = append gt l in (lt, gt)
          | _ -> go k t
  
      ///O(log n). Performs a split but also returns whether the pivot key was found in the original map. Credit: Haskell.org
      let splitTryFind k t =
          let rec go k t =
              match t with
  