anchor.diff:              | Some _, None -> l
               | None, Some _ -> r
               | Some lv, Some rv ->
  -                let rightMin = r.tree.ViewLeft |> Seq.head
  +                let rightMin = min r
  +                let leftMin = min l
                   if lv < rightMin then
                       { tree = FingerTree.concat l.tree r.tree }
  +                elif rv < leftMin then
  +                    { tree = FingerTree.concat r.tree l.tree }
                   else
                       let mutable res = l
                       for e in r.tree.ViewLeft do
                           res <- add e res
                       res
   
  +    let unsafeConcatWithMiddle (l : SortedList<'a>) (m : list<'a>) (r : SortedList<'a>) =
  +        { tree = FingerTree.concatWithMiddle l.tree m r.tree }
  +   
  +    let unsafeAppendRange (l : SortedList<'a>) (r : list<'a>) =
  +        { tree = FingerTree.concatWithMiddle l.tree r (FingerTree.custom m) }
  +    
  +    let unsafePrependRange (l : list<'a>) (r : SortedList<'a>) =
  +        { tree = FingerTree.concatWithMiddle (FingerTree.custom m) l r.tree }
  +
  +
       let viewl (l : SortedList<'a>) =
           match FingerTree.viewl l.tree with
               | Some(v,rest) -> Some(v, { tree = rest })
  
positive.code:             | Some(v,rest) -> Some(v, { tree = rest })
              | None -> None
  
  
  
  // some tests
  module Test =
  
negative.code:         let merged = SortedList.union a b
          printfn "merged = %A" merged
  
          printfn "range(a) = %A" (SortedList.range a)
          printfn "range(b) = %A" (SortedList.range b)
  
  
          let test = l |> SortedList.replaceRangeInclusive 4 10 [8]
          printfn "l = %A" l
          printfn "test = %A" test
  
  
      let run3() =
          let res = IntervalTree.ofList [Range1i(0,4); Range1i(6,10); Range1i(12,20)]
  
          printfn "%A" res
  