anchor.diff:  //==============//
   
   
  -let [<Test>] ``|Array| areEqual``() =
  +[<Test; Parallelizable>]
  +let  ``|Array| areEqual``() =
       Check.QuickThrowOnFailure <| fun (x: int[]) (y: int[]) ->
           (x = y) = (Array.areEqual x y)
       
  
positive.code:         (loop [] xs |> List.rev) = xs
  
  
  let [<Test>] ``|List| GroupBy doesn't lose elements in the process`` () =
      Check.QuickThrowOnFailure <|
      fun (xs:int list) ->
          List.groupBy (string>>String.length) xs 
              |> List.collect snd |> List.length = xs.Length
  
  
  let [<Test>] ``|List| Groups map back onto their keys`` () =
      Check.QuickThrowOnFailure <|
      fun (xs:int list) ->
      (xs <> []) ==> let keyfn = (string>>String.length) in
  
negative.code:                 Array.isSubArray (array.[start..finish]) array start = true)
  
  
  [<Test; Parallelizable>]
  let  ``|Array| startsWith respects bounds``() =
      Check.QuickThrowOnFailure <| 
      fun (subEnd: int) (array:int[]) ->
          (subEnd >= 0 && subEnd < array.Length) ==> 
             lazy (Array.startsWith (array.[0..subEnd]) array = true)
  
  
  [<Test; Parallelizable>]
  let  ``|Array| endsWith respects bounds``() =
      Check.QuickThrowOnFailure <| 
      fun (subStart: int) (array:int[]) ->
          (subStart >= 0 && subStart < array.Length) ==> 
             lazy (Array.endsWith (array.[subStart..array.Length-1]) array = true)
  
  
  [<Test; Parallelizable>]
  let  ``|Array| Distinct has no duplicates``() =
      Check.QuickThrowOnFailure <|
          fun (array:string []) ->
              (Array.distinct array).Length = (HashSet<_> array).Count
  
  
  [<Test; Parallelizable>]
  let  ``|Array| Distinct is the same size or smaller than its input`` () =
      Check.QuickThrowOnFailure <|
          fun (array:string []) ->
              (Array.distinct array).Length <= Array.length array
  
  
  [<Test; Parallelizable>]
  let  ``|Array| DistinctBy has no duplicates``() =
      Check.QuickThrowOnFailure <|
      fun (array:int []) ->
          (Array.distinctBy string array).Length = (HashSet<_> array).Count
          
  
  [<Test; Parallelizable>]
  let  ``|Array| DistinctBy is the same size or smaller than its input`` () =
      Check.QuickThrowOnFailure <|
      fun (array:int[]) ->
          (Array.distinctBy string array).Length <= Array.length array
  
  
  [<Test; Parallelizable>]
  let  ``|Array| foldi indexes arrays properly`` () =
      Check.QuickThrowOnFailure <|
      fun (array:int[]) ->
          (array <> [||]) ==>
              ((Array.foldi (fun _ i _ -> i)) 0 array = array.Length-1)
  
  
  [<Test; Parallelizable>]
  let  ``|Array| takeWhile pred xs + skipWhile pred xs = xs`` () =
      Check.QuickThrowOnFailure <|
      fun (xs:int []) ->
          let takeList, skipList = Array.takeWhile ((>)1000) xs, Array.skipWhile ((>)1000) xs
          Array.append takeList  skipList = xs
          
  
  [<Test; Parallelizable>]
  let  ``|Array| Groups map back onto their keys`` () =
      Check.QuickThrowOnFailure <|
      fun (xs:int []) ->
      (xs <> [||]) ==> let keyfn = (string>>String.length) in
  