anchor.diff:          let (centerTree, _) = rightTree |> Map.splitWithKey ((>=) (d+n+1))
           centerTree
   
  -    let rec existsDistance distance n a = function
  +    let rec private existsDistance distance n a = function
           | Empty -> false
           | Node(b, _, map) ->
               let d = distance a b
  
positive.code:                 let size = subtree |> Map.valueList |> List.map size |> List.sum |> (+) 1
                  Node(b, size, subtree)
  
      module Int =
  
          let distance i j = abs(i - j)
  
          let insert a tree = insert distance a tree
  
          let exists a tree = exists distance a tree
    
          let existsDistance n a tree = existsDistance distance n a tree
  
          let elemsDistance n a tree = elemsDistance distance n a tree
  
          let fromList xs = fromList distance xs
  
          let unions xs = unions distance xs
  
          let union t1 t2 = unions [t1; t2]
  
          let delete a tree = delete distance a tree
  
      module Char =
  
          let distance(i:char) (j:char) = abs((int i) - (int j))
  
          let insert a tree = insert distance a tree
  
          let exists a tree = exists distance a tree
  
          let existsDistance n a tree = existsDistance distance n a tree
  
          let elemsDistance n a tree = elemsDistance distance n a tree
  
          let fromList xs = fromList distance xs
  
          let unions xs = unions distance xs
  
          let union t1 t2 = unions [t1; t2]
  
          let delete a tree = delete distance a tree
  
      module List =
  
          let private hirschberg xs = function
              | [] -> List.length xs
              | ys ->
                  let lys = List.length ys
                  let startArr = [1..lys] |> List.map (fun x -> (x,x))
                  xs
                  |> Seq.zip (Seq.unfold (fun i -> Some(i+1, i+1)) 0)
                  |> Seq.toList
                  |> List.fold (fun arr (i,xi) ->
                      ys
                      |> List.zip (List.sortBy fst arr)
                      |> List.mapAccum (fun (s,c) ((j,el),yj) ->
                          let nc = List.min [s + (if xi = yj then 0 else 1); el + 1; c + 1]
                          ((el,nc),(j,nc))
                      ) (i - 1, i)
                      |> snd
                  ) startArr
                  |> List.find (fst >> (=) lys)
                  |> snd
  
          let distance = hirschberg
  
          let insert a tree = insert distance a tree
  
          let exists a tree = exists distance a tree
  
          let existsDistance n a tree = existsDistance distance n a tree
  
          let elemsDistance n a tree = elemsDistance distance n a tree
  
          let fromList xs = fromList distance xs
  
          let unions xs = unions distance xs
  
          let union t1 t2 = unions [t1; t2]
  
          let delete a tree = delete distance a tree
  
      module ByteString =
  
          open ByteString
  
          let distance xs = function
              | ys when ByteString.isEmpty ys -> ByteString.length xs
              | ys ->
                  let xs = ByteString.toList xs
                  let ys = ByteString.toList ys
                  List.distance xs ys
  
          let insert a tree = insert distance a tree
  
          let exists a tree = exists distance a tree
  
          let existsDistance n a tree = existsDistance distance n a tree
  
          let elemsDistance n a tree = elemsDistance distance n a tree
  
          let fromList xs = fromList distance xs
  
          let unions xs = unions distance xs
  
          let union t1 t2 = unions [t1; t2]
  
          let delete a tree = delete distance a tree
  
negative.code:             let dict = Map.insertWith recurse d (Node(a, 1, Map.empty)) dict
              Node(b, size + 1, dict)
  
      let rec private exists distance a = function
          | Empty -> false
          | Node(b, _, dict) ->
              let d = distance a b
  