anchor.diff:           let rules =
              tc.GetConstructors ()
              |> Array.map (fun c ->
  -              let returnType = Ty.ofType tc
  -              let parTypes =
  -                lazy (c.GetParameters ()
  -                      |> Array.map (fun p -> Ty.ofType p.ParameterType))
  -              let genArgs =
  -                lazy if tc.ContainsGenericParameters
  -                     then tc.GetGenericArguments () |> Array.map Ty.ofType
  -                     else [||]
  -              {new Rule<_> () with
  -                member t.ReturnType = returnType
  -                member t.ParTypes = parTypes.Force ()
  -                member t.GenericArgTypes = genArgs.Force ()
  -                member t.Invoke (genArgTys, argTys, argObjs) =
  +              {ReturnType = Ty.ofType tc
  +               ParTypes =
  +                 c.GetParameters ()
  +                 |> Array.map (fun p -> Ty.ofType p.ParameterType)
  +               GenericArgTypes =
  +                 if tc.ContainsGenericParameters
  +                 then tc.GetGenericArguments () |> Array.map Ty.ofType
  +                 else [||]
  +               Invoke = fun genArgTys argTys argObjs ->
                    let tc = if tc.ContainsGenericParameters
                             then tc.MakeGenericType genArgTys
                             else tc
  
positive.code: 
  ////////////////////////////////////////////////////////////////////////////////
  
  type [<AbstractClass>] Rule<'v> () =
    abstract ReturnType: Ty<'v>
    abstract ParTypes: array<Ty<'v>>
    abstract GenericArgTypes: array<Ty<'v>>
    abstract Invoke: array<Type> * array<Type> * array<obj> -> option<obj>
  
  module Rule =
    let mapVars v2w (rule: Rule<_>) =
      let returnType = Ty.mapVars v2w rule.ReturnType
      let parTypes = lazy Array.map (Ty.mapVars v2w) rule.ParTypes
      let genericArgTypes = lazy Array.map (Ty.mapVars v2w) rule.GenericArgTypes
      {new Rule<_> () with
        member ir.ReturnType = returnType
        member ir.ParTypes = parTypes.Force ()
        member ir.GenericArgTypes = genericArgTypes.Force ()
        member ir.Invoke (genArgTys, argTys, argObjs) =
         rule.Invoke (genArgTys, argTys, argObjs)}
  
    let freshVars (rule: Rule<Type>) : Rule<Int64> =
      mapVars (Fresh.newMapper ()) rule
  
negative.code:                  | None ->
                     failwith "Bug"
                   | Some genArgTys ->
                     rule.Invoke genArgTys argTys argVals
                     |> Option.map (fun o ->
                        (HashEqMap.add monoTy o objEnv, Value (monoTy, o))))
  
  