anchor.diff:  let foldBack2 () : unit =
       // integer vector  
       let funcInt x y z = x.ToString() + y.ToString() + z
  -    let resultInt = Vector.foldBack2 funcInt  [| 1;3;5 |]  [|2;4;6|] "x"
  +    let resultInt = Vector.foldBack2 funcInt (vector [| 1;3;5 |]) (vector [|2;4;6|]) "x"
       if resultInt <> "123456x" then Assert.Fail()
           
       // string vector
       let funcStr x y z= x + y + z        
  -    let resultStr = Vector.foldBack2 funcStr [|"A"; "B";  "C" ; "D" |] [|"H"; "I";  "J" ; "K" |] "X"
  +    let resultStr = Vector.foldBack2 funcStr (vector [|"A"; "B";  "C" ; "D" |]) (vector [|"H"; "I";  "J" ; "K" |]) "X"
       if resultStr <> "AHBICJDKX" then Assert.Fail()
           
       // empty vector
  -    let emptyArr:vector<int> = [| |]
  +    let emptyArr:vector<int> = vector [| |]
       let resultEpt = Vector.foldBack2 funcInt emptyArr emptyArr "x"
       if resultEpt <> "x" then Assert.Fail()
   
       // null vector
  -    let nullArr = null : string[] 
  -    let validArray = [| "a" |] 
  +    let nullArr = Unchecked.defaultof<vector<_>> : vector<string> 
  +    let validArray = vector [| "a" |] 
       checkThrowsArgumentNullException (fun () -> Vector.foldBack2 funcStr nullArr validArray "begin" |> ignore)  
       checkThrowsArgumentNullException (fun () -> Vector.foldBack2 funcStr validArray nullArr "begin" |> ignore)  
           
       // len1 <> len2
  -    checkThrowsArgumentException(fun () -> Vector.foldBack2 funcInt [|1..10|] [|2..20|] "x" |> ignore)
  +    checkThrowsArgumentException(fun () -> Vector.foldBack2 funcInt (vector [|1..10|]) (vector [|2..20|]) "x" |> ignore)
           
       ()
   
   [<TestCase>]
   let forall () : unit =
       // integer vector
  -    let resultInt = Vector.forall (fun x -> x > 2) [| 3..2..10 |]
  +    let resultInt = Vector.forall (fun x -> x > 2) <| vector [| 3..2..10 |]
       if resultInt <> true then Assert.Fail()
           
       // string vector
  -    let resultStr = Vector.forall (fun (x:string) -> x.Contains("a")) [|"Lists"; "are";  "commonly" ; "list" |]
  +    let resultStr = Vector.forall (fun (x:string) -> x.Contains("a")) <| vector [|"Lists"; "are";  "commonly" ; "list" |]
       if resultStr <> false then Assert.Fail()
           
       // empty vector 
  -    let resultEpt = Vector.forall (fun (x:string) -> x.Contains("a")) [||] 
  +    let resultEpt = Vector.forall (fun (x:string) -> x.Contains("a")) <| vector [||] 
       if resultEpt <> true then Assert.Fail()
   
       // null vector
  -    let nullArr = null:string[] 
  +    let nullArr : vector<string> = Unchecked.defaultof<vector<_>> 
       checkThrowsArgumentNullException (fun () -> Vector.forall (fun x -> true) nullArr |> ignore)  
           
       ()
  
positive.code:         
  [<TestCase>]
  let toSeq () : unit =
      let intArr = [| 1..10 |]
      let seq = Vector.toSeq intArr
      let sum = Seq.sum seq
      Assert.AreEqual(55, sum)
  
negative.code: [<TestCase>]
  let copy () : unit =
      // int vector
      let intSrc:vector<int> = vector [| 3;5;7 |]    
      let intCopyed = Vector.copy  intSrc
      if intCopyed <> vector [| 3;5;7 |] then Assert.Fail()
          
      // string vector
      let stringSrc: vector<string> = vector [|"Lists"; "are";  "commonly"  |]
          
      let strCopyed = Vector.copy  stringSrc   
      if strCopyed <> vector [|"Lists"; "are";  "commonly"  |] then Assert.Fail()
          
      // empty vector
      let emptySrc :vector<int> = vector [| |]
      let emptyCopyed = Vector.copy emptySrc
      if emptyCopyed <> vector [| |] then Assert.Fail()
  
      // null vector
      let nullArr :vector<int> = Unchecked.defaultof<vector<_>>    
      checkThrowsArgumentNullException (fun () -> Vector.copy nullArr |> ignore) 
          
      ()
  