anchor.diff:              "length" =? T<int>
   
               // Traversing
  -            "add" => T<string> + T<Dom.Element> + TSelf ^-> TSelf
  -            "add" => T<string> * T<Dom.Element> ^-> TSelf
  +            "add" => T<string> + T<Dom.Node> + TSelf ^-> TSelf
  +            "add" => T<string> * T<Dom.Node> ^-> TSelf
               "addBack" => !?T<string> ^-> TSelf
               "children" => !?T<string> ^-> TSelf
               "closest" => T<string> * !?T<Dom.Element> ^-> TSelf
  
positive.code:             "filter" => T<Dom.Element> ^-> TSelf
              "filter" => TSelf ^-> TSelf
              "find" => T<string> ^-> TSelf
              "find" => T<Dom.Element> ^-> TSelf
              "find" => TSelf ^-> TSelf
              "first" => T<unit> ^-> TSelf
              "has" => (T<string> + T<Dom.Element>) ^-> TSelf
              "is" => T<string> ^-> T<bool>
              "is" => (T<int> * T<Dom.Element> ^-> T<bool>) ^-> T<bool>
              "is" => T<Dom.Element> ^-> T<bool>
              "is" => TSelf ^-> T<bool>
              "last" => T<unit> ^-> TSelf
              "map" => ((T<int> * T<Dom.Element>) ^-> T<obj>) ^-> TSelf
              "next" => !?T<string> ^-> TSelf
              "nextAll" => !?T<string> ^-> TSelf
              "nextUntil" => T<unit> ^-> TSelf
              "nextUntil" => T<string> * !?T<string> ^-> TSelf
              "nextUntil" => (T<Dom.Element> + TSelf) * !?T<string> ^-> TSelf
              "not" => T<string> ^-> TSelf
              "not" => (T<int> * T<Dom.Element> ^-> T<bool>) ^-> TSelf
              "not" => T<Dom.Element> ^-> TSelf
              "not" => (Type.ArrayOf T<Dom.Element>) ^-> TSelf
              "not" => TSelf ^-> TSelf
              "parent" => !?T<string> ^-> TSelf
              "parents" => !?T<string> ^-> TSelf
              "parentsUntil" => T<unit> ^-> TSelf
              "parentsUntil" => T<string> * !?T<string> ^-> TSelf
              "parentsUntil" => (T<Dom.Element> + TSelf) * !?T<string> ^-> TSelf
              "prev" => !?T<string> ^-> TSelf
              "prevAll" => !?T<string> ^-> TSelf
              "prevUntil" => T<unit> ^-> TSelf
              "prevUntil" => T<string> * !?T<string> ^-> TSelf
              "prevUntil" => (T<Dom.Element> + TSelf) * !?T<string> ^-> TSelf
              "siblings" => !?T<string> ^-> TSelf
              "slice" => T<int> * !?T<int> ^-> TSelf
          ]
  
negative.code: 
      let JQueryClass =
          let EH = T<Dom.Element> -* Event ^-> T<unit>
          let Content = T<string> + T<Dom.Node> + Type.ArrayOf T<Dom.Node> + TSelf
          let Func = T<int> ^-> Content
          let FuncWithHTML = T<int> * T<string> ^-> Content
          JQ
          |+> Instance [
              "ignore" =? T<unit>
  