anchor.diff:                  
           Expr.Cast<unit>(aux 0 r)
   
  +    open System.Reflection.Emit
  +    open System.Collections.Concurrent
  +
  +    type private Marker = class end
  +
  +    let private compileDynamicMethod<'D when 'D :> Delegate> 
  +                (name : string) (argTypes : Type []) (returnType : Type)
  +                (ilBuilder : ILGenerator -> unit) =
  +
  +        let dynamicMethod =
  +            new DynamicMethod(name, MethodAttributes.Static ||| MethodAttributes.Public, 
  +                                CallingConventions.Standard, returnType, argTypes, typeof<Marker>, 
  +                                skipVisibility = true)
  +
  +        let ilGen = dynamicMethod.GetILGenerator()
  +        do ilBuilder ilGen
  +        dynamicMethod.CreateDelegate(typeof<'D>) :?> 'D
  +
  +    let private compileCache = new ConcurrentDictionary<MemberInfo * string, Lazy<Delegate>>()
  +    let private compileDynamicMethodCached<'D when 'D :> Delegate> 
  +                (memberInfo : MemberInfo) (id : string) (argTypes : Type []) (returnType : Type)
  +                (ilBuilder : ILGenerator -> unit) =
  +
  +        let wrapper = compileCache.GetOrAdd((memberInfo, id), fun _ -> lazy(compileDynamicMethod<'D> id argTypes returnType ilBuilder :> Delegate))
  +        lazy(wrapper.Value :?> 'D)
  +
  +    let mkProjection<'DeclaringType, 'Property> (memberInfo : MemberInfo) (path : MemberInfo []) =
  +        let id = sprintf "%O-%O-projection" memberInfo.DeclaringType memberInfo
  +        let builder (gen : ILGenerator) =
  +            gen.Emit OpCodes.Ldarg_0
  +            for m in path do
  +                match m with
  +                | :? FieldInfo as f -> gen.Emit(OpCodes.Ldfld, f)
  +                | :? PropertyInfo as p -> 
  +                    let m = p.GetGetMethod(true)
  +                    if m.IsVirtual then
  +                        gen.EmitCall(OpCodes.Callvirt, m, null)
  +                    else
  +                        gen.EmitCall(OpCodes.Call, m, null)
  +                | _ -> invalidMember m
  +
  +            gen.Emit OpCodes.Ret
  +
  +        compileDynamicMethodCached<Func<'DeclaringType, 'Property>>
  +            memberInfo id [|typeof<'DeclaringType>|] typeof<'Property> builder
  +
  +    let mkInjection<'DeclaringType, 'Property> (memberInfo : MemberInfo) (path : MemberInfo []) =
  +        let id = sprintf "%O-%O-injection" memberInfo.DeclaringType memberInfo
  +        let builder (gen : ILGenerator) =
  +            gen.Emit OpCodes.Ldarg_0
  +            for i = 0 to path.Length - 2 do
  +                match path.[i] with
  +                | :? FieldInfo as f -> gen.Emit(OpCodes.Ldfld, f)
  +                | :? PropertyInfo as p -> 
  +                    let m = p.GetGetMethod(true)
  +                    if m.IsVirtual then
  +                        gen.EmitCall(OpCodes.Callvirt, m, null)
  +                    else
  +                        gen.EmitCall(OpCodes.Call, m, null)
  +                | m -> invalidMember m
  +
  +            gen.Emit OpCodes.Ldarg_1
  +
  +            match path.[path.Length - 1] with
  +            | :? FieldInfo as f -> gen.Emit(OpCodes.Stfld, f)
  +            | :? PropertyInfo as p ->
  +                let m = p.GetSetMethod(true)
  +                if m.IsVirtual then
  +                    gen.EmitCall(OpCodes.Callvirt, m, null)
  +                else
  +                    gen.EmitCall(OpCodes.Call, m, null)
  +
  +            | m -> invalidMember m
  +
  +            gen.Emit OpCodes.Ldarg_0
  +            gen.Emit OpCodes.Ret
  +
  +        compileDynamicMethodCached<Func<'DeclaringType, 'Property, 'DeclaringType>>
  +            memberInfo id [|typeof<'DeclaringType>; typeof<'Property>|] typeof<'DeclaringType> builder
  +
  +    let mkUninitializedCtor<'DeclaringType> (ctor : MethodBase) =
  +        let id = sprintf "%O-%O-ctor" ctor.DeclaringType ctor
  +        let builder (gen : ILGenerator) =
  +            for p in ctor.GetParameters() do
  +                match p.ParameterType with
  +                | t when t.IsPrimitive -> gen.Emit OpCodes.Ldc_I4_0
  +                | t when t.IsValueType -> 
  +                    let l = gen.DeclareLocal t
  +                    gen.Emit(OpCodes.Ldloca_S, l.LocalIndex)
  +                    gen.Emit(OpCodes.Initobj, t)
  +                    gen.Emit(OpCodes.Ldloc, l.LocalIndex)
  +                | _ -> gen.Emit OpCodes.Ldnull
  +
  +            match ctor with
  +            | :? ConstructorInfo as c -> gen.Emit(OpCodes.Newobj, c)
  +            | :? MethodInfo as m when m.IsStatic ->
  +                if m.IsVirtual then gen.EmitCall(OpCodes.Callvirt, m, null)
  +                else gen.EmitCall(OpCodes.Call, m, null)
  +            | _ -> invalidMember ctor
  +
  +            gen.Emit OpCodes.Ret
  +
  +        compileDynamicMethodCached<Func<'DeclaringType>> ctor id [||] typeof<'DeclaringType> builder
  +
  +    let mkTagReader<'U> (tagReader : MemberInfo) =
  +        let id = sprintf "%O-%O-tagReader" tagReader.DeclaringType tagReader
  +        let builder (gen : ILGenerator) =
  +            gen.Emit OpCodes.Ldarg_0
  +            let m =
  +                match tagReader with
  +                | :? MethodInfo as m -> m
  +                | :? PropertyInfo as p -> p.GetGetMethod(true)
  +                | _ -> invalidMember tagReader
  +
  +            if m.IsVirtual then gen.EmitCall(OpCodes.Callvirt, m, null)
  +            else gen.EmitCall(OpCodes.Call, m, null)
  +            gen.Emit OpCodes.Ret
  +
  +        compileDynamicMethodCached<Func<'U, int>> tagReader id [|typeof<'U>|] typeof<int> builder
  +                
  +
   //-------------------------
   // Member Shape Definitions
   
  
positive.code: 
  /// Identifies an F# record type
  and ShapeFSharpRecord<'Record> private () =
      let props = FSharpType.GetRecordFields(typeof<'Record>, allMembers)
      let fields = typeof<'Record>.GetFields(allInstanceMembers)
      let mkRecordField (prop : PropertyInfo) (field : FieldInfo) =
          mkWriteMemberUntyped<'Record> prop.Name prop [|field :> MemberInfo|]
  
      let recordFields = Array.map2 mkRecordField props fields
  
      /// F# record field shapes
      member __.Fields = recordFields
  
      /// Creates an uninitialized instance for given record
      member inline __.CreateUninitialized() = 
          FormatterServices.GetUninitializedObject(typeof<'Record>) :?> 'Record
  
      interface IShapeFSharpRecord with
          member __.Fields = recordFields |> Array.map unbox
  
negative.code: 
      /// Injects a value to member of given instance
      member __.Inject (instance : 'DeclaringType) (field : 'MemberType) : 'DeclaringType =
          injectFunc.Value.Invoke(instance, field)
  
      /// Injects a value to member of given instance
      member __.InjectExpr (instance : Expr<'DeclaringType>) (field : Expr<'MemberType>) =
  