rdl 2.0.1 → 2.1.0

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

@@ -1,17 +0,0 @@
-require_relative 'range.rb'
-
-class Random
-  rdl_nowrap
-
-  type 'self.new', '(?Integer seed) -> Random' # Floats can be passed also, but just truncated to int?
-  type 'self.new_seed', '() -> Integer'
-  type 'self.rand', '(?Integer max) -> Numeric'
-  type 'self.srand', '(?Integer number) -> Numeric old_seed'
-
-  type :==, '(%any) -> %bool'
-  type :bytes, '(Fixnum size) -> String'
-  type :rand, '(?(Integer or Range<Integer>) max) -> Integer'
-  type :rand, '(?(Float or Range<Float>) max) -> Float'
-  pre(:rand) { |max| max > 0 }
-  type :seed, '() -> Integer'
-end

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

@@ -1,39 +0,0 @@
-class Range
-  rdl_nowrap
-
-  # 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, '() -> t'
-  type :bsearch, '() { (t) -> %bool } -> u or nil'
-  type :cover?, '(%any obj) -> %bool'
-  type :each, '() { (t) -> %any } -> self'
-  type :each, '() -> Enumerator<t>'
-  type :end, '() -> t'
-  rdl_alias :eql?, :==
-  type :exclude_end?, '() -> %bool'
-  type :first, '() -> t'
-  type :first, '(Fixnum n) -> Array<t>'
-  type :hash, '() -> Fixnum'
-  type :include?, '(%any obj) -> %bool'
-  type :inspect, '() -> String'
-  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, '() -> 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) { (t) -> %any } -> self'
-  type :step, '(?Fixnum n) -> Enumerator<t>'
-  type :to_s, '() -> String'
-end

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

@@ -1,209 +0,0 @@
-class Rational < Numeric
-  rdl_nowrap
-
-  type :%, '(%integer) -> Rational'
-  pre(:%) { |x| x!=0}
-  type :%, '(Float) -> Float'
-  pre(:%) { |x| x!=0&&!x.nan?}
-  type :%, '(Rational) -> Rational'
-  pre(:%) { |x| x!=0}
-  type :%, '(BigDecimal) -> BigDecimal'
-  pre(:%) { |x| x!=0&&!x.nan?}
-
-  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 :+, '(Float) -> Float'
-  type :+, '(Rational) -> Rational'
-  type :+, '(BigDecimal) -> BigDecimal'
-  type :+, '(Complex) -> Complex'
-
-  type :-, '(%integer) -> Rational'
-  type :-, '(Float) -> Float'
-  type :-, '(Rational) -> Rational'
-  type :-, '(BigDecimal) -> BigDecimal'
-  type :-, '(Complex) -> Complex'
-
-  type :-, '() -> Rational'
-
-  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'
-  pre(:/) { |x| x!=0}
-  type :/, '(Float) -> Float'
-  pre(:/) { |x| x!=0}
-  type :/, '(Rational) -> Rational'
-  pre(:/) { |x| x!=0}
-  type :/, '(BigDecimal) -> BigDecimal'
-  pre(:/) { |x| x!=0}
-  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 :<, '(Float) -> %bool'
-  pre(:<) { |x| !x.nan?}
-  type :<, '(Rational) -> %bool'
-  type :<, '(BigDecimal) -> %bool'
-  pre(:<) { |x| !x.nan?}
-
-  type :<=, '(%integer) -> %bool'
-  type :<=, '(Float) -> %bool'
-  pre(:<=) { |x| !x.nan?}
-  type :<=, '(Rational) -> %bool'
-  type :<=, '(BigDecimal) -> %bool'
-  pre(:<=) { |x| !x.nan?}
-
-  type :>, '(%integer) -> %bool'
-  type :>, '(Float) -> %bool'
-  pre(:>) { |x| !x.nan?}
-  type :>, '(Rational) -> %bool'
-  type :>, '(BigDecimal) -> %bool'
-  pre(:>) { |x| !x.nan?}
-
-  type :>=, '(%integer) -> %bool'
-  type :>=, '(Float) -> %bool'
-  pre(:>=) { |x| !x.nan?}
-  type :>=, '(Rational) -> %bool'
-  type :>=, '(BigDecimal) -> %bool'
-  pre(:>=) { |x| !x.nan?}
-
-  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 :abs, '() -> Rational'
-  post(:abs) { |r,x| r >= 0 }
-
-  type :abs2, '() -> Rational'
-  post(:abs2) { |r,x| 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 :div, '(Fixnum) -> %integer'
-  pre(:div) { |x| x!=0}
-  type :div, '(Bignum) -> %integer'
-  pre(:div) { |x| x!=0}
-  type :div, '(Float) -> %integer'
-  pre(:div) { |x| x!=0 && !x.nan?}
-  type :div, '(Rational) -> %integer'
-  pre(:div) { |x| x!=0}
-  type :div, '(BigDecimal) -> %integer'
-  pre(:div) { |x| x!=0 && !x.nan?}
-
-  type :modulo, '(%integer) -> Rational'
-  pre(:modulo) { |x| x!=0}
-  type :modulo, '(Float) -> Float'
-  pre(:modulo) { |x| x!=0&&!x.nan?}
-  type :modulo, '(Rational) -> Rational'
-  pre(:modulo) { |x| x!=0}
-  type :modulo, '(BigDecimal) -> BigDecimal'
-  pre(:modulo) { |x| x!=0&&!x.nan?}
-
-  type :ceil, '() -> %integer'
-  type :ceil, '(%integer) -> %numeric'
-
-  type :denominator, '() -> %integer'
-  post(:denominator) { |r,x| r > 0 }
-
-  type :divmod, '(%real) -> [%real, %real]'
-  pre(:divmod) { |x| x!=0 && if x.is_a?(BigDecimal) then !x.nan? else true end}
-
-  type :equal?, '(Object) -> %bool'
-
-  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) -> %numeric'
-
-  type :hash, '() -> %integer'
-
-  type :inspect, '() -> String'
-
-  type :numerator, '() -> %integer'
-
-  type :phase, '() -> %numeric'
-
-  type :quo, '(%integer) -> Rational'
-  pre(:quo) { |x| x!=0}
-  type :quo, '(Float) -> Float'
-  pre(:quo) { |x| x!=0}
-  type :quo, '(Rational) -> Rational'
-  pre(:quo) { |x| x!=0}
-  type :quo, '(BigDecimal) -> BigDecimal'
-  pre(:quo) { |x| x!=0}
-  type :quo, '(Complex) -> Complex'
-  pre(:quo) { |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 :rationalize, '() -> 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) -> %numeric'
-
-  type :to_f, '() -> Float'
-  pre(:to_f) { self<=Float::MAX}
-
-  type :to_i, '() -> %integer'
-
-  type :to_r, '() -> Rational'
-
-  type :to_s, '() -> String'
-
-  type :truncate, '() -> %integer'
-
-  type :truncate, '(%integer) -> Rational'
-
-  type :zero?, '() -> %bool'
-
-  type :conj, '() -> Rational'
-  type :conjugate, '() -> Rational'
-
-  type :imag, '() -> Fixnum'
-  post(:imag) { |r,x| r == 0 }
-  type :imaginary, '() -> Fixnum'
-  post(:imaginary) { |r,x| r == 0 }
-
-  type :real, '() -> Rational'
-
-  type :real?, '() -> true'
-
-  type :to_c, '() -> Complex'
-  post(:to_c) { |r,x| r.imaginary == 0 }
-
-  type :coerce, '(%integer) -> [Rational, Rational]'
-  type :coerce, '(Float) -> [Float, Float]'
-  type :coerce, '(Rational) -> [Rational, Rational]'
-  type :coerce, '(Complex) -> [%numeric, %numeric]'
-end

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

@@ -1,30 +0,0 @@
-class Regexp
-  rdl_nowrap
-
-  type 'self.escape', '(String or Symbol) -> String'
-  type 'self.last_match', '() -> MatchData', wrap: false # Can't wrap or messes up MatchData
-  type 'self.last_match', '(Fixnum) -> String', wrap: false
-  type 'self.new', '(String, ?%any options, ?String kcode) -> Regexp'
-  type 'self.new', '(Regexp) -> Regexp'
-  rdl_alias 'self.compile', 'self.new'
-  rdl_alias 'self.quote', 'self.escape'
-  type 'self.try_convert', '(%any obj) -> Regexp or nil'
-  type 'self.union', '(*(Regexp or String) pats) -> Regexp'
-  type 'self.union', '(Array<Regexp or String> pats) -> Regexp'
-  type :==, '(%any other) -> %bool'
-  type :===, '(%any other) -> %bool', wrap: false # Can't wrap this of it messes with $1, $2, etc as well!
-  type :=~, '(String str) -> Fixnum or nil', wrap: false # Can't wrap this or it will mess with $1, $2, etc
-  type :casefold?, '() -> %bool'
-  type :encoding, '() -> Encoding'
-  rdl_alias :eql?, :==
-  type :fixed_encoding?, '() -> %bool'
-  type :hash, '() -> Fixnum'
-  type :inspect, '() -> String'
-  type :match, '(String, ?Fixnum) -> MatchData or nil'
-  type :named_captures, '() -> Hash<String, Array<Fixnum>>'
-  type :names, '() -> Array<String>'
-  type :options, '() -> Fixnum'
-  type :source, '() -> String'
-  type :to_s, '() -> String'
-  type :~, '() -> Fixnum or nil'
-end

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

@@ -1,58 +0,0 @@
-class Set
-  rdl_nowrap
-
-  type_params [:t], :all?
-
-  type 'self.[]', '(*u) -> Set<u>'
-  type 'self.new', '(?Enumerable<u> enum) -> Set<u>'
-
-  rdl_alias :&, :intersection
-  type :+, '(Enumerable<t> enum) -> Set<t>'
-  rdl_alias :-, :difference
-  rdl_alias :<, :proper_subset?
-  rdl_alias :<<, :add
-  rdl_alias :<=, :subset?
-  rdl_alias :>, :proper_superset?
-  rdl_alias :>=, :superset?
-  type :^, '(Enumerable<t> enum) -> Set<t>'
-  type :add, '(t o) -> self'
-  type :add?, '(t o) -> self or nil'
-  type :classify, '() { (u) -> t } -> Hash<u, Set<t>>'
-  type :clear, '() -> self'
-  rdl_alias :collect!, :map
-  type :delete, '(t o) -> self'
-  type :delete?, '(t o) -> self or nil'
-  type :delete_if, '() { (t) -> %bool } -> self'
-  type :difference, '(Enumerable<t> enum) -> Set<t>'
-  type :disjoint?, '(Set<t> set) -> %bool'
-#??  type :divide, '() { BLOCK }'
-  type :each, '() { (t) -> %any } -> self'
-  type :each, '() -> Enumerator<t>'
-  type :empty?, '() -> %bool'
-  type :flatten!, '() -> self or nil'
-  post(:flatten!) { |r| (not r) || (r.none? { |x| x.is_a?(Set) }) }
-  type :flatten, '() -> Set'
-  post(:flatten) { |r| r.none? { |x| x.is_a?(Set) } }
-  #  type :flatten_merge, '(set : XXXX, seen : ?XXXX)' #??
-  rdl_alias :include?, :member?
-  type :intersect?, '(Set<t> set) -> %bool'
-  type :intersection, '(Enumerable<t> enum) -> Set<t>'
-  type :keep_if, '() { (t) -> %bool } -> self'
-  rdl_alias :length, :size
-  type :map!, '() { (t) -> u } -> Set<u>' # !! Fix, actually changes type!
-  type :member?, '(t o) -> %bool'
-  type :merge, '(Enumerable<t> enum) -> self'
-  type :proper_subset?, '(Set<t> set) -> %bool'
-  type :proper_superset?, '(Set<t> set) -> %bool'
-  type :reject!, '() { (t) -> %bool } -> self or nil'
-  type :replace, '(Enumerable<u> enum) -> Set<u>' # !! Fix, actually changes type!
-  type :select!, '() { (t) -> %bool } -> self or nil'
-  type :size, '() -> Fixnum'
-  type :subset?, '(Set<t> set) -> %bool'
-  type :subtract, '(Enumerable<t> enum) -> self'
-  type :superset?, '(Set<t> set) -> %bool'
-  type :to_a, '() -> Array<t>'
-#  type :to_set, '(klass: ?Class, args : *XXXX) { BLOCK }' # ??
-  rdl_alias :|, :+
-  rdl_alias :union, :+
-end

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

@@ -1,143 +0,0 @@
-class String
-  rdl_nowrap
-
-  type :new, '(?String str) -> String new_str'
-  type :try_convert, '(Object obj) -> String or nil new_string'
-  type :%, '(Object) -> String'
-  type :*, '(Fixnum) -> String'
-  type :+, '(String) -> String'
-  type :<<, '(Object) -> String'
-  type :<=>, '(String other) -> Fixnum or nil ret'
-  type :==, '(%any) -> %bool'
-  type :===, '(%any) -> %bool'
-  type :=~, '(Object) -> Fixnum or nil', wrap: false # Wrapping this messes up $1 etc
-  type :[], '(Fixnum, ?Fixnum) -> String or nil'
-  type :[], '(Range<Fixnum> or Regexp) -> String or nil'
-  type :[], '(Regexp, Fixnum) -> String or nil'
-  type :[], '(Regexp, String) -> String or nil'
-  type :[], '(String) -> String or nil'
-  type :ascii_only?, '() -> %bool'
-  type :b, '() -> String'
-  type :bytes, '() -> Array' # TODO: bindings to parameterized (vars)
-  type :bytesize, '() -> Fixnum'
-  type :byteslice, '(Fixnum, ?Fixnum) -> String or nil'
-  type :byteslice, '(Range<Fixnum>) -> String or nil'
-  type :capitalize, '() -> String'
-  type :capitalize!, '() -> String or nil'
-  type :casecmp, '(String) -> nil or Fixnum'
-  type :center, '(Fixnum, ?String) -> String'
-  type :chars, '() -> Array'  #deprecated
-  type :chomp, '(?String) -> String'
-  type :chomp!, '(?String) -> String or nil'
-  type :chop, '() -> String'
-  type :chop!, '() -> String or nil'
-  type :chr, '() -> String'
-  type :clear, '() -> String'
-  type :codepoints, '() -> Array<Fixnum>' # TODO
-  type :codepoints, '() {(?%any) -> %any} -> Array<Fixnum>' # TODO
-  type :concat, '(Fixnum or Object) -> String'
-  type :count, '(String, *String) -> Fixnum'
-  type :crypt, '(String) -> String'
-  type :delete, '(String, *String) -> String'
-  type :delete!, '(String, *String) -> String or nil'
-  type :downcase, '() -> String'
-  type :downcase!, '() -> String or nil'
-  type :dump, '() -> String'
-  type :each_byte, '() {(Fixnum) -> %any} -> String'
-  type :each_byte, '() -> Enumerator'
-  type :each_char, '() {(String) -> %any} -> String'
-  type :each_char, '() -> Enumerator'
-  type :each_codepoint, '() {(Fixnum) -> %any} -> String'
-  type :each_codepoint, '() -> Enumerator'
-  type :each_line, '(?String) {(Fixnum) -> %any} -> String'
-  type :each_line, '(?String) -> Enumerator'
-  type :empty?, '() -> %bool'
-#  type :encode, '(?Encoding, ?Encoding, *Symbol) -> String' # TODO: fix Hash arg
-#  type :encode!, '(Encoding, ?Encoding, *Symbol) -> String'
-  type :encoding, '() -> Encoding'
-  type :end_with?, '(*String) -> %bool'
-  type :eql?, '(String) -> %bool'
-  type :force_encoding, '(String or Encoding) -> String'
-  type :getbyte, '(Fixnum) -> Fixnum or nil'
-  type :gsub, '(Regexp or String, String) -> String', wrap: false # Can't wrap these, since they mess with $1 etc
-  type :gsub, '(Regexp or String, Hash) -> String', wrap: false
-  type :gsub, '(Regexp or String) {(String) -> %any } -> String', wrap: false
-  type :gsub, '(Regexp or String) ->  Enumerator', wrap: false
-  type :gsub, '(Regexp or String) -> String', wrap: false
-  type :gsub!, '(Regexp or String, String) -> String or nil', wrap: false
-  type :gsub!, '(Regexp or String) {(String) -> %any } -> String or nil', wrap: false
-  type :gsub!, '(Regexp or String) -> Enumerator', wrap: false
-  type :hash, '() -> Fixnum'
-  type :hex, '() -> Fixnum'
-  type :include?, '(String) -> %bool'
-  type :index, '(Regexp or String, ?Fixnum) -> Fixnum or nil'
-  type :replace, '(String) -> String'
-  type :insert, '(Fixnum, String) -> String'
-  type :inspect, '() -> String'
-  type :intern, '() -> Symbol'
-  type :length, '() -> Fixnum'
-  type :lines, '(?String) -> Array<String>'
-  type :ljust, '(Fixnum, ?String) -> String' # TODO
-  type :lstrip, '() -> String'
-  type :lstrip!, '() -> String or nil'
-  type :match, '(Regexp or String) -> MatchData'
-  type :match, '(Regexp or String, Fixnum) -> MatchData'
-  type :next, '() -> String'
-  type :next!, '() -> String'
-  type :oct, '() -> Fixnum'
-  type :ord, '() -> Fixnum'
-  type :partition, '(Regexp or String) -> Array<String>'
-  type :prepend, '(String) -> String'
-  type :reverse, '() -> String'
-  type :rindex, '(String or Regexp, ?Fixnum) -> Fixnum or nil' # TODO
-  type :rjust, '(Fixnum, ?String) -> String' # TODO
-  type :rpartition, '(String or Regexp) -> Array<String>'
-  type :rstrip, '() -> String'
-  type :rstrip!, '() -> String'
-  type :scan, '(Regexp or String) -> Array<String or Array<String>>', wrap: false # Can't wrap or screws up last_match
-  type :scan, '(Regexp or String) {(*%any) -> %any} -> Array<String or Array<String>>', wrap: false
-  type :scrub, '(?String) -> String'
-  type :scrub, '(?String) {(%any) -> %any} -> String'
-  type :scrub!, '(?String) -> String'
-  type :scrub!, '(?String) {(%any) -> %any} -> String'
-  type :set_byte, '(Fixnum, Fixnum) -> Fixnum'
-  type :size, '() -> Fixnum'
-  rdl_alias :slice, :[]
-  type :slice!, '(Fixnum, ?Fixnum) -> String or nil'
-  type :slice!, '(Range<Fixnum> or Regexp) -> String or nil'
-  type :slice!, '(Regexp, Fixnum) -> String or nil'
-  type :slice!, '(Regexp, String) -> String or nil'
-  type :slice!, '(String) -> String or nil'
-  type :split, '(?(Regexp or String), ?Fixnum) -> Array<String>'
-  type :split, '(?Fixnum) -> Array<String>'
-  type :squeeze, '(?String) -> String'
-  type :squeeze!, '(?String) -> String'
-  type :start_with?, '(* String) -> %bool'
-  type :strip, '() -> String'
-  type :strip!, '() -> String'
-  type :sub, '(Regexp or String, String or Hash) -> String', wrap: false # Can't wrap these, since they mess with $1 etc
-  type :sub, '(Regexp or String) {(String) -> %any} -> String', wrap: false
-  type :sub!, '(Regexp or String, String) -> String', wrap: false # TODO: Does this really not allow Hash?
-  type :sub!, '(Regexp or String) {(String) -> %any} -> String', wrap: false
-  type :succ, '() -> String'
-  type :sum, '(?Fixnum) -> Fixnum'
-  type :swapcase, '() -> String'
-  type :swapcase!, '() -> String or nil'
-  type :to_c, '() -> Complex'
-  type :to_f, '() -> Float'
-  type :to_i, '(?Fixnum) -> Fixnum'
-  type :to_r, '() -> Rational'
-  type :to_s, '() -> String'
-  type :to_str, '() -> String'
-  type :to_sym, '() -> Symbol'
-  type :tr, '(String, String) -> String'
-  type :tr!, '(String, String) -> String or nil'
-  type :tr_s, '(String, String) -> String'
-  type :tr_s!, '(String, String) -> String or nil'
-  type :unpack, '(String) -> Array<String>'
-  type :upcase, '() -> String'
-  type :upcase!, '() -> String or nil'
-  type :upto, '(String, ?bool) -> Enumerator'
-  type :upto, '(String, ?bool) {(String) -> %any } -> String'
-  type :valid_encoding?, '() -> %bool'
-end