anchor.diff:      let matchFunc n =
           if n = 3 then Some(n.ToString())
           else None
  -    let resultInt = Array.pick matchFunc intArr
  +    let resultInt = Vector.pick matchFunc intArr
       Assert.AreEqual("3", resultInt)
           
       // make it not found
  -    checkThrowsKeyNotFoundException (fun () -> Array.pick (fun n -> None) intArr |> ignore)
  +    checkThrowsKeyNotFoundException (fun () -> Vector.pick (fun n -> None) intArr |> ignore)
           
   [<TestCase>]
   let toSeq () : unit =
       let intArr = [| 1..10 |]
  -    let seq = Array.toSeq intArr
  +    let seq = Vector.toSeq intArr
       let sum = Seq.sum seq
       Assert.AreEqual(55, sum)
           
   [<TestCase>]
   let tryPick () : unit =
  -    // integer array
  +    // integer vector
       let intArr = [| 1..10 |]    
       let funcInt x = 
               match x with
               | _ when x % 3 = 0 -> Some (x.ToString())            
               | _ -> None
  -    let resultInt = Array.tryPick funcInt intArr
  +    let resultInt = Vector.tryPick funcInt intArr
       if resultInt <> Some "3" then Assert.Fail()
           
  -    // string array
  +    // string vector
       let strArr = [|"Lists"; "are";  "commonly" ; "list" |]
       let funcStr x = 
               match x with
               | "good" -> Some (x.ToString())            
               | _ -> None
  -    let resultStr = Array.tryPick funcStr strArr
  +    let resultStr = Vector.tryPick funcStr strArr
       if resultStr <> None then Assert.Fail()
           
  -    // empty array
  -    let emptyArr:int[] = [| |]
  -    let resultEpt = Array.tryPick funcInt emptyArr
  +    // empty vector
  +    let emptyArr:vector<int> = [| |]
  +    let resultEpt = Vector.tryPick funcInt emptyArr
       if resultEpt <> None then Assert.Fail()
   
  -    // null array
  +    // null vector
       let nullArr = null:string[]  
  -    checkThrowsArgumentNullException (fun () -> Array.tryPick funcStr nullArr |> ignore)  
  +    checkThrowsArgumentNullException (fun () -> Vector.tryPick funcStr nullArr |> ignore)  
           
       ()
   
   [<TestCase>]
   let fold () : unit =
  -    // integer array
  +    // integer vector
       let intArr = [| 1..5 |]    
       let funcInt x y = x+"+"+y.ToString()
  -    let resultInt = Array.fold funcInt "x" intArr
  +    let resultInt = Vector.fold funcInt "x" intArr
       if resultInt <> "x+1+2+3+4+5" then Assert.Fail()
           
  -    // string array
  +    // string vector
       let strArr = [|"A"; "B";  "C" ; "D" |]
       let funcStr x y = x+y
               
  -    let resultStr = Array.fold funcStr "X" strArr
  +    let resultStr = Vector.fold funcStr "X" strArr
       if resultStr <> "XABCD" then Assert.Fail()
           
  -    // empty array
  -    let emptyArr : int[] = [| |]
  -    let resultEpt = Array.fold funcInt "x" emptyArr
  +    // empty vector
  +    let emptyArr : vector<int> = [| |]
  +    let resultEpt = Vector.fold funcInt "x" emptyArr
       if resultEpt <> "x" then Assert.Fail()
   
  -    // null array
  +    // null vector
       let nullArr = null : string[] 
  -    checkThrowsArgumentNullException (fun () -> Array.fold funcStr "begin" nullArr |> ignore)  
  +    checkThrowsArgumentNullException (fun () -> Vector.fold funcStr "begin" nullArr |> ignore)  
           
       ()
   
   [<TestCase>]
   let fold2 () : unit =
  -    // integer array  
  +    // integer vector  
       let funcInt x y z = x + y.ToString() + z.ToString()
  -    let resultInt = Array.fold2 funcInt "x" [| 1;3;5 |]  [|2;4;6|]
  +    let resultInt = Vector.fold2 funcInt "x" [| 1;3;5 |]  [|2;4;6|]
       if resultInt <> "x123456" then Assert.Fail()
           
  -    // string array
  +    // string vector
       let funcStr x y z= x + y + z        
  -    let resultStr = Array.fold2 funcStr "X" [|"A"; "B";  "C" ; "D" |] [|"H"; "I";  "J" ; "K" |]
  +    let resultStr = Vector.fold2 funcStr "X" [|"A"; "B";  "C" ; "D" |] [|"H"; "I";  "J" ; "K" |]
       if resultStr <> "XAHBICJDK" then Assert.Fail()
           
  -    // empty array
  -    let emptyArr:int[] = [| |]
  -    let resultEpt = Array.fold2 funcInt "x" emptyArr emptyArr
  +    // empty vector
  +    let emptyArr:vector<int> = [| |]
  +    let resultEpt = Vector.fold2 funcInt "x" emptyArr emptyArr
       if resultEpt <> "x" then Assert.Fail()
   
  -    // null array
  +    // null vector
       let nullArr = null:string[]
       let validArray = [| "a" |]
  -    checkThrowsArgumentNullException (fun () -> Array.fold2 funcStr "begin" validArray nullArr |> ignore)  
  -    checkThrowsArgumentNullException (fun () -> Array.fold2 funcStr "begin" nullArr validArray |> ignore)  
  +    checkThrowsArgumentNullException (fun () -> Vector.fold2 funcStr "begin" validArray nullArr |> ignore)  
  +    checkThrowsArgumentNullException (fun () -> Vector.fold2 funcStr "begin" nullArr validArray |> ignore)  
           
       // len1 <> len2
  -    checkThrowsArgumentException(fun () -> Array.fold2 funcInt "x" [| 1;3;5 |]  [|2;4;6;8|] |> ignore)
  +    checkThrowsArgumentException(fun () -> Vector.fold2 funcInt "x" [| 1;3;5 |]  [|2;4;6;8|] |> ignore)
                   
       ()
   
   [<TestCase>]
   let foldBack () : unit =
  -    // integer array
  +    // integer vector
       let intArr = [| 1..5 |]    
       let funcInt x y = x.ToString()+y
  -    let resultInt = Array.foldBack funcInt intArr "x"
  +    let resultInt = Vector.foldBack funcInt intArr "x"
       if resultInt <> "12345x" then Assert.Fail()
           
  -    // string array
  +    // string vector
       let strArr = [|"A"; "B";  "C" ; "D" |]
       let funcStr x y = x+y
               
  -    let resultStr = Array.foldBack funcStr strArr "X" 
  +    let resultStr = Vector.foldBack funcStr strArr "X" 
       if resultStr <> "ABCDX" then Assert.Fail()
           
  -    // empty array
  -    let emptyArr:int[] = [| |]
  -    let resultEpt = Array.foldBack funcInt emptyArr "x" 
  +    // empty vector
  +    let emptyArr:vector<int> = [| |]
  +    let resultEpt = Vector.foldBack funcInt emptyArr "x" 
       if resultEpt <> "x" then Assert.Fail()
   
  -    // null array
  +    // null vector
       let nullArr = null:string[]      
  -    checkThrowsArgumentNullException (fun () -> Array.foldBack funcStr nullArr "begin" |> ignore)  
  +    checkThrowsArgumentNullException (fun () -> Vector.foldBack funcStr nullArr "begin" |> ignore)  
           
       ()
   
   [<TestCase>]
   let foldBack2 () : unit =
  -    // integer array  
  +    // integer vector  
       let funcInt x y z = x.ToString() + y.ToString() + z
  -    let resultInt = Array.foldBack2 funcInt  [| 1;3;5 |]  [|2;4;6|] "x"
  +    let resultInt = Vector.foldBack2 funcInt  [| 1;3;5 |]  [|2;4;6|] "x"
       if resultInt <> "123456x" then Assert.Fail()
           
  -    // string array
  +    // string vector
       let funcStr x y z= x + y + z        
  -    let resultStr = Array.foldBack2 funcStr [|"A"; "B";  "C" ; "D" |] [|"H"; "I";  "J" ; "K" |] "X"
  +    let resultStr = Vector.foldBack2 funcStr [|"A"; "B";  "C" ; "D" |] [|"H"; "I";  "J" ; "K" |] "X"
       if resultStr <> "AHBICJDKX" then Assert.Fail()
           
  -    // empty array
  -    let emptyArr:int[] = [| |]
  -    let resultEpt = Array.foldBack2 funcInt emptyArr emptyArr "x"
  +    // empty vector
  +    let emptyArr:vector<int> = [| |]
  +    let resultEpt = Vector.foldBack2 funcInt emptyArr emptyArr "x"
       if resultEpt <> "x" then Assert.Fail()
   
  -    // null array
  +    // null vector
       let nullArr = null : string[] 
       let validArray = [| "a" |] 
  -    checkThrowsArgumentNullException (fun () -> Array.foldBack2 funcStr nullArr validArray "begin" |> ignore)  
  -    checkThrowsArgumentNullException (fun () -> Array.foldBack2 funcStr validArray nullArr "begin" |> ignore)  
  +    checkThrowsArgumentNullException (fun () -> Vector.foldBack2 funcStr nullArr validArray "begin" |> ignore)  
  +    checkThrowsArgumentNullException (fun () -> Vector.foldBack2 funcStr validArray nullArr "begin" |> ignore)  
           
       // len1 <> len2
  -    checkThrowsArgumentException(fun () -> Array.foldBack2 funcInt [|1..10|] [|2..20|] "x" |> ignore)
  +    checkThrowsArgumentException(fun () -> Vector.foldBack2 funcInt [|1..10|] [|2..20|] "x" |> ignore)
           
       ()
   
   [<TestCase>]
   let forall () : unit =
  -    // integer array
  -    let resultInt = Array.forall (fun x -> x > 2) [| 3..2..10 |]
  +    // integer vector
  +    let resultInt = Vector.forall (fun x -> x > 2) [| 3..2..10 |]
       if resultInt <> true then Assert.Fail()
           
  -    // string array
  -    let resultStr = Array.forall (fun (x:string) -> x.Contains("a")) [|"Lists"; "are";  "commonly" ; "list" |]
  +    // string vector
  +    let resultStr = Vector.forall (fun (x:string) -> x.Contains("a")) [|"Lists"; "are";  "commonly" ; "list" |]
       if resultStr <> false then Assert.Fail()
           
  -    // empty array 
  -    let resultEpt = Array.forall (fun (x:string) -> x.Contains("a")) [||] 
  +    // empty vector 
  +    let resultEpt = Vector.forall (fun (x:string) -> x.Contains("a")) [||] 
       if resultEpt <> true then Assert.Fail()
   
  -    // null array
  +    // null vector
       let nullArr = null:string[] 
  -    checkThrowsArgumentNullException (fun () -> Array.forall (fun x -> true) nullArr |> ignore)  
  +    checkThrowsArgumentNullException (fun () -> Vector.forall (fun x -> true) nullArr |> ignore)  
           
       ()
           
   [<TestCase>]
   let forall2 () : unit =
  -    // integer array
  +    // integer vector
       let resultInt = Array.forall2 (fun x y -> x < y) [| 1..10 |] [|2..2..20|]
       if resultInt <> true then Assert.Fail()
           
  -    // string array
  -    let resultStr = Array.forall2 (fun (x:string) (y:string) -> x.Length < y.Length) [|"Lists"; "are";  "commonly" ; "list" |] [|"Listslong"; "arelong";  "commonlylong" ; "listlong" |]
  +    // string vector
  +    let resultStr = Vector.forall2 (fun (x:string) (y:string) -> x.Length < y.Length) [|"Lists"; "are";  "commonly" ; "list" |] [|"Listslong"; "arelong";  "commonlylong" ; "listlong" |]
       if resultStr <> true then Assert.Fail()
           
  -    // empty array 
  -    let resultEpt = Array.forall2 (fun x y -> x>y) [||] [||]
  +    // empty vector 
  +    let resultEpt = Vector.forall2 (fun x y -> x>y) [||] [||]
       if resultEpt <> true then Assert.Fail()
   
  -    // null array
  +    // null vector
       let nullArr = null:string[]
       let validArray = [| "a" |] 
  -    checkThrowsArgumentNullException (fun () -> Array.forall2 (fun x y-> true) nullArr validArray |> ignore)  
  -    checkThrowsArgumentNullException (fun () -> Array.forall2 (fun x y-> true) validArray nullArr |> ignore)  
  +    checkThrowsArgumentNullException (fun () -> Vector.forall2 (fun x y-> true) nullArr validArray |> ignore)  
  +    checkThrowsArgumentNullException (fun () -> Vector.forall2 (fun x y-> true) validArray nullArr |> ignore)  
           
       // len1 <> len2
  -    checkThrowsArgumentException(fun () -> Array.forall2 (fun x y -> x < y) [|1..10|] [|2..20|] |> ignore)
  +    checkThrowsArgumentException(fun () -> Vector.forall2 (fun x y -> x < y) [|1..10|] [|2..20|] |> ignore)
           
       ()
           
   [<TestCase>]
   let get () : unit =
  -    // integer array
  +    // integer vector
       let intArr = [| 3;4;7;8;10 |]    
  -    let resultInt = Array.get intArr 3
  +    let resultInt = Vector.get intArr 3
       if resultInt <> 8 then Assert.Fail()
           
  -    // string array
  +    // string vector
       let strArr = [|"Lists"; "are";  "commonly" ; "list" |]
           
  -    let resultStr = Array.get strArr 2
  +    let resultStr = Vector.get strArr 2
       if resultStr <> "commonly" then Assert.Fail()
           
  -    // empty array
  -    let emptyArr:int[] = [| |]
  -    checkThrowsIndexOutRangException (fun () -> Array.get emptyArr -1 |> ignore)
  -
  -    // null array
  +    // empty vector
  +    let emptyArr:vector<int> = [| |]
  +    checkThrowsIndexOutRangException (fun () -> Vector.get emptyArr -1 |> ignore)
  +
  +    // null vector
       let nullArr = null:string[] 
  -    checkThrowsNullRefException (fun () -> Array.get nullArr 0 |> ignore)  
  +    checkThrowsNullRefException (fun () -> Vector.get nullArr 0 |> ignore)  
           
       ()
   
   let private InitTester initInt initString = 
  -    // integer array
  -    let resultInt : int[] = initInt 3 (fun x -> x + 3) 
  +    // integer vector
  +    let resultInt : vector<int> = initInt 3 (fun x -> x + 3) 
       if resultInt <> [|3;4;5|] then Assert.Fail()
           
  -    // string array
  +    // string vector
       let funStr (x:int) = 
           match x with
           | 0 -> "Lists"
  
positive.code:     if ([||], intSrc) <> allRight then Assert.Fail()
  
          
      // string array
      let stringSrc: string [] = "List 1 list 2 3 4 5".Split([|' '|], System.StringSplitOptions.RemoveEmptyEntries)
      let funcString x = match x with
                          | "list"-> true
  
negative.code:         
  [<TestCase>]  
  let map () : unit =
      MapTester Vector.map Vector.map
          
  [<TestCase>]
  let mapWithSideEffects  () : unit =
  