anchor.diff:      }
   
   type Clone private () =
  -   
  -//static Func<TTarget, object, object> MagicMethodHelper<TTarget, TParam, TReturn>(MethodInfo method)
  -//{
  -//    // Convert the slow MethodInfo into a fast, strongly typed, open delegate
  -//    Func<TTarget, TParam, TReturn> func = (Func<TTarget, TParam, TReturn>)Delegate.CreateDelegate
  -//        (typeof(Func<TTarget, TParam, TReturn>), method);
  -        
  -//    // Now create a more weakly typed delegate which will call the strongly typed one
  -//    Func<TTarget, object, object> ret = (TTarget target, object param) => func(target, (TParam) param);
  -//    return ret;
  -//}
  -
  -//static Func<T, object, object> MagicMethod<T>(MethodInfo method) where T : class
  -//{
  -//    // First fetch the generic form
  -//    MethodInfo genericHelper = typeof(Test).GetMethod(“MagicMethodHelper”, 
  -//        BindingFlags.Static | BindingFlags.NonPublic);
  -        
  -//    // Now supply the type arguments
  -//    MethodInfo constructedHelper = genericHelper.MakeGenericMethod
  -//        (typeof(T), method.GetParameters()[0].ParameterType, method.ReturnType);
  -            
  -//    // Now call it. The null argument is because it’s a static method.
  -//    object ret = constructedHelper.Invoke(null, new object[] {method});
  -        
  -//    // Cast the result to the right kind of delegate and return it
  -//    return (Func<T, object, object>) ret;
  -//}    
   
       static member CreateMagicMethodHelper<'TTarget, 'TReturn> (meth : MethodInfo) =
           let func = meth.CreateDelegate (typeof<Func<'TTarget, 'TReturn>>) :?> Func<'TTarget, 'TReturn>
  
positive.code:                 None
  
          member this.CloneComponent comp =
              this.Clone (comp :> obj) :?> Component
  
  type EntityBuilder = EntityBuilder of (Entity -> EntityManager -> unit)
  
  
negative.code:             |> Seq.toArray
  
          let props =
              runtimeProps
              |> Seq.choose (fun prop ->
                  if prop.CanRead && prop.CanWrite && not (ctorProps.Contains prop) && not (prop.Name = "Owner") then
                      Some prop
                  else
                      None
              )
              |> Seq.toArray
  
          let ctorGets : Func<'T, obj> [] =
              ctorProps
              |> Array.map (fun x -> Clone.MagicMethod<'T> x.GetMethod)
  
          let sets =
              props
              |> Array.map (fun x -> Clone.MagicMethod2<'T> x.SetMethod)
  
          let gets =
              props
              |> Array.map (fun x -> Clone.MagicMethod<'T> x.GetMethod)
  
          fun (comp : 'T) ->
              let finalO = ctor.Invoke (ctorGets |> Array.map (fun x -> x.Invoke (comp)))
  
              sets
              |> Array.iteri (fun i setMeth ->
                  let get = gets.[i]
                  setMeth.Invoke (finalO :?> 'T, get.Invoke (comp)) |> ignore
              )
  
              finalO :?> 'T
  
  type IEntityLookupData =
  
  