anchor.diff:  
   [<TestCase>]
   let remove () : unit =
  -    [(5, "a"); (3, "b")]
  -    |> IntMap.ofList
  -    |> IntMap.remove 5
  -    |> should equal (
  -        IntMap.singleton 3 "b")
  -
  -    [(5, "a"); (3, "b")]
  -    |> IntMap.ofList
  -    |> IntMap.remove 7
  -    |> should equal (
  -        IntMap.ofList [(5, "a"); (3, "b")])
  -
       (IntMap.empty : IntMap<string>)
       |> IntMap.remove 5
       |> should equal (IntMap.empty : IntMap<string>)
   
  +    [(5, "a"); (3, "b")]
  +    |> IntMap.ofList
  +    |> IntMap.remove 5
  +    |> should equal (
  +        IntMap.singleton 3 "b")
  +
  +    [| (5, 'a'); (3, 'b'); (11, 'f'); (2, 'd');
  +        (17, 'a'); (4, 'g'); (12, 'b'); (14, 'c'); |]
  +    |> IntMap.ofArray
  +    |> IntMap.remove 4
  +    |> should equal (IntMap.ofArray
  +       [| (5, 'x'); (3, 'b'); (11, 'f'); (2, 'd');
  +          (17, 'a'); (12, 'b'); (14, 'c'); |])
  +
  +[<TestCase>]
  +let union () : unit =
  +//    let a = IntMap.ofList [(5, "a"); (3, "b")]
  +//    let b = IntMap.ofList [(5, "A"); (7, "C")]
  +//    let c = IntMap.union a b
  +//    let d = IntMap.ofList [(3, "b"); (5, "a"); (7, "C")]
  +
  +    IntMap.union
  +        (IntMap.ofList [(5, "a"); (3, "b")])
  +        (IntMap.ofList [(5, "A"); (7, "C")])
  +    |> should equal (
  +        IntMap.ofList [(3, "b"); (5, "a"); (7, "C")])
  +
  +[<TestCase>]
  +let ofSeq () : unit =
  +    (Seq.empty : seq<int * string>)
  +    |> IntMap.ofSeq
  +    |> should equal IntMap.empty
  +
  +//    seq {
  +//        yield (
  +
  +//[<TestCase>]
  +//let ofList () : unit =
  +//    Assert.Fail ()
  +//
  +//[<TestCase>]
  +//let ofArray () : unit =
  +//    Assert.Fail ()
  +//
  +//[<TestCase>]
  +//let ofMap () : unit =
  +//    Assert.Fail ()
  +//
  +//[<TestCase>]
  +//let toSeq () : unit =
  +//    Assert.Fail ()
  +//
  +//[<TestCase>]
  +//let toList () : unit =
  +//    Assert.Fail ()
  +//
  +//[<TestCase>]
  +//let toArray () : unit =
  +//    Assert.Fail ()
  +//
  +//[<TestCase>]
  +//let toMap () : unit =
  +//    Assert.Fail ()
  +//
  +//[<TestCase>]
  +//let tryPick () : unit =
  +//    Assert.Fail ()
  +//
  +//[<TestCase>]
  +//let pick () : unit =
  +//    Assert.Fail ()
  +
   [<TestCase>]
   let map () : unit =
       [(5, "a"); (3, "b")]
  
positive.code:     |> IntMap.count
      |> should equal 1
  
      [(1, 'a'); (2, 'c'); (3, 'b')]
      |> IntMap.ofList
      |> IntMap.count
      |> should equal 3
  
  [<TestCase>]
  let contains () : unit =
      [(5, 'a'); (3, 'b')]
      |> IntMap.ofList
      |> IntMap.containsKey 5
      |> should be True
  
      [(5, 'a'); (3, 'b')]
      |> IntMap.ofList
      |> IntMap.containsKey 1
      |> should be False
  
  [<TestCase>]
  let singleton () : unit =
      IntMap.singleton 1 'a'
      |> should equal <| IntMap.ofList [(1, 'a')]
  
      IntMap.singleton 1 'a'
      |> IntMap.count
      |> should equal 1
  
  [<TestCase>]
  let add () : unit =
      [(5, 'a'); (3, 'b')]
      |> IntMap.ofList
      |> IntMap.add 5 'x'
      |> should equal (
          IntMap.ofList [(3, 'b'); (5, 'x')])
  
      [(5, 'a'); (3, 'b')]
      |> IntMap.ofList
      |> IntMap.add 7 'x'
      |> should equal (
          IntMap.ofList [(3, 'b'); (5, 'a'); (7, 'x')])
  
      IntMap.empty
      |> IntMap.add 5 'x'
  
negative.code:     |> should equal (
          IntMap.ofList [(5, "5:a"); (3, "3:b")])
  
  //[<TestCase>]
  //let filter () : unit =
  //    Assert.Fail ()
  //
  //[<TestCase>]
  //let choose () : unit =
  //    Assert.Fail ()
  //
  //[<TestCase>]
  //let iter () : unit =
  //    Assert.Fail ()
  //
  //[<TestCase>]
  //let iterBack () : unit =
  //    Assert.Fail ()
  //
  //[<TestCase>]
  //let fold () : unit =
  //    Assert.Fail ()
  //
  //[<TestCase>]
  //let foldBack () : unit =
  //    Assert.Fail ()
  //
  //[<TestCase>]
  //let exists () : unit =
  //    Assert.Fail ()
  //
  //[<TestCase>]
  //let forall () : unit =
  //    Assert.Fail ()
  //
  //[<TestCase>]
  //let partition () : unit =
  //    Assert.Fail ()
  //
  //[<TestCase>]
  //let mapPartition () : unit =
  //    Assert.Fail ()
  
  
  
  