rdl 2.0.1 → 2.1.0

data/lib/types/core/bigmath.rb

@@ -0,0 +1,10 @@
+RDL.nowrap :BigMath
+
+RDL.type :BigMath, 'self.exp', '(Integer, Integer) -> BigDecimal'
+RDL.type :BigMath, 'self.log', '(Integer, Integer) -> BigDecimal'
+RDL.type :BigMath, :E, '(Integer) -> BigDecimal'
+RDL.type :BigMath, :PI, '(Integer) -> BigDecimal'
+RDL.type :BigMath, :atan, '(Integer, Integer) -> BigDecimal'
+RDL.type :BigMath, :cos, '(Integer, Integer) -> BigDecimal'
+RDL.type :BigMath, :sin, '(Integer, Integer) -> BigDecimal'
+RDL.type :BigMath, :sqrt, '(Integer, Integer) -> BigDecimal'

data/lib/types/core/bignum.rb

@@ -0,0 +1,214 @@
+RDL.nowrap :Bignum
+
+RDL.type :Bignum, :%, '(Fixnum x {{ x!=0 }}) -> Fixnum', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :%, '(Bignum x {{ x!=0 }}) -> Integer', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :%, '(Float x {{ x!=0 }}) -> Float', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :%, '(Rational x {{ x!=0 }}) -> Rational', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :%, '(BigDecimal x {{ x!=0 }}) -> BigDecimal', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :&, '(Integer) -> Integer', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :*, '(Fixnum) -> Integer', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :*, '(Bignum) -> Bignum', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :*, '(Float) -> Float', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :*, '(Rational) -> Rational', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :*, '(BigDecimal) -> BigDecimal', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :*, '(Complex) -> Complex', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.pre(:Bignum, :*, version: RDL::Globals::FIXBIG_VERSIONS) { |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
+
+RDL.type :Bignum, :**, '(Integer) -> %numeric', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :**, '(Float) -> %numeric', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :**, '(Rational) -> %numeric', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :**, '(BigDecimal) -> BigDecimal', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.pre(:Bignum, :**, version: RDL::Globals::FIXBIG_VERSIONS) { |x| x!=BigDecimal::INFINITY && if self<0 then x<=-1||x>=0 else true end}
+RDL.post(:Bignum, :**, version: RDL::Globals::FIXBIG_VERSIONS) { |r,x| r.real?}
+RDL.type :Bignum, :**, '(Complex) -> Complex', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.pre(:Bignum, :**, version: RDL::Globals::FIXBIG_VERSIONS) { |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}
+
+RDL.type :Bignum, :+, '(Integer) -> Integer', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :+, '(Float) -> Float', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :+, '(Rational) -> Rational', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :+, '(BigDecimal) -> BigDecimal', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :+, '(Complex) -> Complex', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :-, '(Integer) -> Integer', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :-, '(Float) -> Float', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :-, '(Rational) -> Rational', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :-, '(BigDecimal) -> BigDecimal', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :-, '(Complex) -> Complex', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :-@, '() -> Integer', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :+@, '() -> Bignum', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :/, '(Integer x {{ x!=0 }}) -> Integer', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :/, '(Float x {{ x!=0 }}) -> Float', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :/, '(Rational x {{ x!=0 }}) -> Rational', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :/, '(BigDecimal x {{ x!=0 }}) -> BigDecimal', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :/, '(Complex x {{ x!=0 }}) -> Complex', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.pre(:Bignum, :/, version: RDL::Globals::FIXBIG_VERSIONS) { |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}
+
+RDL.type :Bignum, :<, '(Integer) -> %bool', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :<, '(Float) -> %bool', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :<, '(Rational) -> %bool', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :<, '(BigDecimal) -> %bool', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :<<, '(Fixnum) -> Integer', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :<=, '(Integer) -> %bool', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :<=, '(Float) -> %bool', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :<=, '(Rational) -> %bool', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :<=, '(BigDecimal) -> %bool', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :<=>, '(Integer) -> Object', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.post(:Bignum, :<=>, version: RDL::Globals::FIXBIG_VERSIONS) { |r,x| r == -1 || r==0 || r==1}
+RDL.type :Bignum, :<=>, '(Float) -> Object', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.post(:Bignum, :<=>, version: RDL::Globals::FIXBIG_VERSIONS) { |r,x| r == -1 || r==0 || r==1}
+RDL.type :Bignum, :<=>, '(Rational) -> Object', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.post(:Bignum, :<=>, version: RDL::Globals::FIXBIG_VERSIONS) { |r,x| r == -1 || r==0 || r==1}
+RDL.type :Bignum, :<=>, '(BigDecimal) -> Object', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.post(:Bignum, :<=>, version: RDL::Globals::FIXBIG_VERSIONS) { |r,x| r == -1 || r==0 || r==1}
+
+RDL.type :Bignum, :==, '(Object) -> %bool', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :===, '(Object) -> %bool', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :>, '(Integer) -> %bool', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :>, '(Float) -> %bool', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :>, '(Rational) -> %bool', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :>, '(BigDecimal) -> %bool', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :>=, '(Integer) -> %bool', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :>=, '(Float) -> %bool', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :>=, '(Rational) -> %bool', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :>=, '(BigDecimal) -> %bool', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :>>, '(Integer) -> Integer', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.post(:Bignum, :>>, version: RDL::Globals::FIXBIG_VERSIONS) { |r,x| r >= 0 }
+
+RDL.type :Bignum, :[], '(Integer) -> Fixnum', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.post(:Bignum, :[], version: RDL::Globals::FIXBIG_VERSIONS) { |r,x| r == 0 || r==1}
+RDL.type :Bignum, :[], '(Rational) -> Fixnum', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.post(:Bignum, :[], version: RDL::Globals::FIXBIG_VERSIONS) { |r,x| r == 0 || r==1}
+RDL.type :Bignum, :[], '(Float) -> Fixnum', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.pre(:Bignum, :[], version: RDL::Globals::FIXBIG_VERSIONS) { |x| x!=Float::INFINITY && !x.nan? }
+RDL.post(:Bignum, :[], version: RDL::Globals::FIXBIG_VERSIONS) { |r,x| r == 0 || r==1}
+RDL.type :Bignum, :[], '(BigDecimal) -> Fixnum', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.pre(:Bignum, :[], version: RDL::Globals::FIXBIG_VERSIONS) { |x| x!=BigDecimal::INFINITY && !x.nan? }
+RDL.post(:Bignum, :[], version: RDL::Globals::FIXBIG_VERSIONS) { |r,x| r == 0 || r==1}
+
+RDL.type :Bignum, :^, '(Integer) -> Integer', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :|, '(Integer) -> Integer', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :~, '() -> Bignum', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :abs, '() -> Bignum r {{ r>=0 }}', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :bit_length, '() -> Integer r {{ r>=0 }}', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :div, '(Integer x {{ x!=0 }}) -> Integer', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :div, '(Float x {{ x!=0 && !x.nan? }}) -> Integer', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :div, '(Rational x {{ x!=0 }}) -> Integer', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :div, '(BigDecimal x {{ x!=0 && !x.nan?}}) -> Integer', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :divmod, '(%real) -> [%real, %real]', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.pre(:Bignum, :divmod, version: RDL::Globals::FIXBIG_VERSIONS) { |x| x!=0 && if x.is_a?(Float) then !x.nan? else true end}
+
+RDL.type :Bignum, :even?, '() -> %bool', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :fdiv, '(Integer) -> Float', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :fdiv, '(Float) -> Float', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :fdiv, '(Rational) -> Float', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :fdiv, '(BigDecimal) -> BigDecimal', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :fdiv, '(Complex) -> Complex', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.pre(:Bignum, :fdiv, version: RDL::Globals::FIXBIG_VERSIONS) { |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}
+
+RDL.type :Bignum, :to_s, '() -> String', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :inspect, '() -> String', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :magnitude, '() -> Bignum', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.post(:Bignum, :magnitude, version: RDL::Globals::FIXBIG_VERSIONS) { |r,x| r >= 0 }
+
+RDL.type :Bignum, :modulo, '(Fixnum x {{ x!=0 }}) -> Fixnum', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :modulo, '(Bignum x {{ x!=0 }}) -> Integer', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :modulo, '(Float x {{ x!=0 }}) -> Float', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :modulo, '(Rational x {{ x!=0 }}) -> Rational', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :modulo, '(BigDecimal x {{ x!=0 }}) -> BigDecimal', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :next, '() -> Integer', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :odd?, '() -> %bool', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :size, '() -> Integer', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :succ, '() -> Integer', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :to_f, '() -> Float', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :zero?, '() -> %bool', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :ceil, '() -> Integer', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :denominator, '() -> Fixnum r {{ r==1 }}', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :floor, '() -> Integer', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :numerator, '() -> Bignum', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :quo, '(Integer x {{ x!=0 }}) -> Rational', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :quo, '(Float x {{ x!=0 }}) -> Float', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :quo, '(Rational x {{ x!=0 }}) -> Rational', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :quo, '(BigDecimal x {{ x!=0 }}) -> BigDecimal', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :quo, '(Complex x {{ x!=0 }}) -> Complex', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.pre(:Bignum, :quo, version: RDL::Globals::FIXBIG_VERSIONS) { 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}
+
+RDL.type :Bignum, :rationalize, '() -> Rational', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :rationalize, '(%numeric) -> Rational', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :round, '() -> Integer', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :round, '(%numeric) -> %numeric', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.pre(:Bignum, :round, version: RDL::Globals::FIXBIG_VERSIONS) { |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].
+
+RDL.type :Bignum, :to_i, '() -> Bignum', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :to_r, '() -> Rational', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :truncate, '() -> Integer', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :angle, '() -> %numeric', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.post(:Bignum, :angle, version: RDL::Globals::FIXBIG_VERSIONS) { |r,x| r == 0 || r == Math::PI}
+
+RDL.type :Bignum, :arg, '() -> %numeric', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.post(:Bignum, :arg, version: RDL::Globals::FIXBIG_VERSIONS) { |r,x| r == 0 || r == Math::PI}
+
+RDL.type :Bignum, :equal?, '(Object) -> %bool', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :eql?, '(Object) -> %bool', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :hash, '() -> Integer', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :phase, '() -> %numeric', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :abs2, '() -> Bignum r {{ r>=0 }}', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :conj, '() -> Bignum', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :conjugate, '() -> Bignum', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :imag, '() -> Fixnum r {{ r==0 }}', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :imaginary, '() -> Fixnum r {{ r==0 }}', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :real, '() -> Bignum', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :real?, '() -> true', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :to_c, '() -> Complex r {{ r.imaginary==0 }}', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :remainder, '(Fixnum x {{ x!=0 }}) -> Fixnum r {{ r>=0 }}', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :remainder, '(Bignum x {{ x!=0 }}) -> Fixnum r {{ r>=0 }}', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :remainder, '(Float x {{ x!=0 }}) -> Float', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :remainder, '(Rational x {{ x!=0 }}) -> Rational r {{ r>=0 }}', version: RDL::Globals::FIXBIG_VERSIONS
+RDL.type :Bignum, :remainder, '(BigDecimal x {{ x!=0 }}) -> BigDecimal', version: RDL::Globals::FIXBIG_VERSIONS
+
+RDL.type :Bignum, :coerce, '(Integer) -> [Integer, Integer]', version: RDL::Globals::FIXBIG_VERSIONS

data/lib/types/core/class.rb

@@ -0,0 +1,15 @@
+RDL.nowrap :Class
+
+RDL.type :Class, :allocate, '() -> %any' # Instance of class self
+RDL.type :Class, :inherited, '(Class) -> %any'
+#RDL.type :Class, 'initialize', '() -> '
+#RDL.type :Class, 'new', '(*%any) -> %any' #Causes two other test cases to fail
+RDL.type :Class, :superclass, '() -> Class or nil'
+
+#RDL.type :Class, :class_eval, '() {() -> %any} -> %any'
+#RDL.type :Class, :method_defined?, '(String or Symbol) -> %bool'
+#RDL.type :Class, :define_method, '(String or Symbol) {(*%any) -> %any} -> Proc'
+RDL.type :Class, :instance_methods, '(?%bool) -> Array<Symbol>'
+RDL.type :Class, :class, '() -> Class'
+RDL.type :Class, :superclass, '() -> Class'
+RDL.type :Class, :name, '() -> String'

data/lib/types/core/complex.rb

@@ -0,0 +1,123 @@
+RDL.nowrap :Complex
+
+RDL.type :Complex, :*, '(Integer) -> Complex'
+RDL.type :Complex, :*, '(Float) -> Complex'
+RDL.pre(:Complex, :*) { |x| if x.infinite?||x.nan? then !self.imaginary.is_a?(BigDecimal)&&!self.real.is_a?(BigDecimal) else true end}
+RDL.type :Complex, :*, '(Rational) -> Complex'
+RDL.type :Complex, :*, '(BigDecimal) -> Complex'
+RDL.pre(:Complex, :*) {if x.real.is_a?(Float) then !x.real.infinite? && !x.real.nan? elsif x.imaginary.is_a?(Float) then !x.imaginary.infinite? && !x.imaginary.nan? else true end}
+RDL.type :Complex, :*, '(Complex) -> Complex'
+RDL.pre(:Complex, :*) { |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}
+
+RDL.type :Complex, :**, '(Integer) -> Complex'
+RDL.type :Complex, :**, '(Float) -> Complex'
+RDL.type :Complex, :**, '(Rational) -> Complex'
+RDL.type :Complex, :**, '(BigDecimal x {{ !x.infinite? && !x.nan? && x>=0 }}) -> Complex'
+RDL.type :Complex, :**, '(Complex) -> Complex'
+RDL.pre(:Complex, :**) { |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}
+
+RDL.type :Complex, :+, '(Integer) -> Complex'
+RDL.type :Complex, :+, '(Float) -> Complex'
+RDL.pre(:Complex, :+) { |x| if x.infinite?||x.nan? then !self.real.is_a?(BigDecimal) else true end}
+RDL.type :Complex, :+, '(Rational) -> Complex'
+RDL.type :Complex, :+, '(BigDecimal) -> Complex'
+RDL.pre(:Complex, :+) {if x.real.is_a?(Float) then !x.real.infinite? && !x.real.nan? else true end}
+RDL.type :Complex, :+, '(Complex) -> Complex'
+RDL.pre(:Complex, :+) { |x| if (x.real.is_a?(BigDecimal) && self.real.is_a?(Float)) then !(self.real.infinite?||self.real.nan?) elsif x.real.is_a?(Float)&&self.real.is_a?(BigDecimal) then !(x.real.infinite?||x.real.nan?) elsif (x.imaginary.is_a?(BigDecimal) && self.imaginary.is_a?(Float)) then !(self.imaginary.infinite?||self.imaginary.nan?) elsif x.imaginary.is_a?(Float)&&self.imaginary.is_a?(BigDecimal) then !(x.imaginary.infinite?||x.imaginary.nan?) else true end}
+
+RDL.type :Complex, :-, '(Integer) -> Complex'
+RDL.type :Complex, :-, '(Float) -> Complex'
+RDL.pre(:Complex, :-) { |x| if x.infinite?||x.nan? then !self.real.is_a?(BigDecimal) else true end}
+RDL.type :Complex, :-, '(Rational) -> Complex'
+RDL.type :Complex, :-, '(BigDecimal) -> Complex'
+RDL.pre(:Complex, :-) {if x.real.is_a?(Float) then !x.real.infinite? && !x.real.nan? else true end}
+RDL.type :Complex, :-, '(Complex) -> Complex'
+RDL.pre(:Complex, :-) { |x| if (x.real.is_a?(BigDecimal) && self.real.is_a?(Float)) then !(self.real.infinite?||self.real.nan?) elsif x.real.is_a?(Float)&&self.real.is_a?(BigDecimal) then !(x.real.infinite?||x.real.nan?) elsif (x.imaginary.is_a?(BigDecimal) && self.imaginary.is_a?(Float)) then !(self.imaginary.infinite?||self.imaginary.nan?) elsif x.imaginary.is_a?(Float)&&self.imaginary.is_a?(BigDecimal) then !(x.imaginary.infinite?||x.imaginary.nan?) else true end}
+
+RDL.type :Complex, :-@, '() -> Complex'
+
+RDL.type :Complex, :+@, '() -> Complex'
+
+RDL.type :Complex, :/, '(Integer x {{ x!=0 }}) -> Complex'
+RDL.type :Complex, :/, '(Float x {{ x!=0 }}) -> Complex'
+RDL.pre(:Complex, :/) { |x| if x.infinte?||x.nan? then !self.real.is_a?(BigDecimal) && !self.imaginary.is_a?(BigDecimal) else true end}
+RDL.type :Complex, :/, '(Rational x {{ x!=0 }}) -> Complex'
+RDL.type :Complex, :/, '(BigDecimal x {{ x!=0 }}) -> Complex'
+RDL.pre(:Complex, :/) { |x| if self.real.is_a?(Float) then !self.real.infinite? && !self.real.nan? else true end && if self.imaginary.is_a?(Float) then !self.imaginary.infinite? && !self.imaginary.nan? else true end}
+RDL.type :Complex, :/, '(Complex x {{ x!=0 }}) -> Complex'
+RDL.pre(:Complex, :/) { |x| if (x.real.is_a?(BigDecimal)||x.imaginary.is_a?(BigDecimal) || self.real.is_a?(BigDecimal) || self.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) && if self.real.is_a?(Float) then !self.real.infinite? && !self.real.nan? else true end && if self.imaginary.is_a?(Float) then !self.imaginary.infinite? && !self.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}
+
+RDL.type :Complex, :==, '(Object) -> %bool'
+
+RDL.type :Complex, :abs, '() -> %numeric r {{ r>=0 || (if ((((self.real.is_a? BigDecimal)||(self.real.is_a? Float)) && self.real.nan?) || (((self.imaginary.is_a? BigDecimal)||(self.imaginary.is_a? Float)) && self.imaginary.nan?)) then r.nan? end) }}'
+
+RDL.type :Complex, :abs2, '() -> %numeric r {{ r>=0 || (if ((((self.real.is_a? BigDecimal)||(self.real.is_a? Float)) && self.real.nan?) || (((self.imaginary.is_a? BigDecimal)||(self.imaginary.is_a? Float)) && self.imaginary.nan?)) then r.nan? end) }}'
+
+RDL.type :Complex, :angle, '() -> Float'
+
+RDL.type :Complex, :arg, '() -> Float'
+
+RDL.type :Complex, :conj, '() -> Complex'
+RDL.type :Complex, :conjugate, '() -> Complex'
+
+RDL.type :Complex, :denominator, '() -> Integer'
+
+RDL.type :Complex, :equal?, '(Object) -> %bool'
+RDL.type :Complex, :eql?, '(Object) -> %bool'
+
+RDL.type :Complex, :fdiv, '(%numeric) -> Complex'
+RDL.pre(:Complex, :fdiv) { |x| if (self.real.is_a?(Float) && (self.real.infinite? || self.real.nan?))||(self.imaginary.is_a?(Float) && (self.imaginary.infinite? || self.imaginary.nan?)) then !x.is_a?(BigDecimal) && (if x.is_a?(Complex) then !x.real.is_a?(BigDecimal) && !x.imaginary.is_a?(BigDecimal) else true end) else true end}
+
+RDL.type :Complex, :hash, '() -> Integer'
+
+RDL.type :Complex, :imag, '() -> %real'
+RDL.type :Complex, :imaginary, '() -> %real'
+
+RDL.type :Complex, :inspect, '() -> String'
+
+RDL.type :Complex, :magnitude, '() -> %real'
+
+RDL.type :Complex, :numerator, '() -> Complex'
+
+RDL.type :Complex, :phase, '() -> Float'
+
+RDL.type :Complex, :polar, '() -> [%real, %real]'
+
+RDL.type :Complex, :quo, '(Integer x {{ x!=0 }}) -> Complex'
+RDL.type :Complex, :quo, '(Float x {{ x!=0 }}) -> Complex'
+RDL.pre(:Complex, :quo) { |x| if self.real.is_a?(BigDecimal)||self.imaginary.is_a?(BigDecimal) then !x.infinite? && !x.nan? else true end}
+RDL.type :Complex, :quo, '(Rational x {{ x!=0 }}) -> Complex'
+RDL.type :Complex, :quo, '(BigDecimal x {{ x!=0 }}) -> BigDecimal'
+RDL.pre(:Complex, :quo) { |x| if self.real.is_a?(Float) then !self.real.infinite?&&!self.real.nan? else true end && if self.imaginary.is_a?(Float) then !self.imaginary.infinite? && !self.imaginary.nan? else true end}
+RDL.type :Complex, :quo, '(Complex x {{ x!=0 }}) -> Complex'
+RDL.pre(:Complex, :quo) { |x| if (x.real.is_a?(BigDecimal)||x.imaginary.is_a?(BigDecimal) || self.real.is_a?(BigDecimal) || self.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) && if self.real.is_a?(Float) then !self.real.infinite? && !self.real.nan? else true end && if self.imaginary.is_a?(Float) then !self.imaginary.infinite? && !self.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}
+
+RDL.type :Complex, :rationalize, '() -> Rational'
+RDL.pre(:Complex, :rationalize) { self.imaginary==0 && if self.real.is_a?(Float)||self.real.is_a?(BigDecimal) then !self.real.infinite? && !self.real.nan? else true end}
+
+RDL.type :Complex, :rationalize, '(%numeric) -> Rational'
+RDL.pre(:Complex, :rationalize) { |x| self.imaginary==0 && if self.real.is_a?(Float)||self.real.is_a?(Rational) then (if x.is_a?(Float)||x.is_a?(BigDecimal) then !x.infinite? && !x.nan? else true end) else true end && if self.real.is_a?(Float)||self.real.is_a?(BigDecimal) then !self.real.infinite? && !self.real.nan? else true end}
+
+RDL.type :Complex, :real, '() -> %real'
+
+RDL.type :Complex, :real?, '() -> false'
+
+RDL.type :Complex, :rect, '() -> [%real, %real]'
+RDL.type :Complex, :rectangular, '() -> [%real, %real]'
+
+RDL.type :Complex, :to_c, '() -> Complex'
+
+RDL.type :Complex, :to_f, '() -> Float'
+RDL.pre(:Complex, :to_f) { self.imaginary==0}
+
+RDL.type :Complex, :to_i, '() -> Integer'
+RDL.pre(:Complex, :to_i) { self.imaginary==0 && if self.real.is_a?(Float)||self.real.is_a?(BigDecimal) then !self.real.infinite? && !self.real.nan? else true end}
+
+RDL.type :Complex, :to_r, '() -> Rational'
+RDL.pre(:Complex, :to_r) { self.imaginary==0 && if self.real.is_a?(Float)||self.real.is_a?(BigDecimal) then !self.real.infinite? && !self.real.nan? else true end}
+
+RDL.type :Complex, :to_s, '() -> String'
+
+RDL.type :Complex, :zero?, '() -> %bool'
+
+RDL.type :Complex, :coerce, '(%numeric) -> [Complex, Complex]'

data/lib/types/core/coverage.rb

@@ -0,0 +1,4 @@
+RDL.nowrap :Coverage
+
+RDL.type :Coverage, 'self.start', '() -> nil'
+RDL.type :Coverage, 'self.result', '() -> Hash<String,Array<Integer or nil>>'

data/lib/types/core/csv.rb

@@ -0,0 +1,3 @@
+RDL.nowrap :CSV
+
+RDL.type :CSV, 'self.foreach', '(String or File, ?Hash<Symbol, u>) {(Array<String>) -> %any} -> NilClass'

data/lib/types/core/date.rb

@@ -0,0 +1,4 @@
+RDL.nowrap :Date
+
+RDL.type :Date, 'self.now', '() -> DateTime'
+RDL.type :Date, :strftime, '(String) -> String'

data/lib/types/core/dir.rb

@@ -0,0 +1,37 @@
+RDL.nowrap :Dir
+
+RDL.rdl_alias :Dir, :[], :glob
+
+RDL.type :Dir, 'self.chdir', '(?(String or Pathname)) -> 0'
+RDL.type :Dir, 'self.chdir', '(?(String or Pathname)) { (String) -> u } -> u'
+RDL.type :Dir, 'self.chroot', '(String) -> 0'
+RDL.type :Dir, 'self.delete', '(String) -> 0'
+RDL.type :Dir, 'self.entries', '(String, ?Encoding) -> Array<String>'
+RDL.type :Dir, 'self.exist?', '(String file) -> %bool'
+  # exists? deprecated
+RDL.type :Dir, 'self.foreach', '(String dir, ?Encoding) { (String) -> %any } -> nil'
+RDL.type :Dir, 'self.foreach', '(String dir, ?Encoding) -> Enumerator<String>'
+RDL.type :Dir, 'self.getwd', '() -> String'
+RDL.type :Dir, 'self.glob', '(String or Array<String> pattern, ?Fixum flags) -> Array<String>'
+RDL.type :Dir, 'self.glob', '(String or Array<String> pattern, ?Fixum flags) { (String) -> %any} -> nil'
+RDL.type :Dir, 'self.home', '(?String) -> String'
+RDL.type :Dir, 'self.mkdir', '(String, ?Integer) -> 0'
+RDL.type :Dir, 'self.open', '(String, ?Encoding) -> Dir'
+RDL.type :Dir, 'self.open', '(String, ?Encoding) { (Dir) -> u } -> u'
+RDL.type :Dir, 'self.pwd', '() -> String'
+RDL.type :Dir, 'self.rmdir', '(String) -> 0'
+RDL.type :Dir, 'self.unlink', '(String) -> 0'
+RDL.type :Dir, :close, '() -> nil'
+RDL.type :Dir, :each, '() { (String) -> %any } -> self'
+RDL.type :Dir, :each, '() -> Enumerator<String>'
+RDL.type :Dir, :fileno, '() -> Integer'
+RDL.type :Dir, :initialize, '(String, ?Encoding) -> self'
+RDL.type :Dir, :inspect, '() -> String'
+RDL.type :Dir, :path, '() -> String or nil'
+RDL.type :Dir, :pos, '() -> Integer'
+RDL.type :Dir, :pos=, '(Integer) -> Integer'
+RDL.type :Dir, :read, '() -> String or nil'
+RDL.type :Dir, :rewind, '() -> self'
+RDL.type :Dir, :seek, '(Integer) -> self'
+RDL.type :Dir, :tell, '() -> Integer'
+RDL.type :Dir, :to_path, '() -> String or nil'

data/lib/types/core/encoding.rb

@@ -0,0 +1,21 @@
+RDL.nowrap :Encoding
+
+RDL.type :Encoding, 'self.aliases', '() -> Hash<String, String>'
+RDL.type :Encoding, 'self.compatible?', '(%any obj1, %any obj2) -> Encoding or nil'
+RDL.type :Encoding, 'self.default_external', '() -> Encoding'
+RDL.type :Encoding, 'self.default_external=', '(String) -> String'
+RDL.type :Encoding, 'self.default_external=', '(Encoding) -> Encoding'
+RDL.type :Encoding, 'self.default_internal', '() -> Encoding'
+RDL.type :Encoding, 'self.default_internal=', '(String) -> String or nil'
+RDL.type :Encoding, 'self.default_internal=', '(Encoding) -> Encoding or nil'
+RDL.type :Encoding, 'self.find', '(String or Encoding) -> Encoding'
+RDL.type :Encoding, 'self.list', '() -> Array<Encoding>'
+RDL.type :Encoding, 'self.name_list', '() -> Array<String>'
+
+RDL.type :Encoding, :ascii_compatible?, '() -> %bool'
+RDL.type :Encoding, :dummy?, '() -> %bool'
+RDL.type :Encoding, :inspect, '() -> String'
+RDL.type :Encoding, :name, '() -> String'
+RDL.type :Encoding, :names, '() -> Array<String>'
+RDL.type :Encoding, :replicate, '(String name) -> Encoding'
+RDL.rdl_alias :Encoding, :to_s, :name

data/lib/types/core/enumerable.rb

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