anchor.diff:      Check.QuickThrowOnFailure splitAt<NormalFloat>
   
   let splitInto<'a when 'a : equality> (xs : 'a []) count =
  -    let s = run (fun () -> xs |> Seq.splitInto count |> Seq.map Seq.toArray |> Seq.toArray)
  -    let l = run (fun () -> xs |> List.ofArray |> List.splitInto count |> Seq.map Seq.toArray |> Seq.toArray)
  -    let a = run (fun () -> xs |> Array.splitInto count |> Seq.map Seq.toArray |> Seq.toArray)
  -    consistency "splitInto" s l a
  +    let ls = List.ofArray xs
  +    if count < 1 then 
  +        Prop.throws<ArgumentException,_> (lazy List.splitInto count ls) .&.
  +        Prop.throws<ArgumentException,_> (lazy Array.splitInto count xs) .&.
  +        Prop.throws<ArgumentException,_> (lazy Seq.splitInto count xs) 
  +    else
  +        let s = run (fun () -> xs |> Seq.splitInto count |> Seq.map Seq.toArray |> Seq.toArray)
  +        let l = run (fun () -> ls |> List.splitInto count |> Seq.map Seq.toArray |> Seq.toArray)
  +        let a = run (fun () -> xs |> Array.splitInto count |> Seq.map Seq.toArray |> Seq.toArray)
  +        consistency "splitInto" s l a
   
   [<Test>]
   let ``splitInto is consistent`` () =
  
positive.code:             if !c > 100 then None else // prevent infinity seqs
              c := !c + 1
              f x
  
      
      let s : 'b [] = Seq.unfold (f()) start |> Seq.toArray
      let l = List.unfold (f()) start |> List.toArray
      let a = Array.unfold (f()) start
  
negative.code:     Check.QuickThrowOnFailure sumBy<float>
  
  let splitAt<'a when 'a : equality> (xs : 'a []) index =
      let ls = List.ofArray xs
      if index < 0 then 
          Prop.throws<ArgumentException,_> (lazy List.splitAt index ls) .&.
          Prop.throws<ArgumentException,_> (lazy Array.splitAt index xs) 
      elif index > xs.Length then
          Prop.throws<InvalidOperationException,_> (lazy List.splitAt index ls) .&.
          Prop.throws<InvalidOperationException,_> (lazy Array.splitAt index xs) 
      else
          // no seq version
          let l = run (fun () -> ls |> List.splitAt index |> fun (a,b) -> List.toArray a,List.toArray b)
          let a = run (fun () -> xs |> Array.splitAt index)
          (l = a) |@ "splitAt"
  
  [<Test>]
  let ``splitAt is consistent`` () =
  