anchor.diff:          (mapf : ('v->'v)->'l->'l)
           (pred: 'v->bool)
           (filter: ('v->bool)->'l->'l)
  -        (eq : 'l->'v list->bool) =
  +        (eq : 'l->'v ResizeArray->bool) =
   
  -        let applyAction fslist testlist action =
  +        let applyAction (list:'v ResizeArray) testlist action =
               match action with
               | ListAction.AddLast v ->
  -                (fslist @ [v], addLast v testlist)
  +                (cloneAdd v list, addLast v testlist)
               | ListAction.MapIncrementFn ->
  -                (List.map incrf fslist, mapf incrf testlist)
  +                (cloneMap incrf list, mapf incrf testlist)
               | ListAction.FilterWithFn ->
  -                (List.filter pred fslist, filter pred testlist)
  +                (cloneFilter pred list, filter pred testlist)
               | ListAction.SetNthToNth(n1, n2) ->
  -                let len = List.length fslist
  +                let len = list.Count
                   if len > 0 then
                       let idx1, idx2 = Math.Abs(n1) % len, Math.Abs(n2) % len
  -                    let fs =
  -                        let v2 = Seq.item idx2 fslist
  -                        List.mapi (fun i v -> if i = idx1 then v2 else v) fslist
  +                    let newlist = 
  +                        let v2 = Seq.item idx2 list
  +                        cloneSet idx1 v2 list
                       let test =
                           let v2 = getNth idx2 testlist
                           setNth idx1 v2 testlist
  -                    (fs, test)
  +                    (newlist, test)
                   else
  -                    (fslist, testlist)
  +                    (list, testlist)
   
  -        let (fslists, testlists) =
  +        let (lists, testlists) =
               Array.fold
                   (fun acc action ->
                       match acc with
  
positive.code:             ary2.[i] <- v
              ary2
  
          eqSetsAfterSteps initialList ary actions add get set ((+) 1) Array.map pred Array.filter eq
  
      [<Property>]
      let ulistEqListsAfterSteps (initialList : int list) (actions : ListAction<int>[]) =
          let testList = Ulist.addMany initialList (Ulist.makeEmpty(None))
          let eq (ulist : Ulist<_>) (fslist : _ list) = List.ofSeq ulist = fslist
          let pred i = i % 2 = 0
          eqSetsAfterSteps initialList testList actions Ulist.add Ulist.get Ulist.set ((+) 1) Ulist.map pred Ulist.filter eq
  
  
negative.code:                         let (newF, newT) = applyAction fsmap testMap action
                          (newF :: fsmap :: fsmaps, newT :: testMap :: testMaps)
                      | _ -> failwithumf ())
                  ([list], [testlist])
                  actions
  
          let success = List.forall2 eq testlists lists 
          if not success then
              Trace.WriteLine "FAILURE:"
              List.iteri2 (fun i list testlist  ->
                  if i > 0 then Trace.WriteLine (sprintf "After action %A" actions.[i-1])
                  Trace.WriteLine (sprintf "list: %A\ntestlist: %A" list testlist))
                  (List.rev lists)
                  (List.rev testlists)
          success
  
      [<Property>]
      /// Proof of concept, we can delete this after we know test is correct
      let aryEqListsAfterSteps (initialList : ResizeArray<int>) (actions : ListAction<int> []) =
          let ary = Array.ofSeq initialList
          let eq (ary: int[]) (fslist: int ResizeArray) = List.ofSeq ary = List.ofSeq fslist
          let pred i = i % 2 = 0
  
          let add (v:int) (ary: int[]) =
  