rdl 1.1.1 → 2.0.0.rc1

data/types/ruby-2.x/integer.rb

@@ -1,32 +1,197 @@
 class Integer < Numeric
   rdl_nowrap
 
-  type :ceil, '() -> Integer'
+  type :%, '(Fixnum x {{ x!=0 }}) -> Fixnum'
+  type :%, '(Bignum x {{ x!=0 }}) -> %integer'
+  type :%, '(Float x {{ x!=0 }}) -> Float'
+  type :%, '(Rational x {{ x!=0 }}) -> Rational'
+  type :%, '(BigDecimal x {{ x!=0 }}) -> BigDecimal'
+
+  type :&, '(%integer) -> Fixnum'
+
+  type :*, '(%integer) -> %integer'
+  type :*, '(Float) -> Float'
+  type :*, '(Rational) -> Rational'
+  type :*, '(BigDecimal) -> BigDecimal'
+  type :*, '(Complex) -> Complex'
+  pre(:*) { |x| if (x.real.is_a?(BigDecimal)||x.imaginary.is_a?(BigDecimal)) then (if x.real.is_a?(Float) then (x.real!=Float::INFINITY && !(x.real.nan?)) elsif(x.imaginary.is_a?(Float)) then x.imaginary!=Float::INFINITY && !(x.imaginary.nan?) else true end) else true end} #can't have a complex with part BigDecimal, other part infinity/NAN
+
+  type :**, '(%integer) -> %numeric'
+  type :**, '(Float) -> %numeric'
+  type :**, '(Rational) -> %numeric'
+  type :**, '(BigDecimal) -> BigDecimal'
+  pre(:**) { |x| x!=BigDecimal::INFINITY && if self<0 then x<=-1||x>=0 else true end}
+  post(:**) { |r,x| r.real?}
+  type :**, '(Complex) -> Complex'
+  pre(:**) { |x| x!=0 && if (x.real.is_a?(BigDecimal)||x.imaginary.is_a?(BigDecimal)) then (if x.real.is_a?(Float) then (x.real!=Float::INFINITY && !(x.real.nan?)) elsif(x.imaginary.is_a?(Float)) then x.imaginary!=Float::INFINITY && !(x.imaginary.nan?) else true end) else true end}
+
+  type :+, '(%integer) -> %integer'
+  type :+, '(Float) -> Float'
+  type :+, '(Rational) -> Rational'
+  type :+, '(BigDecimal) -> BigDecimal'
+  type :+, '(Complex) -> Complex'
+
+  type :-, '(%integer) -> %integer'
+  type :-, '(Float) -> Float'
+  type :-, '(Rational) -> Rational'
+  type :-, '(BigDecimal) -> BigDecimal'
+  type :-, '(Complex) -> Complex'
+
+  type :-, '() -> %integer'
+
+  type :/, '(%integer x {{ x!=0 }}) -> %integer'
+  type :/, '(Float x {{ x!=0 }}) -> Float'
+  type :/, '(Rational x {{ x!=0 }}) -> Rational'
+  type :/, '(BigDecimal x {{ x!=0 }}) -> BigDecimal'
+  type :/, '(Complex x {{ x!=0 }}) -> Complex'
+  pre(:/) { |x| x!=0 && if (x.real.is_a?(BigDecimal)||x.imaginary.is_a?(BigDecimal)) then (if x.real.is_a?(Float) then (x.real!=Float::INFINITY && !(x.real.nan?)) elsif(x.imaginary.is_a?(Float)) then x.imaginary!=Float::INFINITY && !(x.imaginary.nan?) else true end) else true end && if (x.real.is_a?(Rational) && x.imaginary.is_a?(Float)) then !x.imaginary.nan? else true end}
+
+  type :<, '(%integer) -> %bool'
+  type :<, '(Float) -> %bool'
+  type :<, '(Rational) -> %bool'
+  type :<, '(BigDecimal) -> %bool'
+
+  type :<<, '(Fixnum) -> %integer'
+
+  type :<=, '(%integer) -> %bool'
+  type :<=, '(Float) -> %bool'
+  type :<=, '(Rational) -> %bool'
+  type :<=, '(BigDecimal) -> %bool'
+
+  type :<=>, '(%integer) -> Object'
+  post(:<=>) { |r,x| r == -1 || r==0 || r==1}
+  type :<=>, '(Float) -> Object'
+  post(:<=>) { |r,x| r == -1 || r==0 || r==1}
+  type :<=>, '(Rational) -> Object'
+  post(:<=>) { |r,x| r == -1 || r==0 || r==1}
+  type :<=>, '(BigDecimal) -> Object'
+  post(:<=>) { |r,x| r == -1 || r==0 || r==1}
+
+  type :==, '(Object) -> %bool'
+
+  type :===, '(Object) -> %bool'
+
+  type :>, '(%integer) -> %bool'
+  type :>, '(Float) -> %bool'
+  type :>, '(Rational) -> %bool'
+  type :>, '(BigDecimal) -> %bool'
+
+  type :>=, '(%integer) -> %bool'
+  type :>=, '(Float) -> %bool'
+  type :>=, '(Rational) -> %bool'
+  type :>=, '(BigDecimal) -> %bool'
+
+  type :>>, '(%integer) -> %integer r {{ r>=0 }}'
+
+  type :[], '(%integer) -> Fixnum'
+  post(:[]) { |r,x| r == 0 || r==1}
+  type :[], '(Rational) -> Fixnum'
+  post(:[]) { |r,x| r == 0 || r==1}
+  type :[], '(Float) -> Fixnum'
+  pre(:[]) { |x| x!=Float::INFINITY && !x.nan? }
+  post(:[]) { |r,x| r == 0 || r==1}
+  type :[], '(BigDecimal) -> Fixnum'
+  pre(:[]) { |x| x!=BigDecimal::INFINITY && !x.nan? }
+  post(:[]) { |r,x| r == 0 || r==1}
+
+  type :^, '(%integer) -> %integer'
+
+  type :|, '(%integer) -> %integer'
+
+  type :~, '() -> %integer'
+
+  type :abs, '() -> %integer r {{ r>=0 }}'
+
+  type :bit_length, '() -> %integer r {{ r>=0 }}'
+
+  type :div, '(%integer x {{ x!=0 }}) -> %integer'
+  type :div, '(Float x {{ x!=0 && !x.nan? }}) -> %integer'
+  type :div, '(Rational x {{ x!=0 }}) -> %integer'
+  type :div, '(BigDecimal x {{ x!=0 && !x.nan? }}) -> %integer'
+
+  type :divmod, '(%real x {{ x!=0 }}) -> [%real, %real]'
+  pre(:divmod) { |x| if x.is_a?(Float) then !x.nan? else true end}
+
+  type :fdiv, '(%integer) -> Float'
+  type :fdiv, '(Float) -> Float'
+  type :fdiv, '(Rational) -> Float'
+  type :fdiv, '(BigDecimal) -> BigDecimal'
+  type :fdiv, '(Complex) -> Complex'
+  pre(:fdiv) { |x| if (x.real.is_a?(BigDecimal)||x.imaginary.is_a?(BigDecimal)) then (if x.real.is_a?(Float) then (x.real!=Float::INFINITY && !(x.real.nan?)) elsif(x.imaginary.is_a?(Float)) then x.imaginary!=Float::INFINITY && !(x.imaginary.nan?) else true end) else true end && if (x.real.is_a?(Rational) && x.imaginary.is_a?(Float)) then !x.imaginary.nan? else true end}
+
+  type :to_s, '() -> String'
+  type :inspect, '() -> String'
+
+  type :magnitude, '() -> %integer r {{ r>=0 }}'
+
+  type :modulo, '(Fixnum x {{ x!=0 }}) -> Fixnum'
+  type :modulo, '(Bignum x {{ x!=0 }}) -> %integer'
+  type :modulo, '(Float x {{ x!=0 }}) -> Float'
+  type :modulo, '(Rational x {{ x!=0 }}) -> Rational'
+  type :modulo, '(BigDecimal x {{ x!=0 }}) -> BigDecimal'
+
+  type :quo, '(%integer x {{ x!=0 }}) -> Rational'
+  type :quo, '(Float x {{ x!=0 }}) -> Float'
+  type :quo, '(Rational x {{ x!=0 }}) -> Rational'
+  type :quo, '(BigDecimal x {{ x!=0 }}) -> BigDecimal'
+  type :quo, '(Complex x {{ x!=0 }}) -> Complex'
+  pre(:quo) { |x| if (x.real.is_a?(BigDecimal)||x.imaginary.is_a?(BigDecimal)) then (if x.real.is_a?(Float) then (x.real!=Float::INFINITY && !(x.real.nan?)) elsif(x.imaginary.is_a?(Float)) then x.imaginary!=Float::INFINITY && !(x.imaginary.nan?) else true end) else true end && if (x.real.is_a?(Rational) && x.imaginary.is_a?(Float)) then !x.imaginary.nan? else true end}
+
+  type :abs2, '() -> %integer r {{ r>=0 }}'
+  type :angle, '() -> %numeric'
+  post(:angle) { |r,x| r == 0 || r == Math::PI}
+  type :arg, '() -> %numeric'
+  post(:arg) { |r,x| r == 0 || r == Math::PI}
+  type :equal?, '(Object) -> %bool'
+  type :eql?, '(Object) -> %bool'
+  type :hash, '() -> %integer'
+  type :ceil, '() -> %integer'
   type :chr, '(Encoding) -> String'
+  type :coerce, '(%numeric) -> [%real, %real]'
+  pre(:coerce) { |x| if x.is_a?(Complex) then x.imaginary==0 else true end}
+  type :conj, '() -> %integer'
+  type :conjugate, '() -> %integer'
   type :denominator, '() -> Fixnum'
   post(:denominator) { |r,x| r == 1 }
-  type :downto, '(Integer) { (Integer) -> %any } -> Integer'
-  type :downto, '(Integer limit) -> Enumerator<Integer>'
+  type :downto, '(%integer) { (%integer) -> %any } -> %integer'
+  type :downto, '(%integer limit) -> Enumerator<%integer>'
   type :even?, '() -> %bool'
-  type :gcd, '(Integer) -> Integer'
-  type :gcdlcm, '(Integer) -> [Integer, Integer]'
-  type :floor, '() -> Integer'
-  type :integer?, '() -> TrueClass'
-  type :lcm, '(Integer) -> Integer'
-  type :next, '() -> Integer'
-  type :numerator, '() -> Integer'
+  type :gcd, '(%integer) -> %integer'
+  type :gcdlcm, '(%integer) -> [%integer, %integer]'
+  type :floor, '() -> %integer'
+  type :imag, '() -> Fixnum r {{ r==0 }}'
+  type :imaginary, '() -> Fixnum r {{ r==0 }}'
+  type :integer?, '() -> true'
+  type :lcm, '(%integer) -> %integer'
+  type :next, '() -> %integer'
+  type :numerator, '() -> %integer'
   type :odd?, '() -> %bool'
-  type :ord, '() -> Integer'
-  type :pred, '() -> Integer'
-  type :rationalize, '(Numeric) -> Rational'
-  type :round, '(Numeric) -> Numeric'
-  type :succ, '() -> Integer'
-  type :times, '() { (Integer) -> %any } -> Integer'
-  type :times, '() -> Enumerator<Integer>'
-  type :to_i, '() -> Integer'
-  type :to_int, '() -> Integer'
+  type :ord, '() -> %integer'
+  type :phase, '() -> %numeric'
+  type :pred, '() -> %integer'
+  type :rationalize, '() -> Rational'
+  type :rationalize, '(%numeric) -> Rational'
+  type :real, '() -> %integer'
+  type :real?, '() -> true'
+  type :remainder, '(Fixnum x {{ x!=0 }}) -> Fixnum r {{ r>=0 }}'
+  type :remainder, '(Bignum x {{ x!=0 }}) -> Fixnum r {{ r>=0 }}'
+  type :remainder, '(Float x {{ x!=0 }}) -> Float'
+  type :remainder, '(Rational x {{ x!=0 }}) -> Rational r {{ r>=0 }}'
+  type :remainder, '(BigDecimal x {{ x!=0 }}) -> BigDecimal'
+  type :round, '() -> %integer'
+  type :round, '(%numeric) -> %numeric'
+  pre(:round) { |x| x!=0 && if x.is_a?(Complex) then x.imaginary==0 && (if x.real.is_a?(Float)||x.real.is_a?(BigDecimal) then !x.real.infinite? && !x.real.nan? else true end) elsif x.is_a?(Float) then x!=Float::INFINITY && !x.nan? elsif x.is_a?(BigDecimal) then x!=BigDecimal::INFINITY && !x.nan? else true end} #Also, x must be in range [-2**31, 2**31].
+  type :size, '() -> %integer'
+  type :succ, '() -> %integer'
+  type :times, '() { (%integer) -> %any } -> %integer'
+  type :times, '() -> Enumerator<%integer>'
+  type :to_c, '() -> Complex r {{ r.imaginary==0 }}'
+  type :to_f, '() -> Float'
+  type :to_i, '() -> %integer'
+  type :to_int, '() -> %integer'
   type :to_r, '() -> Rational'
-  type :truncate, '() -> Integer'
-  type :upto, '(Integer) { (Integer) -> %any } -> Integer'
-  type :upto, '(Integer) -> Enumerator<Integer>'
+  type :truncate, '() -> %integer'
+  type :upto, '(%integer) { (%integer) -> %any } -> %integer'
+  type :upto, '(%integer) -> Enumerator<%integer>'
+  type :zero?, '() -> %bool'
 end

data/types/ruby-2.x/nil.rb

@@ -0,0 +1,12 @@
+class NilClass
+  rdl_nowrap
+  type :&, '(%any obj) -> false'
+  type :'^', '(%any obj) -> %bool'
+  type :|, '(%any obj) -> %bool'
+  type :rationalize, '() -> Rational'
+  type :to_a, '() -> []'
+  type :to_c, '() -> Complex'
+  type :to_f, '() -> 0.0'
+  type :to_h, '() -> {}'
+  type :to_r, '() -> Rational'
+end

data/types/ruby-2.x/numeric.rb

@@ -1,56 +1,56 @@
 class Numeric
   rdl_nowrap
 
-  type :%, '(Numeric) -> Numeric'
+  type :%, '(%numeric) -> %numeric'
   pre(:%) { |x| x!=0}
-  type :+, '(Numeric) -> Numeric'
-  type :-, '() -> Numeric'
-  type :<=>, '(Numeric) -> Object'
+  type :+, '(%numeric) -> %numeric'
+  type :-, '() -> %numeric'
+  type :<=>, '(%numeric) -> Object'
   post(:<=>) { |r,x| r == -1 || r==0 || r==1 || r==nil}
-  type :abs, '() -> Numeric'
+  type :abs, '() -> %numeric'
   post(:abs) { |r,x| r >= 0 }
-  type :abs2, '() -> Numeric'
+  type :abs2, '() -> %numeric'
   post(:abs2) { |r,x| r >= 0 }
-  type :angle, '() -> Numeric'
-  type :arg, '() -> Numeric'
-  type :ceil, '() -> Integer'
-  type :coerce, '(Numeric) -> [Numeric, Numeric]'
-  type :conj, '() -> Numeric'
-  type :conjugate, '() -> Numeric'
-  type :denominator, '() -> Integer'
+  type :angle, '() -> %numeric'
+  type :arg, '() -> %numeric'
+  type :ceil, '() -> %integer'
+  type :coerce, '(%numeric) -> [%numeric, %numeric]'
+  type :conj, '() -> %numeric'
+  type :conjugate, '() -> %numeric'
+  type :denominator, '() -> %integer'
   post(:denominator) { |r,x| r >= 0 }
-  type :div, '(Numeric) -> Integer'
+  type :div, '(%numeric) -> %integer'
   pre(:div) { |x| x!=0}
-  type :divmod, '(Numeric) -> [Numeric, Numeric]'
+  type :divmod, '(%numeric) -> [%numeric, %numeric]'
   pre(:divmod) { |x| x!=0 }
-  type :eql?, '(Numeric) -> %bool'
-  type :fdiv, '(Numeric) -> Numeric'
-  type :floor, '() -> Integer'
+  type :eql?, '(%numeric) -> %bool'
+  type :fdiv, '(%numeric) -> %numeric'
+  type :floor, '() -> %integer'
   type :i, '() -> Complex'
-  type :imag, '() -> Numeric'
-  type :imaginary, '() -> Numeric'
+  type :imag, '() -> %numeric'
+  type :imaginary, '() -> %numeric'
   type :integer?, '() -> %bool'
-  type :magnitude, '() -> Numeric'
-  type :modulo, '(Numeric) -> %real'
+  type :magnitude, '() -> %numeric'
+  type :modulo, '(%numeric) -> %real'
   pre(:modulo) { |x| x!=0 }
   type :nonzero?, '() -> self or nil'
-  type :numerator, '() -> Integer'
-  type :phase, '() -> Numeric'
-  type :polar, '() -> [Numeric, Numeric]'
-  type :quo, '(Numeric) -> Numeric'
-  type :real, '() -> Numeric'
-  type :real?, '() -> Numeric'
-  type :rect, '() -> [Numeric, Numeric]'
-  type :rectangular, '() -> [Numeric, Numeric]'
-  type :remainder, '(Numeric) -> %real'
-  type :round, '(Numeric) -> Numeric'
+  type :numerator, '() -> %integer'
+  type :phase, '() -> %numeric'
+  type :polar, '() -> [%numeric, %numeric]'
+  type :quo, '(%numeric) -> %numeric'
+  type :real, '() -> %numeric'
+  type :real?, '() -> %numeric'
+  type :rect, '() -> [%numeric, %numeric]'
+  type :rectangular, '() -> [%numeric, %numeric]'
+  type :remainder, '(%numeric) -> %real'
+  type :round, '(%numeric) -> %numeric'
   type :singleton_method_added, '(Symbol) -> TypeError'
-  type :step, '(Numeric) { (Numeric) -> %any } -> Numeric'
-  type :step, '(Numeric) -> Enumerator<Numeric>'
-  type :step, '(Numeric, Numeric) { (Numeric) -> %any } -> Numeric'
-  type :step, '(Numeric, Numeric) -> Enumerator<Numeric>'
+  type :step, '(%numeric) { (%numeric) -> %any } -> %numeric'
+  type :step, '(%numeric) -> Enumerator<%numeric>'
+  type :step, '(%numeric, %numeric) { (%numeric) -> %any } -> %numeric'
+  type :step, '(%numeric, %numeric) -> Enumerator<%numeric>'
   type :to_c, '() -> Complex'
-  type :to_int, '() -> Integer'
-  type :truncate, '() -> Integer'
+  type :to_int, '() -> %integer'
+  type :truncate, '() -> %integer'
   type :zero?, '() -> %bool'
 end

data/types/ruby-2.x/object.rb

@@ -26,10 +26,10 @@ class Object
   type :===, '(%any other) -> %bool'
   type :=~, '(%any other) -> nil'
   type :class, '() -> Class'
-  type :clone, '() -> %any'
+  type :clone, '() -> self'
 #  type :define_singleton_method, '(XXXX : *XXXX)') # TODO
   type :display, '(IO port) -> nil'
-  type :dup, '() -> %any an_object'
+  type :dup, '() -> self an_object'
   type :enum_for, '(?Symbol method, *%any args) -> Enumerator<%any>'
   type :enum_for, '(?Symbol method, *%any args) { (*%any args) -> %any } -> Enumerator<%any>'
   type :eql?, '(%any other) -> %bool'
@@ -55,7 +55,7 @@ class Object
   type :public_send, '(Symbol or String, *%any args) -> %any'
   type :remove_instance_variable, '(Symbol) -> %any'
 #  type :respond_to?, '(Symbol or String, ?%bool include_all) -> %bool'
-#  type :send, '(Symbol or String, *%any args) -> %any' # Can't wrap this, used outside wrap switch
+  type :send, '(Symbol or String, *%any args) -> %any', wrap: false # Can't wrap this, used outside wrap switch
   type :singleton_class, '() -> Class'
   type :singleton_method, '(Symbol) -> Method'
   type :singleton_methods, '(?%bool all) -> Array<Symbol>'

data/types/ruby-2.x/random.rb

@@ -1,3 +1,5 @@
+require_relative 'range.rb'
+
 class Random
   rdl_nowrap
 

data/types/ruby-2.x/range.rb

@@ -1,38 +1,39 @@
 class Range
   rdl_nowrap
 
-  type_params([:t], nil) { |t| t.member?(self.begin) && t.member?(self.end) } # TODO: And instantiated if t instantiated
+  # Range is immutable, so covariant
+  type_params([:t], nil, variance: [:+]) { |t| t.member?(self.begin) && t.member?(self.end) } # TODO: And instantiated if t instantiated
 
   # TODO: Parse error
 #  type 'self.new', '(begin: [<=> : (u, u) -> Fixnum], end: [<=>, (u, u) -> Fixnum], exclude_end: ?%bool) -> Range<u>'
   type :==, '(%any obj) -> %bool'
   type :===, '(%any obj) -> %bool'
-  type :begin, '() -> u'
-  type :bsearch, '() { (u) -> %bool } -> u or nil'
+  type :begin, '() -> t'
+  type :bsearch, '() { (t) -> %bool } -> u or nil'
   type :cover?, '(%any obj) -> %bool'
   type :each, '() { (t) -> %any } -> self'
-  type :each, '() -> Enumerator<u>'
-  type :end, '() -> u'
+  type :each, '() -> Enumerator<t>'
+  type :end, '() -> t'
   rdl_alias :eql?, :==
   type :exclude_end?, '() -> %bool'
-  type :first, '() -> u'
-  type :first, '(Fixnum n) -> Array<u>'
+  type :first, '() -> t'
+  type :first, '(Fixnum n) -> Array<t>'
   type :hash, '() -> Fixnum'
   type :include?, '(%any obj) -> %bool'
   type :inspect, '() -> String'
-  type :last, '() -> u'
-  type :last, '(Fixnum n) -> Array<u>'
-  type :max, '() -> u'
-  type :max, '() { (u, u) -> Fixnum } -> u'
-  type :max, '(Fixnum n) -> Array<u>'
-  type :max, '(Fixnum n) { (u, u) -> Fixnum } -> Array<u>'
+  type :last, '() -> t'
+  type :last, '(Fixnum n) -> Array<t>'
+  type :max, '() -> t'
+  type :max, '() { (t, t) -> Fixnum } -> t'
+  type :max, '(Fixnum n) -> Array<t>'
+  type :max, '(Fixnum n) { (t, t) -> Fixnum } -> Array<t>'
   rdl_alias :member?, :include
-  type :min, '() -> u'
-  type :min, '() { (u, u) -> Fixnum } -> u'
-  type :min, '(Fixnum n) -> Array<u>'
-  type :min, '(Fixnum n) { (u, u) -> Fixnum } -> Array<u>'
+  type :min, '() -> t'
+  type :min, '() { (t, t) -> Fixnum } -> t'
+  type :min, '(Fixnum n) -> Array<t>'
+  type :min, '(Fixnum n) { (t, t) -> Fixnum } -> Array<t>'
   type :size, '() -> Fixnum or nil'
-  type :step, '(?Fixnum n) { (u) -> %any } -> self'
-  type :step, '(?Fixnum n) -> Enumerator<u>'
+  type :step, '(?Fixnum n) { (t) -> %any } -> self'
+  type :step, '(?Fixnum n) -> Enumerator<t>'
   type :to_s, '() -> String'
 end

data/types/ruby-2.x/rational.rb

@@ -1,7 +1,7 @@
 class Rational < Numeric
   rdl_nowrap
 
-  type :%, '(Integer) -> Rational'
+  type :%, '(%integer) -> Rational'
   pre(:%) { |x| x!=0}
   type :%, '(Float) -> Float'
   pre(:%) { |x| x!=0&&!x.nan?}
@@ -10,20 +10,20 @@ class Rational < Numeric
   type :%, '(BigDecimal) -> BigDecimal'
   pre(:%) { |x| x!=0&&!x.nan?}
 
-  type :*, '(Integer) -> Rational'
+  type :*, '(%integer) -> Rational'
   type :*, '(Float) -> Float'
   type :*, '(Rational) -> Rational'
   type :*, '(BigDecimal) -> BigDecimal'
   type :*, '(Complex) -> Complex'
   pre(:*) { |x| if (x.real.is_a?(BigDecimal)||x.imaginary.is_a?(BigDecimal)) then (if x.real.is_a?(Float) then (x.real!=Float::INFINITY && !(x.real.nan?)) elsif(x.imaginary.is_a?(Float)) then x.imaginary!=Float::INFINITY && !(x.imaginary.nan?) else true end) else true end} #can't have a complex with part BigDecimal, other part infinity/NAN
 
-  type :+, '(Integer) -> Rational'
+  type :+, '(%integer) -> Rational'
   type :+, '(Float) -> Float'
   type :+, '(Rational) -> Rational'
   type :+, '(BigDecimal) -> BigDecimal'
   type :+, '(Complex) -> Complex'
 
-  type :-, '(Integer) -> Rational'
+  type :-, '(%integer) -> Rational'
   type :-, '(Float) -> Float'
   type :-, '(Rational) -> Rational'
   type :-, '(BigDecimal) -> BigDecimal'
@@ -31,16 +31,16 @@ class Rational < Numeric
 
   type :-, '() -> Rational'
 
-  type :**, '(Integer) -> Numeric'
-  type :**, '(Float) -> Numeric'
-  type :**, '(Rational) -> Numeric'
+  type :**, '(%integer) -> %numeric'
+  type :**, '(Float) -> %numeric'
+  type :**, '(Rational) -> %numeric'
   type :**, '(BigDecimal) -> BigDecimal'
   pre(:**) { |x| x!=BigDecimal::INFINITY && if self<0 then x<=-1||x>=0 else true end}
   post(:**) { |r,x| r.real?}
   type :**, '(Complex) -> Complex'
   pre(:**) { |x| x!=0 && if (x.real.is_a?(BigDecimal)||x.imaginary.is_a?(BigDecimal)) then (if x.real.is_a?(Float) then (x.real!=Float::INFINITY && !(x.real.nan?)) elsif(x.imaginary.is_a?(Float)) then x.imaginary!=Float::INFINITY && !(x.imaginary.nan?) else true end) else true end}
 
-  type :/, '(Integer) -> Rational'
+  type :/, '(%integer) -> Rational'
   pre(:/) { |x| x!=0}
   type :/, '(Float) -> Float'
   pre(:/) { |x| x!=0}
@@ -51,35 +51,35 @@ class Rational < Numeric
   type :/, '(Complex) -> Complex'
   pre(:/) { |x| x!=0 && if (x.real.is_a?(BigDecimal)||x.imaginary.is_a?(BigDecimal)) then (if x.real.is_a?(Float) then (x.real!=Float::INFINITY && !(x.real.nan?)) elsif(x.imaginary.is_a?(Float)) then x.imaginary!=Float::INFINITY && !(x.imaginary.nan?) else true end) else true end && if (x.real.is_a?(Rational) && x.imaginary.is_a?(Float)) then !x.imaginary.nan? else true end}
 
-  type :<, '(Integer) -> %bool'
+  type :<, '(%integer) -> %bool'
   type :<, '(Float) -> %bool'
   pre(:<) { |x| !x.nan?}
   type :<, '(Rational) -> %bool'
   type :<, '(BigDecimal) -> %bool'
   pre(:<) { |x| !x.nan?}
 
-  type :<=, '(Integer) -> %bool'
+  type :<=, '(%integer) -> %bool'
   type :<=, '(Float) -> %bool'
   pre(:<=) { |x| !x.nan?}
   type :<=, '(Rational) -> %bool'
   type :<=, '(BigDecimal) -> %bool'
   pre(:<=) { |x| !x.nan?}
 
-  type :>, '(Integer) -> %bool'
+  type :>, '(%integer) -> %bool'
   type :>, '(Float) -> %bool'
   pre(:>) { |x| !x.nan?}
   type :>, '(Rational) -> %bool'
   type :>, '(BigDecimal) -> %bool'
   pre(:>) { |x| !x.nan?}
 
-  type :>=, '(Integer) -> %bool'
+  type :>=, '(%integer) -> %bool'
   type :>=, '(Float) -> %bool'
   pre(:>=) { |x| !x.nan?}
   type :>=, '(Rational) -> %bool'
   type :>=, '(BigDecimal) -> %bool'
   pre(:>=) { |x| !x.nan?}
 
-  type :<=>, '(Integer) -> Object'
+  type :<=>, '(%integer) -> Object'
   post(:<=>) { |r,x| r == -1 || r==0 || r==1}
   type :<=>, '(Float) -> Object'
   post(:<=>) { |r,x| r == -1 || r==0 || r==1}
@@ -96,24 +96,24 @@ class Rational < Numeric
   type :abs2, '() -> Rational'
   post(:abs2) { |r,x| r >= 0 }
 
-  type :angle, '() -> Numeric'
+  type :angle, '() -> %numeric'
   post(:angle) { |r,x| r == 0 || r == Math::PI}
 
-  type :arg, '() -> Numeric'
+  type :arg, '() -> %numeric'
   post(:arg) { |r,x| r == 0 || r == Math::PI}
 
-  type :div, '(Fixnum) -> Integer'
+  type :div, '(Fixnum) -> %integer'
   pre(:div) { |x| x!=0}
-  type :div, '(Bignum) -> Integer'
+  type :div, '(Bignum) -> %integer'
   pre(:div) { |x| x!=0}
-  type :div, '(Float) -> Integer'
+  type :div, '(Float) -> %integer'
   pre(:div) { |x| x!=0 && !x.nan?}
-  type :div, '(Rational) -> Integer'
+  type :div, '(Rational) -> %integer'
   pre(:div) { |x| x!=0}
-  type :div, '(BigDecimal) -> Integer'
+  type :div, '(BigDecimal) -> %integer'
   pre(:div) { |x| x!=0 && !x.nan?}
 
-  type :modulo, '(Integer) -> Rational'
+  type :modulo, '(%integer) -> Rational'
   pre(:modulo) { |x| x!=0}
   type :modulo, '(Float) -> Float'
   pre(:modulo) { |x| x!=0&&!x.nan?}
@@ -122,10 +122,10 @@ class Rational < Numeric
   type :modulo, '(BigDecimal) -> BigDecimal'
   pre(:modulo) { |x| x!=0&&!x.nan?}
 
-  type :ceil, '() -> Integer'
-  type :ceil, '(Integer) -> Numeric'
+  type :ceil, '() -> %integer'
+  type :ceil, '(%integer) -> %numeric'
 
-  type :denominator, '() -> Integer'
+  type :denominator, '() -> %integer'
   post(:denominator) { |r,x| r > 0 }
 
   type :divmod, '(%real) -> [%real, %real]'
@@ -133,26 +133,26 @@ class Rational < Numeric
 
   type :equal?, '(Object) -> %bool'
 
-  type :fdiv, '(Integer) -> Float'
+  type :fdiv, '(%integer) -> Float'
   type :fdiv, '(Float) -> Float'
   type :fdiv, '(Rational) -> Float'
   type :fdiv, '(BigDecimal) -> Float'
   type :fdiv, '(Complex) -> Float'
   pre(:fdiv) { |x| x.imaginary==0 && x.real.class != Float}
 
-  type :floor, '() -> Integer'
+  type :floor, '() -> %integer'
 
-  type :floor, '(Integer) -> Numeric'
+  type :floor, '(%integer) -> %numeric'
 
-  type :hash, '() -> Integer'
+  type :hash, '() -> %integer'
 
   type :inspect, '() -> String'
 
-  type :numerator, '() -> Integer'
+  type :numerator, '() -> %integer'
 
-  type :phase, '() -> Numeric'
+  type :phase, '() -> %numeric'
 
-  type :quo, '(Integer) -> Rational'
+  type :quo, '(%integer) -> Rational'
   pre(:quo) { |x| x!=0}
   type :quo, '(Float) -> Float'
   pre(:quo) { |x| x!=0}
@@ -165,25 +165,25 @@ class Rational < Numeric
 
   type :rationalize, '() -> Rational'
 
-  type :rationalize, '(Numeric) -> Rational'
+  type :rationalize, '(%numeric) -> Rational'
   pre(:quo) { |x| if x.is_a?(Float) then x!=Float::INFINITY && !x.nan? else true end}
 
-  type :round, '() -> Integer'
+  type :round, '() -> %integer'
 
-  type :round, '(Integer) -> Numeric'
+  type :round, '(%integer) -> %numeric'
 
   type :to_f, '() -> Float'
   pre(:to_f) { self<=Float::MAX}
 
-  type :to_i, '() -> Integer'
+  type :to_i, '() -> %integer'
 
   type :to_r, '() -> Rational'
 
   type :to_s, '() -> String'
 
-  type :truncate, '() -> Integer'
+  type :truncate, '() -> %integer'
 
-  type :truncate, '(Integer) -> Rational'
+  type :truncate, '(%integer) -> Rational'
 
   type :zero?, '() -> %bool'
 
@@ -197,13 +197,13 @@ class Rational < Numeric
 
   type :real, '() -> Rational'
 
-  type :real?, '() -> TrueClass'
+  type :real?, '() -> true'
 
   type :to_c, '() -> Complex'
   post(:to_c) { |r,x| r.imaginary == 0 }
 
-  type :coerce, '(Integer) -> [Rational, Rational]'
+  type :coerce, '(%integer) -> [Rational, Rational]'
   type :coerce, '(Float) -> [Float, Float]'
   type :coerce, '(Rational) -> [Rational, Rational]'
-  type :coerce, '(Complex) -> [Numeric, Numeric]'
+  type :coerce, '(Complex) -> [%numeric, %numeric]'
 end