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