anchor.diff:                  Array.isSubArray (array.[start..finish]) array start = true)
   
   
  -let [<Test>] ``|Array| startsWith respects bounds``() =
  +[<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)
   
   
  -let [<Test>] ``|Array| endsWith respects bounds``() =
  +[<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)
   
   
  -let [<Test>] ``|Array| Distinct has no duplicates``() =
  +[<Test; Parallelizable>]
  +let  ``|Array| Distinct has no duplicates``() =
       Check.QuickThrowOnFailure <|
           fun (array:string []) ->
               (Array.distinct array).Length = (HashSet<_> array).Count
   
   
  -let [<Test>] ``|Array| Distinct is the same size or smaller than its input`` () =
  +[<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
   
   
  -let [<Test>] ``|Array| DistinctBy has no duplicates``() =
  +[<Test; Parallelizable>]
  +let  ``|Array| DistinctBy has no duplicates``() =
       Check.QuickThrowOnFailure <|
       fun (array:int []) ->
           (Array.distinctBy string array).Length = (HashSet<_> array).Count
           
   
  -let [<Test>] ``|Array| DistinctBy is the same size or smaller than its input`` () =
  +[<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
   
   
  -let [<Test>] ``|Array| foldi indexes arrays properly`` () =
  +[<Test; Parallelizable>]
  +let  ``|Array| foldi indexes arrays properly`` () =
       Check.QuickThrowOnFailure <|
       fun (array:int[]) ->
           (array <> [||]) ==>
               ((Array.foldi (fun _ i _ -> i)) 0 array = array.Length-1)
   
   
  -let [<Test>] ``|Array| takeWhile pred xs + skipWhile pred xs = xs`` () =
  +[<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
           
   
  -let [<Test>] ``|Array| Groups map back onto their keys`` () =
  +[<Test; Parallelizable>]
  +let  ``|Array| Groups map back onto their keys`` () =
       Check.QuickThrowOnFailure <|
       fun (xs:int []) ->
       (xs <> [||]) ==> let keyfn = (string>>String.length) in
  
positive.code: //==============//
  
  
  let [<Test>] ``|Array| areEqual``() =
      Check.QuickThrowOnFailure <| fun (x: int[]) (y: int[]) ->
          (x = y) = (Array.areEqual x y)
      
  
negative.code:     Assert.AreEqual(([||] = null), (Array.areEqual [||] null))
  
  
  [<Test; Parallelizable>]
  let  ``|Array| random slice is a sub array``() =
      let rng = System.Random ()
      Check.QuickThrowOnFailure <| 
      fun (array:int[]) ->
  