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:         | FilterWithFn
          | SetNthToNth of int * int
  
      let cloneAdd v (vs : ResizeArray<_>) =
          seq {
              for x in vs do yield x
              yield v
          } |> ResizeArray
  
      let cloneMap f (vs : ResizeArray<_>) = Seq.map f vs |> ResizeArray
  
      let cloneFilter f (vs : ResizeArray<_>) = Seq.filter f vs |> ResizeArray
  
      let cloneSet (idx : int) (v : 'v) (vs : ResizeArray<_>) =
          let vs2 = ResizeArray(vs.Capacity)
          vs2.AddRange(vs)
          vs2.[idx] <- v
          vs2
  
      /// Keeps a reference to all persistent collections returned after
      /// performing actions, and after they are all applied, checks
      /// that they equal what we would get from FSharp.Core.List
      let eqListsAfterSteps
          (list : 'v ResizeArray)
          (testlist : 'l)
          (actions : ListAction<'v> array)
          (addLast : 'v->'l->'l)
  