anchor.diff:              | Collect(_) :: _ -> failwith "Cannot collect on simple types" 
               | Default(_) :: _ -> failwith "Cannot default on simple types"   
               | Add(_) :: _ -> failwith "Cannot add on simple types"   
  -            | Compare(compfun) :: rest -> let instance = compfun |> applyCompare path instance in applyTransforms rest instance
  +            | Compare(compfun) :: rest -> let instance = compfun |> applyCompare vtype path origInstance instance in applyTransforms rest instance
           match funcs |> Map.tryFind path with
  -        | Some transforms -> applyTransforms transforms instance
  -        | None -> instance
  -
  -    and genOptionCopy rcs (itype: Type) (funcs: FieldUpdaters) (path: string list) (instance: Expr) : Expr = 
  +        | Some transforms -> applyTransforms transforms origInstance
  +        | None -> origInstance
  +
  +    and genOptionCopy rcs (itype: Type) (funcs: FieldUpdaters) (path: string list) (origInstance: Expr) : Expr = 
           let etype = itype.GetGenericArguments().[0]
   
           let rec applyTransforms (funcs: FieldAction list) (instance: Expr) =
  
positive.code:             | Add (adder) :: rest -> 
                  let m = (getMethod <@ addToArray X X @>).MakeGenericMethod([|etype|])          
                  let instance = Expr.Call(m, [adder; instance]) in applyTransforms rest instance
              | Compare(compfun) :: rest -> let instance = compfun |> applyCompare path instance in applyTransforms rest instance
                
          let copyArray funcs = 
              let copyfun = makeSingleArgCopyFunExpr rcs etype funcs path
              let m = (getMethod <@ Array.map X X @>).MakeGenericMethod([|etype; etype|])
              Expr.Call(m, [copyfun; instance])
  
          match funcs |> Map.tryFind path, funcs |> Map.remove path, rcs.CloneWhenNoChanges with    
          | None, _, false -> instance
          | None, _, true -> copyArray Map.empty 
          // Array of arrays, just move to the inner array
          | Some _, _, _ when etype.IsArray -> copyArray funcs 
          | Some transforms, newfuncs, _ -> applyTransforms transforms (copyArray newfuncs)
  
      and genMapCopier rcs (atype : Type) (funcs: FieldUpdaters) (path: string list) (instance: Expr) : Expr = 
          let (ktype, vtype) = 
              let arr = atype.GetGenericArguments()
              if arr.Length <> 2 then failwithf "Unexpected Params on Map Type: %A" arr
  
negative.code: 
      /// Makes it easy to get a placeholder value for a type used to be used in a quotation
      let X<'T> : 'T = Unchecked.defaultof<'T>
  
      /// Compare Application
      let returnNotUnitSecond (_: 'a) (v2: 'b) = v2
      let inline applyCompare (prmType: Type) (name: string list) prm1 prm2 compFunExpr = 
          let inputs = Expr.NewTuple [Expr.Value name; prm1; prm2]
          let app = Expr.Application(compFunExpr, inputs)
          let meth = (getMethod <@ returnNotUnitSecond X X @>).MakeGenericMethod([|typeof<unit>; prmType|])
          Expr.Call(meth, [app; prm2])
  
  module CollectionHelpers =
  
  