anchor.diff:                  "acos" => F
                   "asin" => F
                   "atan" => F
  -                "atan2" => DN * DN ^-> D
  -                "ceil" => DN ^-> T<int>
  +                "atan2" => D * D ^-> D
  +                "ceil" => D ^-> T<int>
                   "cos" => F
                   "exp" => F
  -                "floor" => DN ^-> T<int>
  +                "floor" => D ^-> T<int>
                   "log" => F
                   "max" => !+ T<obj> ^-> D
                   "min" => !+ T<obj> ^-> D
  -                "pow" => DN * DN ^-> D
  +                "pow" => D * D ^-> D
                   "random" => T<unit> ^-> D
  -                "round" => DN ^-> T<int>
  +                "round" => D ^-> T<int>
                   "sin" => F
                   "sqrt" => F
                   "tan" => F
  
positive.code:     module P = Pattern
  
      let EcmaFunctionT = Type.New()
      let EcmaStringT = Type.New()
      let Str = EcmaStringT + T<string>
  
      let EcmaObject =
          Generic - fun (a: CodeModel.TypeParameter) ->
  
negative.code:                 "lastIndex" =@ T<int>
              ]
          |+> Static [
                  Constructor(T<string> * !?T<string>?flags)
              ]
  
      /// The String object is used to manipulate a stored piece of text.
      let EcmaString =
          Class "String"
          |=> Inherits EcmaObjectT
          |+> Instance 
              [
                  "charAt" => T<int->string>
                  "charCodeAt" => T<int->int>
                  "concat" => !+ T<string> ^-> T<string>
                  "indexOf" => T<string> * !?T<int>?pos ^-> T<int>
                  "lastIndexOf" => T<string> * !?T<int>?pos ^-> T<int>
                  "localeCompare" => T<obj> ^-> T<int>
                  "match" => (EcmaRegExp + T<string>) ^-> T<string []>
                  "replace" => (EcmaRegExp + T<string>) * T<string> ^-> T<string>
                  "search" => !?EcmaRegExp ^-> T<int>
                  "slice" => T<int>?startPos * !?T<int>?endPos ^-> T<string>
                  "split" =>
  