anchor.diff:          (loop [] xs |> List.rev) = xs
   
   
  -let [<Test>] ``|List| GroupBy doesn't lose elements in the process`` () =
  +[<Test; Parallelizable>]
  +let  ``|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`` () =
  +[<Test; Parallelizable>]
  +let  ``|List| Groups map back onto their keys`` () =
       Check.QuickThrowOnFailure <|
       fun (xs:int list) ->
       (xs <> []) ==> let keyfn = (string>>String.length) in
  
positive.code:             | true  -> Array.forall (fun x -> keyfn x = key) elms)
  
  
  let [<Test>] ``|Array| Groupsby doesn't lose elements`` () =
      Check.QuickThrowOnFailure <|
      fun (xs:int []) ->
          Array.groupBy (string>>String.length) xs 
          |> Array.map (snd>>Array.length)|>Array.sum = xs.Length
  
  
  let [<Test>] ``|Array| filterMap = filter |> map`` () =
      Check.QuickThrowOnFailure <|
      fun (xs:int []) ->
          let filter x = x<>0 || x%4<>0
  
negative.code:  //  List Tests  //
  //==============//
  
  [<Test; Parallelizable>]
  let ``|List| foldi indexes lists properly`` () =
      Check.QuickThrowOnFailure <|
      fun (xs:int list) ->
          (xs <> []) ==>
              ((List.foldi (fun _ i _ -> i)) 0 xs = xs.Length-1)
  
  
  [<Test; Parallelizable>]
  let  ``|List| takeWhile pred xs + skipWhile pred xs = xs`` () =
      Check.QuickThrowOnFailure <|
      fun (xs:int list) ->
          let takeList, skipList = List.takeWhile ((>)1000) xs, List.skipWhile ((>)1000) xs
          takeList @ skipList = xs
          
  
  [<Test; Parallelizable>]
  let  ``|List| recursing with tryhead returns the list`` () =
      Check.QuickThrowOnFailure <|
      fun (xs:int list) ->
          let rec loop acc xs = 
  