rdl 2.1.0 → 2.2.0

data/lib/types/core/basic_object.rb

@@ -1,9 +1,9 @@
 RDL.nowrap :BasicObject
 
-RDL.type :BasicObject, :==, '(%any other) -> %bool'
+RDL.type :BasicObject, :==, '(%any other) -> %bool', effect: [:+, :+]
 RDL.type :BasicObject, :equal?, '(%any other) -> %bool'
-RDL.type :BasicObject, :!, '() -> %bool'
-RDL.type :BasicObject, :!=, '(%any other) -> %bool'
+RDL.type :BasicObject, :!, '() -> %bool', effect: [:+, :+]
+RDL.type :BasicObject, :!=, '(%any other) -> %bool', effect: [:+, :+]
 RDL.type :BasicObject, :instance_eval, '(String, ?String filename, ?Integer lineno) -> %any'
 RDL.type :BasicObject, :instance_eval, '() { () -> %any } -> %any'
 RDL.type :BasicObject, :instance_exec, '(*%any args) { (*%any) -> %any } -> %any'

data/lib/types/core/bigdecimal.rb

@@ -1,5 +1,10 @@
 RDL.nowrap :BigDecimal
 
+class BigDecimal < Numeric; end ## Hacky way around existing issue.
+## The issue is any types that even reference BigDecimal, e.g., Integer#+ etc., will
+## call const_get on it, but without the above, the class is undefined.
+## May want to come up with more elegant solution in the future.
+
 RDL.type :BigDecimal, :%, '(%numeric) -> BigDecimal'
 RDL.pre(:BigDecimal, :%) { |x| x!=0&&(if x.is_a?(Float) then x!=Float::INFINITY && !x.nan? else true end)}
 

data/lib/types/core/class.rb

@@ -13,3 +13,5 @@ RDL.type :Class, :instance_methods, '(?%bool) -> Array<Symbol>'
 RDL.type :Class, :class, '() -> Class'
 RDL.type :Class, :superclass, '() -> Class'
 RDL.type :Class, :name, '() -> String'
+RDL.type :Class, :==, '(%any) -> %bool', effect: [:+, :+]
+RDL.type :Class, :===, '(%any) -> %bool', effect: [:+, :+]

data/lib/types/core/dir.rb

@@ -1,6 +1,6 @@
 RDL.nowrap :Dir
 
-RDL.rdl_alias :Dir, :[], :glob
+RDL.rdl_alias :Dir, :'self.[]', :'self.glob'
 
 RDL.type :Dir, 'self.chdir', '(?(String or Pathname)) -> 0'
 RDL.type :Dir, 'self.chdir', '(?(String or Pathname)) { (String) -> u } -> u'
@@ -12,8 +12,8 @@ RDL.type :Dir, 'self.exist?', '(String file) -> %bool'
 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.glob', '(String or Array<String> pattern, ?Fixnum flags) -> Array<String>'
+RDL.type :Dir, 'self.glob', '(String or Array<String> pattern, ?Fixnum 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'

data/lib/types/core/enumerable.rb

@@ -2,8 +2,8 @@ RDL.nowrap :Enumerable
 
 RDL.type_params :Enumerable, [:t], :all?
 
-RDL.type :Enumerable, :all?, '() -> %bool'
-RDL.type :Enumerable, :all?, '() { (t) -> %bool } -> %bool'
+RDL.type :Enumerable, :all?, '() -> %bool', effect: [:blockdep, :blockdep]
+RDL.type :Enumerable, :all?, '() { (t) -> %bool } -> %bool', effect: [:blockdep, :blockdep]
 RDL.type :Enumerable, :any?, '() -> %bool'
 RDL.type :Enumerable, :any?, '() { (t) -> %bool } -> %bool'
 # RDL.type :Enumerable, :chunk, '(XXXX : *XXXX)' # TODO
@@ -24,8 +24,8 @@ 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_index, '() { (t, Integer) -> %any } -> Enumerable<t>', effect: [:blockdep, :blockdep] # args! note may not return self
+RDL.type :Enumerable, :each_with_index, '() -> Enumerable<t>', effect: [:blockdep, :blockdep] # 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

data/lib/types/core/enumerator.rb

@@ -18,7 +18,7 @@ RDL.type :Enumerator, :next, '() -> t'
 RDL.type :Enumerator, :next_values, '() -> Array<t>'
 RDL.type :Enumerator, :peek, '() -> t'
 RDL.type :Enumerator, :peek_values, '() -> Array<t>'
-RDL.type :Enumerator, :rewrind, '() -> self'
+RDL.type :Enumerator, :rewind, '() -> self'
 RDL.type :Enumerator, :size, '() -> Integer or Float or nil'
 RDL.rdl_alias :Enumerator, :with_index, :each_with_index
 RDL.rdl_alias :Enumerator, :with_object, :each_with_object

data/lib/types/core/file.rb

@@ -23,7 +23,7 @@ RDL.type :File, 'self.expand_path', '(%path file, ?%path dir) -> String abs_file
 RDL.type :File, 'self.extname', '(String path) -> String'
 RDL.type :File, 'self.file?', '(String or IO file) -> %bool'
 RDL.type :File, 'self.fnmatch', '(String pattern, String path, ?Integer flags) -> %bool'
-RDL.rdl_alias :File, :fnmatch?, :fnmatch
+RDL.rdl_alias :File, :'self.fnmatch?', :'self.fnmatch'
 RDL.type :File, 'self.ftype', '(String file) -> String' # TODO: return in set of strings
 RDL.type :File, 'self.grpowned?', '(String or IO file) -> %bool'
 RDL.type :File, 'self.identical?', '(String or IO file_1, String or IO file_2) -> %bool'
@@ -41,7 +41,7 @@ RDL.type :File, 'self.pipe?', '(String file) -> %bool'
 RDL.type :File, 'self.readable?', '(String file) -> %bool'
 RDL.type :File, 'self.readable_real?', '(String file) -> %bool'
 RDL.type :File, 'self.readlink', '(String link) -> String file'
-RDL.type :File, 'self.readldirpath', '(String pathname, ?String dir) -> String real_pathname'
+RDL.type :File, 'self.realdirpath', '(String pathname, ?String dir) -> String real_pathname'
 RDL.type :File, 'self.realpath', '(String pathname, ?String dir) -> String real_pathname'
 RDL.type :File, 'self.rename', '(String old, String new) -> 0'
 RDL.type :File, 'self.setgid?', '(String file) -> %bool'
@@ -56,7 +56,7 @@ RDL.type :File, 'self.symlink', '(String old, String new) -> 0'
 RDL.type :File, 'self.symlink?', '(String file) -> %bool'
 RDL.type :File, 'self.truncate', '(String file, Integer) -> 0'
 RDL.type :File, 'self.umask', '(?Integer) -> Integer'
-RDL.rdl_alias :File, :unlink, :delete
+RDL.rdl_alias :File, :'self.unlink', :'self.delete'
 RDL.type :File, 'self.utime', '(Time atime, Time mtime, *String files) -> Integer'
 RDL.type :File, 'self.world_readable?', '(String or IO file) -> Integer or nil'
 RDL.type :File, 'self.world_writable?', '(String or IO file) -> Integer or nil'
@@ -105,7 +105,7 @@ RDL.type :'File::Stat', :mode, '() -> Integer'
 RDL.type :'File::Stat', :mtime, '() -> Time'
 RDL.type :'File::Stat', :nlink, '() -> Integer'
 RDL.type :'File::Stat', :owned?, '() -> %bool'
-RDL.type :'File::Stat', :pip?, '() -> %bool'
+RDL.type :'File::Stat', :pipe?, '() -> %bool'
 RDL.type :'File::Stat', :rdev, '() -> Integer or nil'
 RDL.type :'File::Stat', :rdev_major, '() -> Integer'
 RDL.type :'File::Stat', :rdev_minor, '() -> Integer'

data/lib/types/core/float.rb

@@ -1,5 +1,208 @@
 RDL.nowrap :Float
 
+RDL.type :Float, :%, '(Integer x {{ x != 0 }}) -> ``sing_or_type(trec, targs, :%, "Float")``'
+RDL.type :Float, :%, '(Float x {{ x != 0 }}) -> ``sing_or_type(trec, targs, :%, "Float")``'
+RDL.type :Float, :%, '(Rational x {{ x != 0 }}) -> ``sing_or_type(trec, targs, :%, "Float")``'
+RDL.type :Float, :%, '(BigDecimal x {{ x != 0 && !self.infinite? && !self.nan? }}) -> ``sing_or_type(trec, targs, :%, "BigDecimal")``'
+
+RDL.type :Float, :*, '(Integer) -> ``sing_or_type(trec, targs, :*, "Float")``'
+RDL.type :Float, :*, '(Float) -> ``sing_or_type(trec, targs, :*, "Float")``'
+RDL.type :Float, :*, '(Rational) -> ``sing_or_type(trec, targs, :*, "Float")``'
+RDL.type :Float, :*, '(BigDecimal x {{ !self.infinite? && !self.nan? }}) -> ``sing_or_type(trec, targs, :*, "BigDecimal")``'
+RDL.type :Float, :*, '(Complex) -> ``sing_or_type(trec, targs, :*, "Complex")``'
+RDL.pre(:Float, :*) { |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) && self!=Float::INFINITY && !(self.nan?) else true end} #can't have a complex with part BigDecimal, other part infinity/NAN
+
+RDL.type :Float, :**, '(Integer) -> ``sing_or_type(trec, targs, :**, "Float")``'
+RDL.type :Float, :**, '(Float) -> ``sing_or_type(trec, targs, :**, "%numeric")``'
+RDL.type :Float, :**, '(Rational) -> ``sing_or_type(trec, targs, :**, "%numeric")``'
+RDL.type :Float, :**, '(BigDecimal) -> ``sing_or_type(trec, targs, :**, "BigDecimal")``'
+RDL.pre(:Float, :**) { |x| x!=BigDecimal::INFINITY && if self<0 then x<=-1||x>=0 else true end}
+RDL.post(:Float, :**) { |x| x.real?}
+RDL.type :Float, :**, '(Complex) -> ``sing_or_type(trec, targs, :**, "Complex")``'
+RDL.pre(:Float, :**) { |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) && self!=Float::INFINITY && !(self.nan?) else true end}
+
+RDL.type :Float, :+, '(Integer) -> ``sing_or_type(trec, targs, :+, "Float")``'
+RDL.type :Float, :+, '(Float) -> ``sing_or_type(trec, targs, :+, "Float")``'
+RDL.type :Float, :+, '(Rational) -> ``sing_or_type(trec, targs, :+, "Float")``'
+RDL.type :Float, :+, '(BigDecimal x {{ !self.infinite? && !self.nan? }}) -> ``sing_or_type(trec, targs, :+, "BigDecimal")``'
+RDL.type :Float, :+, '(Complex) -> ``sing_or_type(trec, targs, :+, "Complex")``'
+RDL.pre(:Float, :+) { |x| if x.real.is_a?(BigDecimal) then self!=Float::INFINITY && !(self.nan?) else true end}
+
+RDL.type :Float, :-, '(Integer) -> ``sing_or_type(trec, targs, :-, "Float")``'
+RDL.type :Float, :-, '(Float) -> ``sing_or_type(trec, targs, :-, "Float")``'
+RDL.type :Float, :-, '(Rational) -> ``sing_or_type(trec, targs, :-, "Float")``'
+RDL.type :Float, :-, '(BigDecimal x {{ !self.infinite? && !self.nan? }}) -> ``sing_or_type(trec, targs, :-, "BigDecimal")``'
+RDL.type :Float, :-, '(Complex) -> ``sing_or_type(trec, targs, :-, "Complex")``'
+RDL.pre(:Float, :-) { |x| if x.real.is_a?(BigDecimal) then self!=Float::INFINITY && !(self.nan?) else true end}
+
+RDL.type :Float, :-@, '() -> ``sing_or_type(trec, targs, :-@, "Float")``'
+
+RDL.type :Float, :+@, '() -> ``sing_or_type(trec, targs, :+@, "Float")``'
+
+RDL.type :Float, :/, '(Integer x {{ x != 0 }}) -> ``sing_or_type(trec, targs, :/, "Float")``'
+RDL.type :Float, :/, '(Float x {{ x != 0 }}) -> ``sing_or_type(trec, targs, :/, "Float")``'
+RDL.type :Float, :/, '(Rational x {{ x != 0 }}) -> ``sing_or_type(trec, targs, :/, "Float")``'
+RDL.type :Float, :/, '(BigDecimal x {{ x != 0 && !self.infinite? && !self.nan? }}) -> ``sing_or_type(trec, targs, :/, "BigDecimal")``'
+RDL.type :Float, :/, '(Complex x {{ x != 0 }}) -> ``sing_or_type(trec, targs, :/, "Complex")``'
+RDL.pre(:Float, :/) { |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) && self!=Float::INFINITY && !(self.nan?) else true end && if (x.real.is_a?(Rational) && x.imaginary.is_a?(Float)) then !x.imaginary.nan? else true end}
+
+RDL.type :Float, :<, '(Integer) -> ``sing_or_type(trec, targs, :<, "%bool")``'
+RDL.type :Float, :<, '(Float) -> ``sing_or_type(trec, targs, :<, "%bool")``'
+RDL.type :Float, :<, '(Rational) -> ``sing_or_type(trec, targs, :<, "%bool")``'
+RDL.type :Float, :<, '(BigDecimal x {{ !self.nan? && !self.infinite? }}) -> ``sing_or_type(trec, targs, :<, "%bool")``'
+
+RDL.type :Float, :<=, '(Integer) -> ``sing_or_type(trec, targs, :<=, "%bool")``'
+RDL.type :Float, :<=, '(Float) -> ``sing_or_type(trec, targs, :<=, "%bool")``'
+RDL.type :Float, :<=, '(Rational) -> ``sing_or_type(trec, targs, :<=, "%bool")``'
+RDL.type :Float, :<=, '(BigDecimal x {{ !self.nan? && !self.infinite? }}) -> ``sing_or_type(trec, targs, :<=, "%bool")``'
+
+RDL.type :Float, :<=>, '(Integer) -> ``sing_or_type(trec, targs, :<=>, "Integer")``'
+RDL.post(:Float, :<=>) { |x| x == -1 || x==0 || x==1}
+RDL.type :Float, :<=>, '(Float) -> ``sing_or_type(trec, targs, :<=>, "Integer")``'
+RDL.post(:Float, :<=>) { |x| x == -1 || x==0 || x==1}
+RDL.type :Float, :<=>, '(Rational) -> ``sing_or_type(trec, targs, :<=>, "Integer")``'
+RDL.post(:Float, :<=>) { |x| x == -1 || x==0 || x==1}
+RDL.type :Float, :<=>, '(BigDecimal x {{ !self.infinite? && !self.nan? }}) -> ``sing_or_type(trec, targs, :<=>, "Integer")``'
+RDL.post(:Float, :<=>) { |x| x == -1 || x==0 || x==1}
+
+RDL.type :Float, :==, '(Object) -> ``sing_or_type(trec, targs, :==, "%bool")``'
+RDL.pre(:Float, :==) { |x| if (x.is_a?(BigDecimal)) then (!self.nan? && self!=Float::INFINITY) else true end}
+
+RDL.type :Float, :===, '(Object) -> ``sing_or_type(trec, targs, :===, "%bool")``'
+RDL.pre(:Float, :===) { |x| if (x.is_a?(BigDecimal)) then (!self.nan? && self!=Float::INFINITY) else true end}
+
+RDL.type :Float, :>, '(Integer) -> ``sing_or_type(trec, targs, :>, "%bool")``'
+RDL.type :Float, :>, '(Float) -> ``sing_or_type(trec, targs, :>, "%bool")``'
+RDL.type :Float, :>, '(Rational) -> ``sing_or_type(trec, targs, :>, "%bool")``'
+RDL.type :Float, :>, '(BigDecimal x {{ !self.infinite? && !self.nan? }}) -> ``sing_or_type(trec, targs, :>, "%bool")``'
+
+RDL.type :Float, :>=, '(Integer) -> ``sing_or_type(trec, targs, :>=, "%bool")``'
+RDL.type :Float, :>=, '(Float) -> ``sing_or_type(trec, targs, :>=, "%bool")``'
+RDL.type :Float, :>=, '(Rational) -> ``sing_or_type(trec, targs, :>=, "%bool")``'
+RDL.type :Float, :>=, '(BigDecimal x {{ !self.infinite? && !self.nan? }}) -> ``sing_or_type(trec, targs, :>=, "%bool")``'
+
+RDL.type :Float, :abs, '() -> Float r {{ r>=0 || (if self.nan? then r.nan? end) }}' ## TODO
+
+RDL.type :Float, :abs2, '() -> Float r {{ r>=0 || (if self.nan? then r.nan? end) }}' ## TODO
+
+RDL.type :Float, :div, '(Integer x {{ x != 0 && !self.infinite? && !self.nan? }}) -> ``sing_or_type(trec, targs, :div, "Integer")``'
+RDL.type :Float, :div, '(Float x {{ x != 0 && !self.infinite? && !self.nan? }}) -> ``sing_or_type(trec, targs, :div, "Integer")``'
+RDL.type :Float, :div, '(Rational x {{ x != 0 && !self.infinite? && !self.nan? }}) -> ``sing_or_type(trec, targs, :div, "Integer")``'
+RDL.type :Float, :div, '(BigDecimal x {{ x != 0 && !x.nan? && !self.infinite? && !self.nan? }}) -> ``sing_or_type(trec, targs, :div, "Integer")``'
+
+RDL.type :Float, :divmod, '(%real) -> [%real, %real]'
+RDL.pre(:Float, :divmod) { |x| x != 0 && if x.is_a?(Float) then !x.nan? else true end && self!=Float::INFINITY && !self.nan?}
+
+RDL.type :Float, :angle, '() -> ``sing_or_type(trec, targs, :angle, "%numeric")``'
+RDL.post(:Float, :angle) { |r,x| r == 0 || r == Math::PI || r == Float::NAN}
+
+RDL.type :Float, :arg, '() -> ``sing_or_type(trec, targs, :rg, "%numeric")``'
+RDL.post(:Float, :arg) { |r,x| r == 0 || r == Math::PI || r == Float::NAN}
+
+RDL.type :Float, :ceil, '() -> ``sing_or_type(trec, targs, :ceil, "Integer")``'
+RDL.pre(:Float, :ceil) { !self.infinite? && !self.nan?}
+
+RDL.type :Float, :coerce, '(%real) -> [Float, Float]'
+
+RDL.type :Float, :denominator, '() -> Integer r {{ r>0 }}' ## TODO
+
+RDL.type :Float, :equal?, '(Object) -> ``sing_or_type(trec, targs, :equal?, "%bool")``'
+
+RDL.type :Float, :eql?, '(Object) -> ``sing_or_type(trec, targs, :eql?, "%bool")``'
+
+RDL.type :Float, :fdiv, '(Integer) -> ``sing_or_type(trec, targs, :fdiv, "Float")``'
+RDL.type :Float, :fdiv, '(Float) -> ``sing_or_type(trec, targs, :fdiv, "Float")``'
+RDL.type :Float, :fdiv, '(Rational) -> ``sing_or_type(trec, targs, :fdiv, "Float")``'
+RDL.type :Float, :fdiv, '(BigDecimal x {{ !self.infinite? && !self.nan? }}) -> ``sing_or_type(trec, targs, :fdiv, "BigDecimal")``'
+RDL.type :Float, :fdiv, '(Complex) -> ``sing_or_type(trec, targs, :fdiv, "Complex")``'
+RDL.pre(:Float, :fdiv) { |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) && self!=Float::INFINITY && !(self.nan?) else true end && if (x.real.is_a?(Rational) && x.imaginary.is_a?(Float)) then !x.imaginary.nan? else true end}
+
+RDL.type :Float, :finite?, '() -> ``sing_or_type(trec, targs, :finite?, "%bool")``'
+
+RDL.type :Float, :floor, '() -> ``sing_or_type(trec, targs, :floor, "Integer")``'
+RDL.pre(:Float, :ceil) { !self.infinite? && !self.nan?}
+
+RDL.type :Float, :hash, '() -> Integer'
+
+RDL.type :Float, :infinite?, '() -> ``sing_or_type(trec, targs, :infinite?, "Integer")``'
+RDL.post(:Float, :infinite?) { |r,x| r == -1 || r == 1 || r == nil }
+
+RDL.type :Float, :to_s, '() -> String'
+RDL.type :Float, :inspect, '() -> String'
+
+RDL.type :Float, :magnitude, '() -> ``sing_or_type(trec, targs, :magnitude, "Float")``'
+RDL.post(:Float, :magnitude) { |r,x| r>=0 }
+
+RDL.type :Float, :modulo, '(Integer x {{ x != 0 }}) -> ``sing_or_type(trec, targs, :modulo, "Float")``'
+RDL.type :Float, :modulo, '(Float x {{ x != 0 }}) -> ``sing_or_type(trec, targs, :modulo, "Float")``'
+RDL.type :Float, :modulo, '(Rational x {{ x != 0 }}) -> ``sing_or_type(trec, targs, :modulo, "Float")``'
+RDL.type :Float, :modulo, '(BigDecimal x {{ x != 0 && !self.infinite? && !self.nan? }}) -> ``sing_or_type(trec, targs, :modulo, "BigDecimal")``'
+
+RDL.type :Float, :nan?, '() -> ``sing_or_type(trec, targs, :nan?, "%bool")``'
+
+RDL.type :Float, :next_float, '() -> ``sing_or_type(trec, targs, :next_float, "Float")``'
+
+RDL.type :Float, :numerator, '() -> ``sing_or_type(trec, targs, :numerator, "Integer")``'
+
+RDL.type :Float, :phase, '() -> ``sing_or_type(trec, targs, :phase, "%numeric")``'
+RDL.post(:Float, :phase) { |r,x| r == 0 || r == Math::PI || r == Float::NAN}
+
+RDL.type :Float, :prev_float, '() -> ``sing_or_type(trec, targs, :prev_float, "Float")``'
+
+RDL.type :Float, :quo, '(Integer x {{ x != 0 }}) -> ``sing_or_type(trec, targs, :quo, "Float")``'
+RDL.type :Float, :quo, '(Float x {{ x != 0 }}) -> ``sing_or_type(trec, targs, :quo, "Float")``'
+RDL.type :Float, :quo, '(Rational x {{ x != 0 }}) -> ``sing_or_type(trec, targs, :quo, "Float")``'
+RDL.type :Float, :quo, '(BigDecimal x {{ x != 0 && !self.infinite? && !self.nan? }}) -> ``sing_or_type(trec, targs, :quo, "BigDecimal")``'
+RDL.type :Float, :quo, '(Complex x {{ x != 0 }}) -> ``sing_or_type(trec, targs, :quo, "Complex")``'
+RDL.pre(:Float, :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) && self!=Float::INFINITY && !(self.nan?) else true end && if (x.real.is_a?(Rational) && x.imaginary.is_a?(Float)) then !x.imaginary.nan? else true end}
+
+RDL.type :Float, :rationalize, '() -> ``sing_or_type(trec, targs, :rationalize, "Rational")``'
+RDL.pre(:Float, :rationalize) { !self.infinite? && !self.nan?}
+
+RDL.type :Float, :rationalize, '(%numeric) -> ``sing_or_type(trec, targs, :rationalize, "Rational")``'
+RDL.pre(:Float, :rationalize) { |x| if x.is_a?(Float) then x!=Float::INFINITY && !x.nan? else true end}
+
+RDL.type :Float, :round, '() -> ``sing_or_type(trec, targs, :round, "Integer")``'
+RDL.pre(:Float, :round) { !self.infinite? && !self.nan?}
+
+RDL.type :Float, :round, '(%numeric) -> ``sing_or_type(trec, targs, :round, "%numeric")``'
+RDL.pre(:Float, :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].
+
+RDL.type :Float, :to_f, '() -> self'
+
+RDL.type :Float, :to_i, '() -> ``sing_or_type(trec, targs, :to_i, "Integer")``'
+RDL.pre(:Float, :to_i) { !self.infinite? && !self.nan?}
+
+RDL.type :Float, :to_int, '() -> ``sing_or_type(trec, targs, :to_int, "Integer")``'
+RDL.pre(:Float, :to_int) { !self.infinite? && !self.nan?}
+
+RDL.type :Float, :to_r, '() -> ``sing_or_type(trec, targs, :to_r, "Rational")``'
+RDL.pre(:Float, :to_r) { !self.infinite? && !self.nan?}
+
+RDL.type :Float, :truncate, '() -> ``sing_or_type(trec, targs, :truncate, "Integer")``'
+
+RDL.type :Float, :zero?, '() -> ``sing_or_type(trec, targs, :zero, "%bool")``'
+
+RDL.type :Float, :conj, '() -> ``sing_or_type(trec, targs, :conj, "Float")``'
+RDL.type :Float, :conjugate, '() -> ``sing_or_type(trec, targs, :conjugate, "Float")``'
+
+RDL.type :Float, :imag, '() -> Integer r {{ r==0 }}' ## TODO 
+RDL.type :Float, :imaginary, '() -> Integer r {{ r==0 }}'  ## TODO
+
+RDL.type :Float, :real, '() -> ``sing_or_type(trec, targs, :real, "Float")``'
+
+RDL.type :Float, :real?, '() -> ``sing_or_type(trec, targs, :real?, "%bool")``'
+
+RDL.type :Float, :to_c, '() -> Complex r {{ r.imaginary == 0 }}' ## TODO
+
+RDL.type :Float, :coerce, '(%numeric) -> [Float, Float]'
+RDL.pre(:Float, :coerce) { |x| if x.is_a?(Complex) then x.imaginary==0 else true end}
+
+
+
+######### Non-dependent types below #########
+
+
 RDL.type :Float, :%, '(Integer x {{ x != 0 }}) -> Float'
 RDL.type :Float, :%, '(Float x {{ x != 0 }}) -> Float'
 RDL.type :Float, :%, '(Rational x {{ x != 0 }}) -> Float'

data/lib/types/core/hash.rb

@@ -2,14 +2,386 @@ RDL.nowrap :Hash
 
 RDL.type_params :Hash, [:k, :v], :all?
 
-RDL.type :Hash, 'self.[]', '(*u) -> Hash<u, u>'  # example: Hash[1,2,3,4]
-RDL.type :Hash, 'self.[]', '(Array<[a,b]>) -> Hash<a, b>'
-RDL.type :Hash, 'self.[]', '([to_hash: () -> Hash<a, b>]) -> Hash<a, b>'
+def Hash.output_type(trec, targs, meth_name, default1, default2=default1, nil_default: false, use_sing_val: true)
+  case trec
+  when RDL::Type::FiniteHashType    
+    if targs.empty? || targs.all? { |t| t.is_a?(RDL::Type::SingletonType) }
+      vals = RDL.type_cast((if use_sing_val then targs.map { |t| RDL.type_cast(t, "RDL::Type::SingletonType").val } else targs end), "Array<%any>", force: true)
+      res = RDL.type_cast(trec.elts.send(meth_name, *vals), "Object", force: true)
+      if nil_default && res.nil?
+        if default1 == :promoted_val
+          return trec.promote.params[1]
+        elsif default1 == :promoted_key
+          return trec.promote.params[0]
+        else
+          return RDL::Globals.parser.scan_str "#T #{default1}"
+        end
+      end
+      to_type(res)
+    else
+      if default1 == :promoted_val
+        x = trec.promote.params[1]
+        return x
+      elsif default1 == :promoted_key
+        return trec.promote.params[0]
+      else
+        RDL::Globals.parser.scan_str "#T #{default1}"
+      end
+    end
+  else
+    RDL::Globals.parser.scan_str "#T #{default2}"
+  end
+end
+RDL.type Hash, 'self.output_type', "(RDL::Type::Type, Array<RDL::Type::Type>, Symbol, Symbol or String, ?(Symbol or String), { nil_default: ?%bool, use_sing_val: ?%bool } ) -> RDL::Type::Type", typecheck: :type_code, wrap: false, effect: [:+, :+]
+
+
+def Hash.to_type(t)
+  case t
+  when RDL::Type::Type
+    t
+  when Array
+    RDL::Type::TupleType.new(*(t.map { |i| to_type(i) }))
+  else
+    ## symbols, ints, nil, ...
+    RDL::Type::SingletonType.new(t)
+  end
+end
+RDL.type Hash, 'self.to_type', "(%any) -> RDL::Type::Type", typecheck: :type_code, wrap: false, effect: [:+, :+]
+
+def Hash.any_or_k(trec)
+  case trec
+  when RDL::Type::FiniteHashType
+    RDL::Globals.types[:top]
+  else
+    RDL::Globals.parser.scan_str "#T k"
+  end
+end
+RDL.type Hash, 'self.any_or_k', "(RDL::Type::Type) -> RDL::Type::Type", typecheck: :type_code, wrap: false, effect: [:+, :+]
+
+def Hash.any_or_v(trec)
+  case trec
+  when RDL::Type::FiniteHashType
+    RDL::Globals.types[:top]
+  else
+    RDL::Globals.parser.scan_str "#T v"
+  end
+end
+RDL.type Hash, 'self.any_or_v', "(RDL::Type::Type) -> RDL::Type::Type", typecheck: :type_code, wrap: false, effect: [:+, :+]
+
+def Hash.promoted_or_v(trec)
+  case trec
+  when RDL::Type::FiniteHashType
+    trec.promote.params[1]
+  else
+    RDL::Globals.parser.scan_str "#T v"
+  end
+end
+RDL.type Hash, 'self.promoted_or_v', "(RDL::Type::Type) -> RDL::Type::Type", typecheck: :type_code, wrap: false, effect: [:+, :+]
+
+
+def Hash.weak_promote(val)
+  case val
+  when RDL::Type::UnionType
+    if val.types.all? { |t| t.is_a?(RDL::Type::SingletonType) }
+      klass = RDL.type_cast(val.types[0], "RDL::Type::SingletonType", force: true).nominal.klass
+      if val.types.all? { |t| RDL.type_cast(t, "RDL::Type::SingletonType", force: true).nominal.klass == klass }
+        return RDL::Type::NominalType.new(klass)
+      else
+        return val
+      end
+    else
+      return val
+    end
+  else
+    val
+  end
+end
+RDL.type Hash, 'self.weak_promote', "(RDL::Type::Type) -> RDL::Type::Type", typecheck: :type_code, wrap: false, effect: [:+, :+]
+
+#RDL.type :Hash, 'self.[]', '(*%any) -> ``hash_create_output_from_list(targs)``'
+RDL.type :Hash, 'self.[]', '(*%any) -> ``hash_create_output(targs)``'
+
+def Hash.hash_create_output_from_list(targs)
+  raise RDL::Typecheck::StaticTypeError, "Hash[...] expect only 1 argument. Have #{targs}." if targs.size > 1
+  raise RDL::Typecheck::StaticTypeError, "The argument has to be an array or tuple" unless (targs[0].is_a?(RDL::Type::GenericType) && targs[0].base.klass == Array)
+
+  case targs[0].params[0]
+  when RDL::Type::GenericType
+    return RDL::Globals.parser.scan_str "#T Hash<#{targs[0].params[0].params[0]}, #{targs[0].params[0].params[0]}>"
+  when RDL::Type::TupleType
+    return RDL::Type::GenericType.new(RDL::Type::NominalType.new(Hash), targs[0].params[0].params[0], targs[0].params[0].params[1])
+  end
+end
+
+def Hash.hash_create_output(targs)
+  return hash_create_output_from_list(targs) if targs.size == 1
+
+  raise RDL::Typecheck::StaticTypeError, "Hash.[] expects an even number of arguments. Have #{targs}." if targs.size.odd?
+  args = RDL.type_cast([], "Array<%any>", force: true)
+  i = -1
+  args = targs.map { |a| i = i+1 ; if i.even? && a.is_a?(RDL::Type::SingletonType) then RDL.type_cast(a, "RDL::Type::SingletonType", force: true).val else a end }
+  RDL::Type::FiniteHashType.new(RDL.type_cast(Hash[*args], "Hash<%any, RDL::Type::Type>", force: true), nil)
+end
+RDL.type Hash, 'self.hash_create_output', "(Array<RDL::Type::Type>) -> RDL::Type::Type", typecheck: :type_code, wrap: false, effect: [:+, :+]
+
+RDL.type :Hash, :[], '(``any_or_k(trec)``) -> ``output_type(trec, targs, :[], :promoted_val, "v", nil_default: true)``', effect: [:+, :+]
+
+RDL.type :Hash, :[]=, '(``any_or_k(trec)``, ``any_or_v(trec)``) -> ``assign_output(trec, targs)``'
+
+
+def Hash.assign_output(trec, targs)
+  case trec
+  when RDL::Type::FiniteHashType
+    case targs[0]
+    when RDL::Type::SingletonType ### TODO: adjust for strings
+      argval = RDL.type_cast(targs[0], "RDL::Type::SingletonType", force: true).val
+      trec.elts[argval] = RDL::Type::UnionType.new(trec.elts[argval], targs[1]).canonical
+      trec.elts[argval] = weak_promote(trec.elts[argval]) if RDL::Config.instance.weak_update_promote
+      raise RDL::Typecheck::StaticTypeError, "Failed to mutate hash: new hash does not match prior type constraints." unless trec.check_bounds(true)
+      return targs[1]
+    else
+      raise "Unable to promote tuple #{trec} to Hash." unless trec.promote!(targs[0], targs[1])
+      return targs[1]
+    end
+  else
+    RDL::Globals.parser.scan_str "#T v"
+  end
+end
+RDL.type Hash, 'self.assign_output', "(RDL::Type::Type, Array<RDL::Type::Type>) -> RDL::Type::Type", typecheck: :type_code, wrap: false, effect: [:~, :+]
+
+RDL.type :Hash, :store, '(``any_or_k(trec)``, ``any_or_v(trec)``) -> ``assign_output(trec, targs)``'
+RDL.type :Hash, :assoc, '(``any_or_k(trec)``) -> ``RDL::Type::TupleType.new(targs[0], output_type(trec, targs, :[], :promoted_val, "v", nil_default: true))``'
+RDL.type :Hash, :clear, '() -> self'  
+RDL.type :Hash, :compare_by_identity, '() -> self'
+RDL.type :Hash, :compare_by_identity?,  '() -> %bool'
+RDL.type :Hash, :default, '() -> ``promoted_or_v(trec)``'
+RDL.type :Hash, :default, '(``any_or_k(trec)``) -> ``promoted_or_v(trec)``'
+RDL.type :Hash, :default=, '(``promoted_or_v(trec)``) -> ``promoted_or_v(trec)``'
+
+RDL.type :Hash, :delete, '(``any_or_k(trec)``) -> ``delete_output(trec, targs, false)``'
+RDL.type :Hash, :delete, '(``any_or_k(trec)``) { (``any_or_k(trec)``) -> u } -> ``delete_output(trec, targs, true)``'
+
+def Hash.delete_output(trec, targs, block)
+  case trec
+  when RDL::Type::FiniteHashType
+    case targs[0]
+    when RDL::Type::SingletonType
+      argval = RDL.type_cast(targs[0], "RDL::Type::SingletonType", force: true).val
+      if trec.elts.include?(argval)
+        trec.elts[argval]
+      else
+        trec.promote.params[1]
+      end
+    else
+      if block
+        RDL::Type::UnionType.new(trec.promote.params[1], RDL::Globals.parser.scan_str("#T u"))
+      else
+        trec.promote.params[1]
+      end
+    end
+  else
+    t = (if block then "u or v" else "v" end)
+    RDL::Globals.parser.scan_str "#T #{t}"
+  end
+end
+RDL.type Hash, 'self.delete_output', "(RDL::Type::Type, Array<RDL::Type::Type>, %bool) -> RDL::Type::Type", typecheck: :type_code, wrap: false, effect: [:+, :+]
+
+RDL.type :Hash, :delete_if, '() { (``any_or_k(trec)``, ``any_or_v(trec)``) -> %any } -> self'
+RDL.type :Hash, :delete_if, '() -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), RDL::Type::TupleType.new(any_or_k(trec), any_or_v(trec)))``' ## I had made a mistake here, type checker caught it.
+RDL.type :Hash, :each, '() { (``any_or_k(trec)``, ``any_or_v(trec)``) -> %any } -> self'
+RDL.type :Hash, :each, '() -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), RDL::Type::TupleType.new(any_or_k(trec), any_or_v(trec)))``' ## I had made a mistake here, type checker caught it.
+RDL.type :Hash, :each_pair, '() { (``any_or_k(trec)``, ``any_or_v(trec)``) -> %any } -> self'
+RDL.type :Hash, :each_pair, '() -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), RDL::Type::TupleType.new(any_or_k(trec), any_or_v(trec)))``' ## I had made a mistake here, type checker caught it.
+RDL.type :Hash, :each_key, '() { (``any_or_k(trec)``) -> %any } -> self'
+RDL.type :Hash, :each_key, '() -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), any_or_k(trec))``'
+RDL.type :Hash, :each_value, '() { (``any_or_v(trec)``) -> %any } -> self'
+RDL.type :Hash, :each_value, '() -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), any_or_v(trec))``'
+RDL.type :Hash, :empty?, '() -> ``output_type(trec, targs, :empty?, "%bool")``'
+RDL.type :Hash, :fetch, '(``any_or_k(trec)``) -> ``output_type(trec, targs, :fetch, :promoted_val, "v", nil_default: true)``'
+RDL.type :Hash, :fetch, '(``any_or_k(trec)``, u) -> ``RDL::Type::UnionType.new(RDL::Globals.parser.scan_str("u"), output_type(trec, targs, :fetch, :promoted_val, "v", nil_default: true))``'
+RDL.type :Hash, :fetch, '(``any_or_k(trec)``) { (``any_or_k(trec)``) -> u } -> ``RDL::Type::UnionType.new(RDL::Globals.parser.scan_str("u"), output_type(trec, targs, :fetch, :promoted_val, "v", nil_default: true))``'
+RDL.type :Hash, :member?, '(%any) -> ``output_type(trec, targs, :member?, "%bool")``'
+RDL.type :Hash, :has_key?, '(%any) -> ``output_type(trec, targs, :has_key?, "%bool")``', effect: [:+, :+]
+RDL.type :Hash, :key?, '(%any) -> ``output_type(trec, targs, :key?, "%bool")``'
+RDL.type :Hash, :has_value?, '(%any) -> ``output_type(trec, targs, :has_value?, "%bool")``'
+RDL.type :Hash, :value?, '(%any) -> ``output_type(trec, targs, :value?, "%bool")``'
+RDL.type :Hash, :to_s, '() -> String'
+RDL.type :Hash, :inspect, '() -> String'
+RDL.type :Hash, :invert, '() -> ``invert_output(trec)``'
+
+
+def Hash.invert_output(trec)
+  case trec
+  when RDL::Type::FiniteHashType
+    hash = trec.elts.invert
+    hash = Hash[hash.map { |k, v| if !RDL.type_cast(v, "Object", force: true).is_a?(RDL::Type::Type) then [k, RDL::Type::SingletonType.new(v)] else [k, v] end }]
+    RDL::Type::FiniteHashType.new(RDL.type_cast(hash, "Hash<%any, RDL::Type::Type>", force: true), nil)
+  else
+    RDL::Globals.parser.scan_str "#T Hash<v, k>"
+  end
+end
+RDL.type Hash, 'self.invert_output', "(RDL::Type::Type) -> RDL::Type::Type", typecheck: :type_code, wrap: false, effect: [:+, :+]
+
+RDL.type :Hash, :keep_if, '() { (``any_or_k(trec)``,``any_or_v(trec)``) -> %bool } -> self'
+RDL.type :Hash, :keep_if, '() -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), RDL::Type::TupleType.new(any_or_k(trec), any_or_v(trec)))``' ## I had made a mistake here, type checker caught it.
+RDL.type :Hash, :key, '(%any) -> ``output_type(trec, targs, :key, :promoted_key, "k", nil_default: true, use_sing_val: false)``'
+RDL.type :Hash, :keys, '() -> ``output_type(trec, targs, :keys, "Array<k>")``'
+RDL.type :Hash, :length, '() -> ``output_type(trec, targs, :length, "Integer")``'
+RDL.type :Hash, :size, '() -> ``output_type(trec, targs, :size, "Integer")``'
+RDL.type :Hash, :merge, '(``merge_input(targs)``) -> ``merge_output(trec, targs)``'
+RDL.type :Hash, :merge!, '(``merge_input(targs, true)``) -> ``merge_output(trec, targs, true)``'
+
+
+def Hash.merge_input(targs, mutate=false)
+  case targs[0]
+  when RDL::Type::FiniteHashType
+    return targs[0]
+  when RDL::Type::GenericType
+    if mutate
+      return RDL::Globals.parser.scan_str "#T Hash<k, v>"
+    else
+      return RDL::Globals.parser.scan_str "#T Hash<a, b>"
+    end
+  else
+    RDL::Globals.types[:hash]
+  end
+end
+RDL.type Hash, 'self.merge_input', "(Array<RDL::Type::Type>, ?%bool) -> RDL::Type::Type", typecheck: :type_code, wrap: false, effect: [:+, :+]
+
+
+def Hash.merge_output(trec, targs, mutate=false)
+  case trec
+  when RDL::Type::NominalType
+    return RDL::Globals.types[:hash]
+  when RDL::Type::GenericType
+    case targs[0]
+    when RDL::Type::FiniteHashType
+      promoted = RDL.type_cast(targs[0], "RDL::Type::FiniteHashType", force: true).promote
+      key_union = RDL::Type::UnionType.new(promoted.params[0], trec.params[0]).canonical
+      value_union = RDL::Type::UnionType.new(promoted.params[1], trec.params[1]).canonical
+      if mutate
+        raise "Call to `merge!` would change type of Hash." unless (key_union == trec.params[0]) && (value_union == trec.params[1])
+        return trec
+      else
+        return RDL::Type::GenericType.new(trec.base, key_union, value_union)
+      end
+    when RDL::Type::GenericType
+      ret = (if mutate then "Hash<k, v>" else "Hash<a or k, b or v>" end)
+      return RDL::Globals.parser.scan_str "#T #{ret}"
+    else
+      ## targs[0] should just be hash here
+      return RDL::Globals.types[:hash]
+    end
+  when RDL::Type::FiniteHashType
+    case targs[0]
+    when RDL::Type::FiniteHashType
+      arg = RDL.type_cast(targs[0], "RDL::Type::FiniteHashType", force: true)
+      if mutate
+        if arg.elts.any? { |k, v| !RDL.type_cast(k, "Object", force: true).is_a?(Symbol) }
+          arg_key = arg.promote.params[0]
+          arg_val = arg.promote.params[1]
+          raise "Unable to promote tuple #{trec} to Hash." unless trec.promote!(arg_key, arg_val)
+          return trec
+        end
+        trec.elts = RDL.type_cast(Hash[trec.elts.map { |k, v| if arg.elts.has_key?(k) then [k, RDL::Type::UnionType.new(arg.elts[k], v).canonical] else [k, v] end } ].merge(arg.elts), "Hash<%any, RDL::Type::Type>", force: true)
+        raise RDL::Typecheck::StaticTypeError, "Failed to mutate hash: new hash does not match prior type constraints." unless trec.check_bounds(true)
+        return trec
+      else
+        return RDL::Type::FiniteHashType.new(trec.elts.merge(arg.elts), nil)
+      end
+    when RDL::Type::GenericType
+      arg0 = RDL.type_cast(targs[0], "RDL::Type::GenericType", force: true)
+      promoted = trec.promote
+      key_union = RDL::Type::UnionType.new(promoted.params[0], arg0.params[0]).canonical
+      value_union = RDL::Type::UnionType.new(promoted.params[1], arg0.params[1]).canonical
+      if mutate
+        raise "Unable to promote tuple #{trec} to Hash." unless trec.promote!(arg0.params[0], arg0.params[1])
+        return trec        
+      else
+        return RDL::Type::GenericType.new(arg0.base, key_union, value_union)
+      end
+    else
+      ## targs[0] should just be Hash here
+      return RDL::Globals.types[:hash]
+    end
+  end
+
+end
+RDL.type Hash, 'self.merge_output', "(RDL::Type::Type, Array<RDL::Type::Type>, ?%bool) -> RDL::Type::Type", typecheck: :type_code, wrap: false, effect: [:~, :+]
+
+RDL.type :Hash, :merge, '(Hash<a,b>) { (k,v,b) -> v or b } -> Hash<a or k, b or v>'
+RDL.type :Hash, :rassoc, '(``any_or_v(trec)``) -> ``RDL::Type::TupleType.new(output_type(trec, targs, :key, :promoted_key, "k", nil_default: true, use_sing_val: false),targs[0])``'
+RDL.type :Hash, :rehash, '() -> self'
+RDL.type :Hash, :reject, '() -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), any_or_k(trec), any_or_v(trec))``'
+RDL.type :Hash, :reject, '() {(``any_or_k(trec)``,``any_or_v(trec)``) -> %bool} -> self'
+RDL.type :Hash, :reject!, '() {(``any_or_k(trec)``,``any_or_v(trec)``) -> %bool} -> self'
+RDL.type :Hash, :select, '() {(``any_or_k(trec)``,``any_or_v(trec)``) -> %bool} -> self'
+RDL.type :Hash, :select!, '() {(``any_or_k(trec)``,``any_or_v(trec)``) -> %bool} -> self'
+RDL.type :Hash, :shift, '() -> ``shift_output(trec)``'
+
+
+def Hash.shift_output(trec)
+  case trec
+  when RDL::Type::FiniteHashType
+    promoted = trec.promote
+    RDL::Type::TupleType.new(*promoted.params) ## Type error found by type checker here.
+  else
+    RDL::Globals.parser.scan_str "#T [k, v]"
+  end
+end
+RDL.type Hash, 'self.shift_output', "(RDL::Type::Type) -> RDL::Type::Type", typecheck: :type_code, wrap: false, effect: [:+, :+]
+
+RDL.type :Hash, :to_a, '() -> ``output_type(trec, targs, :to_a, "Array<[k, v]>")``'
+RDL.type :Hash, :to_hash, '() -> self'
+RDL.type :Hash, :values, '() -> ``output_type(trec, targs, :values, "Array<v>")``'
+RDL.type :Hash, :values_at, '(``values_at_input(trec)``) -> ``values_at_output(trec, targs)``'
+
+
+def Hash.values_at_input(trec)
+  case trec
+  when RDL::Type::FiniteHashType
+    RDL::Type::VarargType.new(RDL::Globals.types[:top])
+  else
+    RDL::Type::VarargType.new(RDL::Type::VarType.new("k"))
+  end
+end
+RDL.type Hash, 'self.values_at_input', "(RDL::Type::Type) -> RDL::Type::Type", typecheck: :type_code, wrap: false, effect: [:~, :+]
+
+
+def Hash.values_at_output(trec, targs)
+  case trec
+  when RDL::Type::FiniteHashType
+    if targs.all? { |t| t.is_a? RDL::Type::SingletonType }
+      res = trec.elts.values_at(*targs.map { |t| RDL.type_cast(t, "RDL::Type::SingletonType<%any>", force: true).val })
+      if res.all? { |t| !t.nil? }
+        to_type(res)
+      else
+        RDL::Type::GenericType.new(RDL::Type::NominalType.new(Array), trec.promote.params[1])
+      end
+    else
+      RDL::Type::GenericType.new(RDL::Type::NominalType.new(Array), trec.promote.params[1])
+    end
+  else
+    RDL::Globals.parser.scan_str "#T Array<v>"
+  end
+end
+RDL.type Hash, 'self.values_at_output', "(RDL::Type::Type, Array<RDL::Type::Type>) -> RDL::Type::Type", typecheck: :type_code, wrap: false, effect: [:~, :+]
+
+
+
+
+
+######### Non-dependent types below #########
+
+RDL.type :Hash, 'self.[]', '(*u) -> Hash<u, u>', effect: [:+, :+]  # example: Hash[1,2,3,4]
+RDL.type :Hash, 'self.[]', '(Array<[a,b]>) -> Hash<a, b>', effect: [:+, :+]
+RDL.type :Hash, 'self.[]', '([to_hash: () -> Hash<a, b>]) -> Hash<a, b>', effect: [:+, :+]
 
 RDL.type :Hash, :[], '(k) -> v'
-RDL.type :Hash, :[]=, '(k, v) -> v'
+RDL.type :Hash, :[]=, '(k, v) -> v', effect: [:-, :+]
 RDL.type :Hash, :store, '(k,v) -> v'
 
+RDL.type :Hash, :any?, "() { (k, v) -> %any } -> %bool", effect: [:blockdep, :blockdep]
 # RDL.type :Hash, :assoc, '(k) -> [k, v]' # TODO
 RDL.type :Hash, :assoc, '(k) -> Array<k or v>'
 RDL.type :Hash, :clear, '() -> Hash<k,v>'
@@ -27,41 +399,44 @@ RDL.type :Hash, :delete, '(k) -> v'
 RDL.type :Hash, :delete, '(k) { (k) -> u } -> u or v'
 RDL.type :Hash, :delete_if, '() { (k,v) -> %bool } -> Hash<k,v>'
 RDL.type :Hash, :delete_if, '() -> Enumerator<[k, v]>'
-RDL.type :Hash, :each, '() { (k,v) -> %any } -> Hash<k,v>'
-RDL.type :Hash, :each, '() -> Enumerator<[k, v]>'
+RDL.type :Hash, :each, '() { (k,v) -> %any } -> Hash<k,v>', effect: [:blockdep, :blockdep]
+RDL.type :Hash, :each, '() -> Enumerator<[k, v]>', effect: [:blockdep, :blockdep]
 RDL.type :Hash, :each_pair, '() { (k,v) -> %any } -> Hash<k,v>'
 RDL.type :Hash, :each_pair, '() -> Enumerator<[k, v]>'
-RDL.type :Hash, :each_key, '() { (k) -> %any } -> Hash<k,v>'
-RDL.type :Hash, :each_key, '() -> Enumerator<[k, v]>'
+RDL.type :Hash, :each_key, '() { (k) -> %any } -> Hash<k,v>', effect: [:blockdep, :blockdep]
+RDL.type :Hash, :each_key, '() -> Enumerator<[k, v]>', effect: [:blockdep, :blockdep]
 RDL.type :Hash, :each_value, '() { (v) -> %any } -> Hash<k,v>'
 RDL.type :Hash, :each_value, '() -> Enumerator<[k, v]>'
 RDL.type :Hash, :empty?, '() -> %bool'
+RDL.type :Hash, :except, '(%any) -> self', effect: [:+, :+]
 RDL.type :Hash, :fetch, '(k) -> v'
 RDL.type :Hash, :fetch, '(k,u) -> u or v'
 RDL.type :Hash, :fetch, '(k) { (k) -> u } -> u or v'
+RDL.type :Hash, :map, "() { (k, v) -> x } -> Array<x>", effect: [:+, :blockdep]
 RDL.type :Hash, :member?, '(t) -> %bool'
 RDL.type :Hash, :has_key?, '(t) -> %bool'
 RDL.type :Hash, :key?, '(t) -> %bool'
 RDL.type :Hash, :has_value?, '(t) -> %bool'
 RDL.type :Hash, :value?, '(t) -> %bool'
 RDL.type :Hash, :to_s, '() -> String'
+RDL.type :Hash, :include?, '(%any) -> %bool', effect: [:+, :+]
 RDL.type :Hash, :inspect, '() -> String'
-RDL.type :Hash, :invert, '() -> Hash<v,k>'
+RDL.type :Hash, :invert, '() -> Hash<v,k>', effect: [:+, :+]
 RDL.type :Hash, :keep_if, '() { (k,v) -> %bool } -> Hash<k,v>'
 RDL.type :Hash, :keep_if, '() -> Enumerator<[k, v]>'
 RDL.type :Hash, :key, '(t) -> k'
-RDL.type :Hash, :keys, '() -> Array<k>'
+RDL.type :Hash, :keys, '() -> Array<k>', effect: [:+, :+]
 RDL.type :Hash, :length, '() -> Integer'
-RDL.type :Hash, :size, '() -> Integer'
-RDL.type :Hash, :merge, '(Hash<a,b>) -> Hash<a or k, b or v>'
-RDL.type :Hash, :merge, '(Hash<a,b>) { (k,v,b) -> v or b } -> Hash<a or k, b or v>'
+RDL.type :Hash, :size, '() -> Integer', effect: [:+, :+]
+RDL.type :Hash, :merge, '(Hash<a,b>) -> Hash<a or k, b or v>', effect: [:+, :+]
+RDL.type :Hash, :merge, '(Hash<a,b>) { (k,v,b) -> v or b } -> Hash<a or k, b or v>', effect: [:+, :+]
 # RDL.type :Hash, :rassoc, '(k) -> Tuple<k,v>'
 RDL.type :Hash, :rassoc, '(k) -> Array<k or v>'
 RDL.type :Hash, :rehash, '() -> Hash<k,v>'
 RDL.type :Hash, :reject, '() -> Enumerator<[k, v]>'
 RDL.type :Hash, :reject, '() {(k,v) -> %bool} -> Hash<k,v>'
 RDL.type :Hash, :reject!, '() {(k,v) -> %bool} -> Hash<k,v>'
-RDL.type :Hash, :select, '() {(k,v) -> %bool} -> Hash<k,v>'
+RDL.type :Hash, :select, '() {(k,v) -> %bool} -> Hash<k,v>', effect: [:+, :blockdep]
 RDL.type :Hash, :select!, '() {(k,v) -> %bool} -> Hash<k,v>'
 # RDL.type :Hash, :shift, '() -> Tuple<k,v>'
 RDL.type :Hash, :shift, '() -> Array<k or v>'
@@ -69,4 +444,4 @@ RDL.type :Hash, :shift, '() -> Array<k or v>'
 RDL.type :Hash, :to_a, '() -> Array<Array<k or v>>'
 RDL.type :Hash, :to_hash, '() -> Hash<k,v>'
 RDL.type :Hash, :values, '() -> Array<v>'
-RDL.type :Hash, :values_at, '(*k) -> Array<v>'
+RDL.type :Hash, :values_at, '(*k) -> Array<v>', effect: [:+, :+]