rdl 2.0.1 → 2.1.0

data/lib/types/core-ruby-2.x/enumerable.rb

@@ -1,98 +0,0 @@
-module Enumerable
-  rdl_nowrap
-
-  type_params [:t], :all?
-
-  type :all?, '() -> %bool'
-  type :all?, '() { (t) -> %bool } -> %bool'
-  type :any?, '() -> %bool'
-  type :any?, '() { (t) -> %bool } -> %bool'
-  #  type :chunk, '(XXXX : *XXXX)' # TODO
-  type :collect, '() { (t) -> u } -> Array<u>'
-  type :collect, '() -> Enumerator<t>'
-#  type :collect_concat # TODO
-  type :count, '() -> Fixnum'
-  type :count, '(%any) -> Fixnum'
-  type :count, '() { (t) -> %bool } -> Fixnum'
-  type :cycle, '(?Fixnum n) { (t) -> %any } -> nil'
-  type :cycle, '(?Fixnum n) -> Enumerator<t>'
-  type :detect, '(?Proc ifnone) { (t) -> %bool } -> t or nil' # TODO ifnone
-  type :detect, '(?Proc ifnone) -> Enumerator<t>'
-  type :drop, '(Fixnum n) -> Array<t>'
-  type :drop_while, '() { (t) -> %bool } -> Array<t>'
-  type :drop_while, '() -> Enumerator<t>'
-  type :each_cons, '(Fixnum n) { (Array<t>) -> %any } -> nil'
-  type :each_cons, '(Fixnum n) -> Enumerator<t>'
-#  type :each_entry, '(XXXX : *XXXX)' # TODO
-  rdl_alias :each_slice, :each_cons
-  type :each_with_index, '() { (t, Fixnum) -> %any } -> Enumerable<t>' # args! note may not return self
-  type :each_with_index, '() -> Enumerable<t>' # args! note may not return self
-#  type :each_with_object, '(XXXX : XXXX)' #TODO
-  type :entries, '() -> Array<t>' # TODO args?
-  rdl_alias :find, :detect
-  type :find_all, '() { (t) -> %bool } -> Array<t>'
-  type :find_all, '() -> Enumerator<t>'
-  type :find_index, '(%any value) -> Fixnum or nil'
-  type :find_index, '() { (t) -> %bool } -> Fixnum or nil'
-  type :find_index, '() -> Enumerator<t>'
-  type :first, '() -> t or nil'
-  type :first, '(Fixnum n) -> Array<t> or nil'
-#  rdl_alias :flat_map, :collect_concat
-  type :grep, '(%any) -> Array<t>'
-  type :grep, '(%any) { (t) -> u } -> Array<u>'
-  type :group_by, '() { (t) -> u } -> Hash<u, Array<t>>'
-  type :group_by, '() -> Enumerator<t>'
-  type :include?, '(%any) -> %bool'
-  type :inject, '(any initial, Symbol) -> %any' # can't tell initial, return type; not enough info in Symbol
-  type :inject, '(Symbol) -> %any'
-  type :inject, '(u initial) { (u, t) -> u } -> u'
-  type :inject, '() { (t, t) -> t } -> t' # if initial not given, first element is initial
-#  type :lazy # TODO
-  rdl_alias :map, :collect
-  type :max, '() -> t'
-  type :max, '() { (t, t) -> Fixnum } -> t'
-  type :max, '(Fixnum) -> Array<t>'
-  type :max, '(Fixnum) { (t, t) -> Fixnum } -> Array<t>'
-  type :max_by, '() -> Enumerator<t>'
-  type :max_by, '() { (t, t) -> Fixnum } -> t'
-  type :max_by, '(Fixnum) -> Enumerator<t>'
-  type :max_by, '(Fixnum) { (t, t) -> Fixnum } -> Array<t>'
-  rdl_alias :member?, :include?
-  type :min, '() -> t'
-  type :min, '() { (t, t) -> Fixnum } -> t'
-  type :min, '(Fixnum) -> Array<t>'
-  type :min, '(Fixnum) { (t, t) -> Fixnum } -> Array<t>'
-  type :min_by, '() -> Enumerator<t>'
-  type :min_by, '() { (t, t) -> Fixnum } -> t'
-  type :min_by, '(Fixnum) -> Enumerator<t>'
-  type :min_by, '(Fixnum) { (t, t) -> Fixnum } -> Array<t>'
-  type :minmax, '() -> [t, t]'
-  type :minmax, '() { (t, t) -> Fixnum } -> [t, t]'
-  type :minmax_by, '() -> [t, t]'
-  type :minmax_by, '() { (t, t) -> Fixnum } -> Enumerator<t>'
-  type :none?, '() -> %bool'
-  type :none?, '() { (t) -> %bool } -> %bool'
-  type :one?, '() -> %bool'
-  type :one?, '() { (t) -> %bool } -> %bool'
-  type :partition, '() { (t) -> %bool } -> [Array<t>, Array<t>]'
-  type :partition, '() -> Enumerator<t>'
-  rdl_alias :reduce, :inject
-  type :reject, '() { (t) -> %bool } -> Array<t>'
-  type :reject, '() -> Enumerator<t>'
-  type :reverse_each, '() { (t) -> %any } -> Enumerator<t>' # is that really the return type? TODO args
-  type :reverse_each, '() -> Enumerator<t>' # TODO args
-  rdl_alias :select, :find_all
-#  type :slice_after, '(XXXX : *XXXX)' # TODO
-#  type :slice_before, '(XXXX : *XXXX)' # TODO
-#  type :slice_when, '()' # TODO
-  type :sort, '() -> Array<t>'
-  type :sort, '() { (t, t) -> Fixnum } -> Array<t>'
-  type :sort_by, '() { (t) -> %any } -> Array<t>'
-  type :sort_by, '() -> Enumerator<t>'
-  type :take, '(Fixnum n) -> Array<t> or nil'
-  type :take_while, '() { (t) -> %bool } -> Array<t>'
-  type :take_while, '() -> Enumerator<t>'
-  rdl_alias :to_a, :entries
-  type :to_h, '() -> Hash<t, t>' # TODO args?
-#  type :zip, '(XXXX : *XXXX)' # TODO
-end

data/lib/types/core-ruby-2.x/enumerator.rb

@@ -1,26 +0,0 @@
-class Enumerator
-  rdl_nowrap
-
-  type_params [:t], :all?
-
-  type 'self.new', '(?Fixnum) { (Array<u>) -> %any } -> Enumerator<u>'
-  type 'self.new', '(?Proc) { (Array<u>) -> %any } -> Enumerator<u>' # TODO Proc
-  # TODO: deprecated form of new
-  type :each, '() { (t) -> %any } -> %any' # is there a better type?
-  type :each, '() -> self'
-  # TODO: args
-  type :each_with_index, '() { (t, Fixnum) -> %any } -> %any' # TODO args
-  type :each_with_index, '() -> Enumerator<[t, Fixnum]>' # TODO args
-  type :each_with_object, '(u) { (t, u) -> %any } -> %any' # TODO args
-  type :each_with_object, '(u) -> Enumerator<[t, u]>' # TODO args
-  type :feed, '(t) -> nil'
-  type :inspect, '() -> String'
-  type :next, '() -> t'
-  type :next_values, '() -> Array<t>'
-  type :peek, '() -> t'
-  type :peek_values, '() -> Array<t>'
-  type :rewrind, '() -> self'
-  type :size, '() -> Fixnum or Float or nil'
-  rdl_alias :with_index, :each_with_index
-  rdl_alias :with_object, :each_with_object
-end

data/lib/types/core-ruby-2.x/exception.rb

@@ -1,17 +0,0 @@
-class Exception
-  rdl_nowrap
-
-  type :==, '(%any) -> %bool'
-  type :backtrace, '() -> Array<String>'
-  type :backtrace_locations, '() -> Array<Thread::Backtrace::Location>'
-  type :cause, '() -> nil' # TODO exception is proper postcondition
-  type :exception, '(?String) -> Exception' # or error
-  # type 'initialize', '() -> '
-  type :inspect, '() -> String'
-  type :message, '() -> String'
-  # type 'method_missing', '() -> '
-  # type 'respond_to?', '() -> '
-  # type 'respond_to_missing?', '() -> '
-  type :set_backtrace, '(String or Array<String>) -> Array<String>'
-  type :to_s, '() -> String'
-end

data/lib/types/core-ruby-2.x/file.rb

@@ -1,126 +0,0 @@
-class File
-  rdl_nowrap
-
-  type 'self.absolute_path', '(String file, ?String dir) -> String abs_file'
-  type 'self.atime', '(%path or IO file) -> Time'
-  type 'self.basename', '(String file, ?String suffix) -> String base_name'
-  type 'self.birthtime', '(%path or IO file) -> Time'
-  type 'self.blockdev?', '(String or IO file) -> %bool'
-  type 'self.chardev?', '(String or IO file) -> %bool'
-  type 'self.chmod', '(Fixnum mode, *String files) -> Fixnum'
-  type 'self.chown', '(Fixnum owner, Fixnum group, *String files) -> Fixnum'
-  type 'self.ctime', '(%path or IO file) -> Time'
-  type 'self.delete', '(*String files) -> Fixnum'
-  type 'self.directory?', '(String or IO file) -> %bool'
-  type 'self.dirname', '(String file) -> String dir'
-  type 'self.executable?', '(String file) -> %bool'
-  type 'self.executable_real?', '(String file) -> %bool'
-  type 'self.exist?', '(%path or IO file) -> %bool'
-  # exists? deprecated
-  type 'self.expand_path', '(%path file, ?%path dir) -> String abs_file'
-  type 'self.extname', '(String path) -> String'
-  type 'self.file?', '(String or IO file) -> %bool'
-  type 'self.fnmatch', '(String pattern, String path, ?Fixnum flags) -> %bool'
-  rdl_alias :fnmatch?, :fnmatch
-  type 'self.ftype', '(String file) -> String' # TODO: return in set of strings
-  type 'self.grpowned?', '(String or IO file) -> %bool'
-  type 'self.identical?', '(String or IO file_1, String or IO file_2) -> %bool'
-  type 'self.join', '(*(%path or File)) -> String'
-  type 'self.lchmod', '(Fixnum mode, *String files) -> Fixnum'
-  type 'self.lchown', '(Fixnum owner, Fixnum group, *String files) -> Fixnum'
-  type 'self.link', '(String old, String new) -> 0'
-  type 'self.lstat', '(String file) -> File::Stat'
-  type 'self.mtime', '(%path or IO file) -> Time'
-  type 'self.new', '(String file, ?String mode, ?String perm, ?Fixnum opt) -> File'
-  type 'self.open', '(%path file, ?String file, ?String perm, ?Fixnum opt, mode:?String, external_encoding: ?String, internal_encoding: ?String, encoding: ?String, textmode: ?%any, binmode: ?%any, autoclose: ?%any) -> File'
-  type 'self.open', '(%path file, ?String mode, ?String perm, ?Fixnum opt, mode:?String, external_encoding: ?String, internal_encoding: ?String, encoding: ?String, textmode: ?%any, binmode: ?%any, autoclose: ?%any) { (File) -> t } -> t'
-  type 'self.owned?', '(String file) -> %bool'
-  type 'self.path', '(String path) -> String'
-  type 'self.pipe?', '(String file) -> %bool'
-  type 'self.readable?', '(String file) -> %bool'
-  type 'self.readable_real?', '(String file) -> %bool'
-  type 'self.readlink', '(String link) -> String file'
-  type 'self.readldirpath', '(String pathname, ?String dir) -> String real_pathname'
-  type 'self.realpath', '(String pathname, ?String dir) -> String real_pathname'
-  type 'self.rename', '(String old, String new) -> 0'
-  type 'self.setgid?', '(String file) -> %bool'
-  type 'self.setuid?', '(String file) -> %bool'
-  type 'self.size', '(String or IO file) -> Fixnum'
-  type 'self.size?', '(String or IO file) -> Fixnum or nil'
-  type 'self.socket?', '(String or IO file) -> %bool'
-  type 'self.split', '(String file) -> [String, String]'
-  type 'self.stat', '(%path file) -> File::Stat'
-  type 'self.sticky?', '(String file) -> %bool'
-  type 'self.symlink', '(String old, String new) -> 0'
-  type 'self.symlink?', '(String file) -> %bool'
-  type 'self.truncate', '(String file, Fixnum) -> 0'
-  type 'self.umask', '(?Fixnum) -> Fixnum'
-  rdl_alias :unlink, :delete
-  type 'self.utime', '(Time atime, Time mtime, *String files) -> Fixnum'
-  type 'self.world_readable?', '(String or IO file) -> Fixnum or nil'
-  type 'self.world_writable?', '(String or IO file) -> Fixnum or nil'
-  type 'self.writable?', '(String file) -> Fixnum or nil'
-  type 'self.writable_real?', '(String file) -> Fixnum or nil'
-  type 'self.zero?', '(String or IO file) -> Fixnum or nil'
-
-  type :atime, '() -> Time'
-  type :birthtime, '() -> Time'
-  type :chmod, '(Fixnum mode) -> 0'
-  type :chown, '(Fixnum owner, Fixnum group) -> 0'
-  type :ctime, '() -> Time'
-  type :flock, '(Fixnum) -> 0 or %bool'
-  type :lstat, '() -> File::Stat'
-  type :mtime, '() -> Time'
-  type :path, '() -> String file'
-  type :size, '() -> Fixnum'
-  rdl_alias :to_path, :path
-  type :truncate, '(Fixnum) -> 0'
-
-  class Stat
-    rdl_nowrap
-
-    type 'self.new', '(String file) -> File::Stat'
-    type :<=>, '(File::Stat other) -> -1 or 0 or 1 or nil'
-    type :atime, '() -> Time'
-    type :birthtime, '() -> Time'
-    type :blksize, '() -> Fixnum or nil'
-    type :blockdev?, '() -> %bool'
-    type :blocks, '() -> Fixnum or nil'
-    type :chardev?, '() -> %bool'
-    type :ctime, '() -> Time'
-    type :dev, '() -> Fixnum'
-    type :dev_major, '() -> Fixnum'
-    type :dev_minor, '() -> Fixnum'
-    type :directory?, '() -> %bool'
-    type :executable?, '() -> %bool'
-    type :executable_real?, '() -> %bool'
-    type :file?, '() -> %bool'
-    type :ftype, '() -> String'
-    type :gid, '() -> Fixnum'
-    type :grpowned?, '() -> %bool'
-    type :ino, '() -> Fixnum'
-    type :inspect, '() -> String'
-    type :mode, '() -> Fixnum'
-    type :mtime, '() -> Time'
-    type :nlink, '() -> Fixnum'
-    type :owned?, '() -> %bool'
-    type :pip?, '() -> %bool'
-    type :rdev, '() -> Fixnum or nil'
-    type :rdev_major, '() -> Fixnum'
-    type :rdev_minor, '() -> Fixnum'
-    type :readable?, '() -> %bool'
-    type :readable_real?, '() -> %bool'
-    type :setgid?, '() -> %bool'
-    type :setuid?, '() -> %bool'
-    type :size, '() -> Fixnum'
-    type :socket?, '() -> %bool'
-    type :sticky?, '() -> %bool'
-    type :symlink?, '() -> %bool'
-    type :uid, '() -> Fixnum'
-    type :world_readable?, '() -> Fixnum or nil'
-    type :world_writable?, '() -> Fixnum or nil'
-    type :writable?, '() -> %bool'
-    type :writable_real?, '() -> %bool'
-    type :zero?, '() -> %bool'
-  end
-end

data/lib/types/core-ruby-2.x/fileutils.rb

@@ -1,6 +0,0 @@
-module FileUtils
-  rdl_nowrap
-
-  type 'self.cp_r', '(String or Pathname, String or Pathname, ?Hash<:preserve or :noop or :verbose or :dereference_root or :remove_destination, %bool>) -> Array<String>'
-  type 'self.mkdir_p', '(String or Pathname, ?Hash<:mode or :noop or :verbose, %bool>) -> Array<String>'
-end

data/lib/types/core-ruby-2.x/fixnum.rb

@@ -1,213 +0,0 @@
-class Fixnum < Integer
-  rdl_nowrap
-
-  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 :-, '() -> Fixnum'
-
-  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(:/) { 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'
-  post(:>>) { |r,x| 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 :~, '() -> Fixnum'
-
-  type :abs, '() -> %integer r {{ r>=0 }}'
-
-  type :bit_length, '() -> Fixnum r {{ r>=0 }}'
-
-  type :div, '(Fixnum x {{ x!=0 }}) -> %integer'
-  type :div, '(Bignum x {{ x!=0 }}) -> Fixnum'
-  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 :even?, '() -> %bool'
-
-  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 :next, '() -> %integer'
-
-  type :odd?, '() -> %bool'
-
-  type :size, '() -> Fixnum'
-
-  type :succ, '() -> %integer'
-
-  type :to_f, '() -> Float'
-
-  type :zero?, '() -> %bool'
-
-  type :ceil, '() -> %integer'
-
-  type :denominator, '() -> Fixnum r {{ r==1 }}'
-
-  type :floor, '() -> %integer'
-  type :numerator, '() -> Fixnum'
-
-  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 :rationalize, '() -> Rational'
-
-  type :rationalize, '(%numeric) -> Rational'
-
-  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 :to_i, '() -> Fixnum'
-
-  type :to_r, '() -> Rational'
-
-  type :truncate, '() -> %integer'
-
-  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 :phase, '() -> %numeric'
-
-  type :abs2, '() -> %integer r {{ r>=0}}'
-
-  type :conj, '() -> Fixnum'
-  type :conjugate, '() -> Fixnum'
-
-  type :imag, '() -> Fixnum r {{ r==0 }}'
-  type :imaginary, '() -> Fixnum r {{ r==0 }}'
-
-  type :real, '() -> Fixnum'
-
-  type :real?, '() -> true'
-
-  type :to_c, '() -> Complex r {{ r.imaginary == 0 }}'
-
-  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 :coerce, '(%numeric) -> [%real, %real]'
-  pre(:coerce) { |x| if x.is_a?(Complex) then x.imaginary==0 else true end}
-end