anchor.diff:  let allPairs<'a when 'a : equality> (xs : list<'a>) (xs2 : list<'a>) =
       let s = xs |> Seq.allPairs xs2 |> Seq.toArray
       let l = xs |> List.allPairs xs2  |> List.toArray
  -    let a = xs |> Seq.toArray |> Array.allPairs (Seq.toArray xs2)    
  +    let a = xs |> List.toArray |> Array.allPairs (List.toArray xs2)    
       consistency "allPairs" s l a
   
   [<Test>]
  
positive.code:     let s = run (fun () -> xs |> Seq.find predicate)
      let l = run (fun () -> xs |> List.ofArray |> List.find predicate)
      let a = run (fun () -> xs |> Array.find predicate)
      consistency "filter" s l a
  
  [<Test>]
  let ``find is consistent`` () =
  
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`` () =
  