anchor.diff:                      member this.ReturnType = returnType
                       member this.ParTypes = [||]
                       member this.GenericArgTypes = genArgs.Force ()
  -                    member this.Invoke (genArgTys: array<Type>, _: array<obj>) =
  +                    member this.Invoke (genArgTys: array<Type>,
  +                                        argTys: array<Type>,
  +                                        _: array<obj>) =
                        (if t.IsGenericType
                         then t.GetGenericTypeDefinition().MakeGenericType(genArgTys)
                         else t).GetConstructor([||]).Invoke [||] |> Some}
  
positive.code: 
  module Engine =
    type TyEnv<'v when 'v : equality> = HashEqMap<'v, Ty<'v>>
    type ObjEnv<'v when 'v : equality> = HashEqMap<Ty<'v>, obj>
  
    type Result<'v> =
      | Value of obj
      | Ruled of ty: Ty<'v> * args: array<Result<'v>> * rule: Rule<'v>
  
    let rec tryResolveResult objEnv tyEnv result =
      match result with
       | Value _ -> Some (objEnv, result)
       | Ruled (ty, args', rule) ->
         let args = Array.zeroCreate <| Array.length args'
         let rec lp objEnv i =
  
negative.code:      rules = HashEqSet.empty
       tree = TyTree.build []}
  
    let maybeAddRulesObj (o: obj) ruleSet =
      match o with
       | null ->
         ruleSet
  