anchor.diff:              // Use a 'let rec' to allow access to the target as the declaring
               // type of the contents in a delayed way.
               let rec xT : ProvidedTypeDefinition = 
  +                let mutable methodsIdx = 0 
  +                let checkFreshMethods() = 
  +                    x.CountMembersFromCursor(methodsIdx) > 0
  +                    
  +                let getFreshMethods() = 
  +                    let vs, idx2 = x.GetMembersFromCursor(methodsIdx) 
  +                    methodsIdx <- idx2
  +                    vs |> Array.map (convMemberDefToTgt xT)
  +
  +                let mutable interfacesIdx = 0 
  +                let getFreshInterfaces() = 
  +                    let vs, idx2 = x.GetInterfaceImplsFromCursor(interfacesIdx) 
  +                    interfacesIdx <- idx2
  +                    vs |> Array.map convTypeToTgt
  +
  +                let mutable overridesIdx = 0 
  +                let getFreshMethodOverrides() = 
  +                    let vs, idx2 = x.GetMethodOverridesFromCursor(overridesIdx) 
  +                    overridesIdx <- idx2
  +                    vs |> Array.map (fun (a,b) -> (convMethodRefToTgt a :?> ProvidedMethod), convMethodRefToTgt b)
  +
  +                let backingDataSource = Some (checkFreshMethods, getFreshMethods, getFreshInterfaces, getFreshMethodOverrides)
  +
                   ProvidedTypeDefinition(true, container, x.Name, 
                                           (x.BaseTypeRaw >> Option.map convTypeToTgt), 
                                           x.AttributesRaw, 
  
positive.code:         member __.StaticParams = staticParams
          member __.StaticParamsApply = staticParamsApply
          
          // Fetch the members declared since the indicated position in the members list.  This allows the target model to observe 
          // incremental additions made to the source model
          member __.GetMembersFromCursor(idx: int) = evalMembers(); members.GetRange(idx, members.Count - idx).ToArray(), members.Count
  
negative.code:                                 members.Add (e.GetRemoveMethod true)
                          | _ -> ()
                  
          let getMembers() =
              evalMembers()
              members.ToArray()
  
          // Save some common lookups for provided types with lots of members
          let mutable bindings :  Dictionary<int32, obj> = null
  
          let save (key: BindingFlags) f : 'T = 
              let key = int key
  
              if bindings = null then 
                  bindings <- Dictionary<_,_>(HashIdentity.Structural)
  
              if not (moreMembers()) && bindings.ContainsKey(key)  then 
                  bindings.[key] :?> 'T
              else
                  let res = f () // this will refresh the members
                  bindings.[key] <- box res
                  res
  
          let evalInterfaces() =
              if interfacesQueue.Count > 0 then
  