rdl 2.1.0 → 2.2.0
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +5 -5
- data/.gitignore +1 -0
- data/.travis.yml +7 -6
- data/CHANGES.md +29 -0
- data/README.md +94 -26
- data/lib/rdl/boot.rb +82 -41
- data/lib/rdl/boot_rails.rb +5 -0
- data/lib/rdl/config.rb +9 -1
- data/lib/rdl/query.rb +2 -2
- data/lib/rdl/typecheck.rb +972 -225
- data/lib/rdl/types/annotated_arg.rb +8 -0
- data/lib/rdl/types/ast_node.rb +73 -0
- data/lib/rdl/types/bot.rb +8 -0
- data/lib/rdl/types/bound_arg.rb +63 -0
- data/lib/rdl/types/computed.rb +48 -0
- data/lib/rdl/types/dependent_arg.rb +9 -0
- data/lib/rdl/types/dynamic.rb +61 -0
- data/lib/rdl/types/finite_hash.rb +54 -9
- data/lib/rdl/types/generic.rb +33 -0
- data/lib/rdl/types/intersection.rb +8 -0
- data/lib/rdl/types/lexer.rex +6 -1
- data/lib/rdl/types/lexer.rex.rb +13 -1
- data/lib/rdl/types/method.rb +14 -0
- data/lib/rdl/types/nominal.rb +8 -0
- data/lib/rdl/types/non_null.rb +8 -0
- data/lib/rdl/types/optional.rb +8 -0
- data/lib/rdl/types/parser.racc +31 -5
- data/lib/rdl/types/parser.tab.rb +540 -302
- data/lib/rdl/types/rdl_types.rb +45 -0
- data/lib/rdl/types/singleton.rb +14 -1
- data/lib/rdl/types/string.rb +104 -0
- data/lib/rdl/types/structural.rb +8 -0
- data/lib/rdl/types/top.rb +8 -0
- data/lib/rdl/types/tuple.rb +32 -8
- data/lib/rdl/types/type.rb +54 -11
- data/lib/rdl/types/union.rb +41 -2
- data/lib/rdl/types/var.rb +10 -0
- data/lib/rdl/types/vararg.rb +8 -0
- data/lib/rdl/util.rb +13 -10
- data/lib/rdl/wrap.rb +271 -27
- data/lib/rdl_disable.rb +16 -2
- data/lib/types/active_record.rb +1 -0
- data/lib/types/core/array.rb +442 -23
- data/lib/types/core/basic_object.rb +3 -3
- data/lib/types/core/bigdecimal.rb +5 -0
- data/lib/types/core/class.rb +2 -0
- data/lib/types/core/dir.rb +3 -3
- data/lib/types/core/enumerable.rb +4 -4
- data/lib/types/core/enumerator.rb +1 -1
- data/lib/types/core/file.rb +4 -4
- data/lib/types/core/float.rb +203 -0
- data/lib/types/core/hash.rb +390 -15
- data/lib/types/core/integer.rb +223 -10
- data/lib/types/core/io.rb +2 -2
- data/lib/types/core/kernel.rb +8 -5
- data/lib/types/core/marshal.rb +3 -0
- data/lib/types/core/module.rb +3 -3
- data/lib/types/core/numeric.rb +0 -2
- data/lib/types/core/object.rb +5 -5
- data/lib/types/core/pathname.rb +2 -2
- data/lib/types/core/process.rb +1 -3
- data/lib/types/core/range.rb +1 -1
- data/lib/types/core/regexp.rb +2 -2
- data/lib/types/core/set.rb +1 -1
- data/lib/types/core/string.rb +408 -16
- data/lib/types/core/symbol.rb +3 -3
- data/lib/types/core/time.rb +1 -1
- data/lib/types/core/uri.rb +13 -13
- data/lib/types/rails/_helpers.rb +7 -1
- data/lib/types/rails/action_controller/mime_responds.rb +2 -0
- data/lib/types/rails/active_record/associations.rb +42 -30
- data/lib/types/rails/active_record/comp_types.rb +637 -0
- data/lib/types/rails/active_record/finder_methods.rb +1 -1
- data/lib/types/rails/active_record/model_schema.rb +28 -16
- data/lib/types/rails/active_record/relation.rb +5 -3
- data/lib/types/rails/active_record/sql-strings.rb +166 -0
- data/lib/types/rails/string.rb +1 -1
- data/lib/types/sequel.rb +1 -0
- data/lib/types/sequel/comp_types.rb +581 -0
- data/rdl.gemspec +5 -4
- data/test/test_alias.rb +4 -0
- data/test/test_array_types.rb +244 -0
- data/test/test_bound_types.rb +80 -0
- data/test/test_contract.rb +4 -0
- data/test/test_dsl.rb +5 -0
- data/test/test_dyn_comptype_checks.rb +206 -0
- data/test/test_generic.rb +21 -20
- data/test/test_hash_types.rb +322 -0
- data/test/test_intersection.rb +1 -0
- data/test/test_le.rb +29 -4
- data/test/test_member.rb +3 -1
- data/test/test_parser.rb +5 -0
- data/test/test_query.rb +1 -0
- data/test/test_rdl.rb +63 -28
- data/test/test_rdl_type.rb +4 -0
- data/test/test_string_types.rb +102 -0
- data/test/test_type_contract.rb +59 -37
- data/test/test_typecheck.rb +480 -75
- data/test/test_types.rb +17 -0
- data/test/test_wrap.rb +5 -0
- metadata +35 -5
- data/lib/types/rails/active_record/schema_types.rb +0 -51
data/lib/rdl_disable.rb
CHANGED
@@ -29,6 +29,20 @@ module RDL::Annotate
|
|
29
29
|
def type_params(*args); end
|
30
30
|
end
|
31
31
|
|
32
|
+
module RDL::RDLAnnotate
|
33
|
+
define_method :rdl_pre, RDL::Annotate.instance_method(:pre)
|
34
|
+
define_method :rdl_post, RDL::Annotate.instance_method(:post)
|
35
|
+
define_method :rdl_type, RDL::Annotate.instance_method(:type)
|
36
|
+
define_method :rdl_var_type, RDL::Annotate.instance_method(:var_type)
|
37
|
+
define_method :rdl_alias, RDL::Annotate.instance_method(:rdl_alias)
|
38
|
+
define_method :rdl_type_params, RDL::Annotate.instance_method(:type_params)
|
39
|
+
define_method :rdl_attr_accessor_type, RDL::Annotate.instance_method(:attr_accessor_type) # note in disable these don't call var_type
|
40
|
+
define_method :rdl_attr_reader_type, RDL::Annotate.instance_method(:attr_reader_type)
|
41
|
+
define_method :rdl_attr_type, RDL::Annotate.instance_method(:attr_type)
|
42
|
+
define_method :rdl_attr_writer_type, RDL::Annotate.instance_method(:attr_writer_type)
|
43
|
+
end
|
44
|
+
|
45
|
+
|
32
46
|
module RDL
|
33
47
|
extend RDL::Annotate
|
34
48
|
def self.type_alias(*args); end
|
@@ -37,8 +51,8 @@ module RDL
|
|
37
51
|
def self.at(*args); end
|
38
52
|
def self.note_type(*args); end
|
39
53
|
def self.remove_type(*args); end
|
40
|
-
def self.
|
41
|
-
def self.
|
54
|
+
def self.instantiate!(*args); self; end
|
55
|
+
def self.deinstantiate!(*args); self; end
|
42
56
|
def self.type_cast(*args); self; end
|
43
57
|
def self.query(*args); end
|
44
58
|
end
|
@@ -0,0 +1 @@
|
|
1
|
+
Dir[File.dirname(__FILE__) + "/rails/active_record/*.rb"].each { |f| require f }
|
data/lib/types/core/array.rb
CHANGED
@@ -2,31 +2,452 @@ RDL.nowrap :Array
|
|
2
2
|
|
3
3
|
RDL.type_params :Array, [:t], :all?
|
4
4
|
|
5
|
-
|
6
|
-
|
7
|
-
RDL
|
8
|
-
|
5
|
+
def Array.to_type(t)
|
6
|
+
case t
|
7
|
+
when RDL::Type::Type
|
8
|
+
t
|
9
|
+
when Array
|
10
|
+
RDL.type_cast(RDL::Type::TupleType.new(*(t.map { |i| to_type(RDL.type_cast(i, "Object")) })), "RDL::Type::TupleType", force: true)
|
11
|
+
else
|
12
|
+
t = "nil" if t.nil?
|
13
|
+
RDL::Globals.parser.scan_str "#T #{t}"
|
14
|
+
end
|
15
|
+
end
|
16
|
+
RDL.type Array, 'self.to_type', "(Object) -> RDL::Type::Type", wrap: false, typecheck: :type_code, effect: [:+, :+]
|
17
|
+
|
18
|
+
|
19
|
+
def Array.output_type(trec, targs, meth_name, default1, default2=default1, use_sing_val: true, nil_false_default: false)
|
20
|
+
case trec
|
21
|
+
when RDL::Type::TupleType
|
22
|
+
if targs.empty? || targs.all? { |t| t.is_a?(RDL::Type::SingletonType) }
|
23
|
+
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)
|
24
|
+
res = RDL.type_cast(trec.params.send(meth_name, *vals), "Object", force: true)
|
25
|
+
if !res && nil_false_default
|
26
|
+
if default1 == :promoted_param
|
27
|
+
trec.promote.params[0]
|
28
|
+
elsif default1 == :promoted_array
|
29
|
+
trec.promote
|
30
|
+
else
|
31
|
+
RDL::Globals.parser.scan_str "#T #{default1}"
|
32
|
+
end
|
33
|
+
else
|
34
|
+
to_type(res)
|
35
|
+
end
|
36
|
+
else
|
37
|
+
if default1 == :promoted_param
|
38
|
+
trec.promote.params[0]
|
39
|
+
elsif default1 == :promoted_array
|
40
|
+
trec.promote
|
41
|
+
else
|
42
|
+
RDL::Globals.parser.scan_str "#T #{default1}"
|
43
|
+
end
|
44
|
+
end
|
45
|
+
else
|
46
|
+
RDL::Globals.parser.scan_str "#T #{default2}"
|
47
|
+
end
|
48
|
+
end
|
49
|
+
RDL.type Array, 'self.output_type', "(RDL::Type::Type, Array<RDL::Type::Type>, Symbol, String or Symbol, ?(String or Symbol), { use_sing_val: ?%bool, nil_false_default: ?%bool }) -> RDL::Type::Type", wrap: false, typecheck: :type_code, effect: [:+, :+]
|
50
|
+
|
51
|
+
|
52
|
+
def Array.any_or_t(trec, vararg=false)
|
53
|
+
case trec
|
54
|
+
when RDL::Type::TupleType
|
55
|
+
ret = RDL::Globals.types[:top]
|
56
|
+
if vararg then RDL::Type::VarargType.new(ret) else ret end
|
57
|
+
else
|
58
|
+
ret = RDL::Globals.parser.scan_str "#T t"
|
59
|
+
if vararg then RDL::Type::VarargType.new(ret) else ret end
|
60
|
+
end
|
61
|
+
end
|
62
|
+
RDL.type Array, 'self.any_or_t', "(RDL::Type::Type, ?%bool) -> RDL::Type::Type", wrap: false, typecheck: :type_code, effect: [:+, :+]
|
63
|
+
|
64
|
+
|
65
|
+
def Array.promoted_or_t(trec, vararg=false)
|
66
|
+
case trec
|
67
|
+
when RDL::Type::TupleType
|
68
|
+
ret = trec.promote.params[0]
|
69
|
+
if vararg then RDL::Type::VarargType.new(ret) else ret end
|
70
|
+
else
|
71
|
+
ret = RDL::Globals.parser.scan_str "#T t"
|
72
|
+
if vararg then RDL::Type::VarargType.new(ret) else ret end
|
73
|
+
end
|
74
|
+
end
|
75
|
+
RDL.type Array, 'self.promoted_or_t', "(RDL::Type::Type, ?%bool) -> RDL::Type::Type", wrap: false, typecheck: :type_code, effect: [:+, :+]
|
76
|
+
|
77
|
+
|
78
|
+
def Array.promote_tuple(trec)
|
79
|
+
case trec
|
80
|
+
when RDL::Type::TupleType
|
81
|
+
trec.promote
|
82
|
+
else
|
83
|
+
trec
|
84
|
+
end
|
85
|
+
end
|
86
|
+
RDL.type Array, 'self.promote_tuple', "(RDL::Type::Type) -> RDL::Type::Type", wrap: false, typecheck: :type_code, effect: [:+, :+]
|
87
|
+
|
88
|
+
|
89
|
+
def Array.promote_tuple!(trec)
|
90
|
+
case trec
|
91
|
+
when RDL::Type::TupleType
|
92
|
+
raise "Unable to promote tuple." unless trec.promote!
|
93
|
+
trec
|
94
|
+
else
|
95
|
+
trec
|
96
|
+
end
|
97
|
+
end
|
98
|
+
RDL.type Array, 'self.promote_tuple!', "(RDL::Type::Type) -> RDL::Type::Type", wrap: false, typecheck: :type_code, effect: [:~, :+]
|
99
|
+
|
100
|
+
RDL.type :Array, :<<, '(``any_or_t(trec)``) -> ``append_push_output(trec, targs, :<<)``'
|
101
|
+
|
102
|
+
|
103
|
+
def Array.append_push_output(trec, targs, meth)
|
104
|
+
case trec
|
105
|
+
when RDL::Type::TupleType
|
106
|
+
RDL.type_cast(trec.params.send(meth, *RDL.type_cast(targs, "Array<%any>")), "%any", force: true)
|
107
|
+
raise RDL::Typecheck::StaticTypeError, "Failed to mutate tuple: new tuple does not match prior type constraints." unless trec.check_bounds(true)
|
108
|
+
trec
|
109
|
+
else
|
110
|
+
RDL::Globals.parser.scan_str "#T Array<t>"
|
111
|
+
end
|
112
|
+
end
|
113
|
+
RDL.type Array, 'self.append_push_output', "(RDL::Type::Type, Array<RDL::Type::Type>, Symbol) -> RDL::Type::Type", typecheck: :type_code, wrap: false, effect: [:~, :+]
|
114
|
+
|
115
|
+
RDL.type :Array, :[], '(Range<Integer>) -> ``output_type(trec, targs, :[], :promoted_array, "Array<t>")``'
|
116
|
+
RDL.type :Array, :[], '(Integer or Float) -> ``output_type(trec, targs, :[], :promoted_param, "t")``'
|
117
|
+
RDL.type :Array, :[], '(Integer, Integer) -> ``output_type(trec, targs, :[], :promoted_array, "Array<t>")``'
|
118
|
+
RDL.type :Array, :&, '(Array<u>) -> ``output_type(trec, targs, :&, :promoted_array, "Array<t>")``'
|
119
|
+
RDL.type :Array, :*, '(Integer) -> ``output_type(trec, targs, :*, :promoted_array, "Array<t>")``'
|
120
|
+
RDL.type :Array, :*, '(String) -> String'
|
121
|
+
RDL.type :Array, :+, '(``plus_input(targs)``) -> ``plus_output(trec, targs)``'
|
122
|
+
|
123
|
+
|
124
|
+
def Array.plus_input(targs)
|
125
|
+
case targs[0]
|
126
|
+
when RDL::Type::TupleType
|
127
|
+
return targs[0]
|
128
|
+
when RDL::Type::GenericType
|
129
|
+
return RDL::Globals.parser.scan_str "#T Array<u>"
|
130
|
+
else
|
131
|
+
RDL::Globals.types[:array]
|
132
|
+
end
|
133
|
+
end
|
134
|
+
RDL.type Array, 'self.plus_input', "(Array<RDL::Type::Type>) -> RDL::Type::Type", typecheck: :type_code, wrap: false, effect: [:+, :+]
|
135
|
+
|
136
|
+
|
137
|
+
def Array.plus_output(trec, targs)
|
138
|
+
case trec
|
139
|
+
when RDL::Type::NominalType
|
140
|
+
return RDL::Globals.types[:array]
|
141
|
+
when RDL::Type::GenericType
|
142
|
+
case targs[0]
|
143
|
+
when RDL::Type::TupleType
|
144
|
+
promoted = RDL.type_cast(targs[0], "RDL::Type::TupleType", force: true).promote
|
145
|
+
param_union = RDL::Type::UnionType.new(promoted.params[0], trec.params[0])
|
146
|
+
return RDL::Type::GenericType.new(trec.base, param_union)
|
147
|
+
when RDL::Type::GenericType
|
148
|
+
return RDL::Globals.parser.scan_str "#T Array<u or t>"
|
149
|
+
else
|
150
|
+
## targs[0] should just be array here
|
151
|
+
return RDL::Globals.types[:array]
|
152
|
+
end
|
153
|
+
when RDL::Type::TupleType
|
154
|
+
case targs[0]
|
155
|
+
when RDL::Type::TupleType
|
156
|
+
return RDL::Type::TupleType.new(*(trec.params + RDL.type_cast(targs[0], "RDL::Type::TupleType", force: true).params))
|
157
|
+
when RDL::Type::GenericType
|
158
|
+
promoted = trec.promote
|
159
|
+
param_union = RDL::Type::UnionType.new(promoted.params[0], RDL.type_cast(targs[0], "RDL::Type::GenericType", force: true).params[0] )
|
160
|
+
return RDL::Type::GenericType.new(RDL.type_cast(targs[0], "RDL::Type::GenericType", force: true).base, param_union)
|
161
|
+
else
|
162
|
+
## targs[0] should just be Array here
|
163
|
+
return RDL::Globals.types[:array]
|
164
|
+
end
|
165
|
+
end
|
166
|
+
end
|
167
|
+
RDL.type Array, 'self.plus_output', "(RDL::Type::Type, Array<RDL::Type::Type>) -> RDL::Type::Type", typecheck: :type_code, wrap: false, effect: [:+, :+]
|
168
|
+
|
169
|
+
RDL.type :Array, :-, '(Array<u>) -> ``output_type(trec, targs, :-, :promoted_array, "Array<t>")``'
|
170
|
+
RDL.type :Array, :slice, '(Range<Integer>) -> ``output_type(trec, targs, :slice, :promoted_array, "Array<t>")``'
|
171
|
+
RDL.type :Array, :slice, '(Integer) -> ``output_type(trec, targs, :slice, :promoted_param, "t")``'
|
172
|
+
RDL.type :Array, :slice, '(Integer, Integer) -> ``output_type(trec, targs, :slice, :promoted_array, "Array<t>")``'
|
173
|
+
RDL.type :Array, :[]=, '(Integer, ``any_or_t(trec)``) -> ``assign_output(trec, targs)``'
|
174
|
+
|
175
|
+
|
176
|
+
def Array.assign_output(trec, targs)
|
177
|
+
case trec
|
178
|
+
when RDL::Type::TupleType
|
179
|
+
case targs[0]
|
180
|
+
when RDL::Type::SingletonType
|
181
|
+
argval = RDL.type_cast(targs[0], "RDL::Type::SingletonType<Integer>", force: true).val
|
182
|
+
if v = trec.params[argval]
|
183
|
+
trec.params[argval] = RDL::Type::UnionType.new(v, targs[1])
|
184
|
+
trec.params[argval] = Hash.weak_promote(trec.params[argval]) if RDL::Config.instance.weak_update_promote
|
185
|
+
raise RDL::Typecheck::StaticTypeError, "Failed to mutate tuple: new tuple does not match previous constraints." unless trec.check_bounds(true)
|
186
|
+
targs[1]
|
187
|
+
else
|
188
|
+
trec.params[RDL.type_cast(targs[0], "RDL::Type::SingletonType<Integer>", force: true).val] = targs[1]
|
189
|
+
raise RDL::Typecheck::StaticTypeError, "Failed to mutate tuple: new tuple does not match previous constraints." unless trec.check_bounds(true)
|
190
|
+
targs[1]
|
191
|
+
end
|
192
|
+
else
|
193
|
+
raise "Unable to promote tuple." unless trec.promote!(targs[1])
|
194
|
+
trec
|
195
|
+
end
|
196
|
+
else
|
197
|
+
RDL::Globals.parser.scan_str "#T t"
|
198
|
+
end
|
199
|
+
end
|
200
|
+
RDL.type Array, 'self.assign_output', "(RDL::Type::Type, Array<RDL::Type::Type>) -> RDL::Type::Type", typecheck: :type_code, wrap: false, effect: [:~, :+]
|
201
|
+
|
202
|
+
RDL.type :Array, :[]=, '(Integer, Integer, ``any_or_t(trec)``) -> t'
|
203
|
+
|
204
|
+
|
205
|
+
def Array.multi_assign_output(trec, targs)
|
206
|
+
## this method could get more precise, but it would require many more cases
|
207
|
+
return RDL::Globals.types[:top] ### TODO: Figure out better solution. This is here to avoid promote!-ing when type does not actually match.
|
208
|
+
=begin
|
209
|
+
## uncomment after figuring out above.
|
210
|
+
case trec
|
211
|
+
when RDL::Type::TupleType
|
212
|
+
element = (if targs.length > 2 then targs[2] else targs[1] end)
|
213
|
+
raise "Unable to promote tuple." unless trec.promote!(element)
|
214
|
+
element
|
215
|
+
else
|
216
|
+
RDL::Globals.parser.scan_str "#T t"
|
217
|
+
end
|
218
|
+
=end
|
219
|
+
end
|
220
|
+
RDL.type Array, 'self.multi_assign_output', "(RDL::Type::Type, Array<RDL::Type::Type>) -> RDL::Type::Type", typecheck: :type_code, wrap: false, effect: [:~, :+]
|
221
|
+
|
222
|
+
RDL.type :Array, :[]=, '(Range<Integer>, ``any_or_t(trec)``) -> ``multi_assign_output(trec, targs)``'
|
223
|
+
RDL.type :Array, :assoc, '(t) -> Array<t>'
|
224
|
+
RDL.type :Array, :at, '(Integer) -> ``output_type(trec, targs, :at, :promoted_param, "t")``'
|
225
|
+
RDL.type :Array, :clear, '() -> self'
|
226
|
+
RDL.type :Array, :map, '() {(``promoted_or_t(trec)``) -> u } -> Array<u>'
|
227
|
+
RDL.type :Array, :map, '() -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), promoted_or_t(trec))``'
|
228
|
+
RDL.type :Array, :map!, '() {(``promoted_or_t(trec)``) -> u} -> ``map_output(trec)``'
|
229
|
+
|
230
|
+
|
231
|
+
def Array.map_output(trec)
|
232
|
+
case trec
|
233
|
+
when RDL::Type::TupleType
|
234
|
+
trec.params.map! { |e| RDL::Globals.parser.scan_str "#T u" } ## set each element to type u
|
235
|
+
raise RDL::Typecheck::StaticTypeError, "Failed to mutate tuple: new tuple does not match previous constraints." unless trec.check_bounds(true)
|
236
|
+
trec
|
237
|
+
else
|
238
|
+
RDL::Globals.parser.scan_str "#T Array<u>"
|
239
|
+
end
|
240
|
+
end
|
241
|
+
RDL.type Array, 'self.map_output', "(RDL::Type::Type) -> RDL::Type::Type", typecheck: :type_code, wrap: false, effect: [:~, :+]
|
242
|
+
|
243
|
+
RDL.type :Array, :map!, '() -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), promoted_or_t(trec))``'
|
244
|
+
RDL.type :Array, :collect, '() {(``promoted_or_t(trec)``) -> u} -> Array<u>'
|
245
|
+
RDL.type :Array, :collect, '() -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), promoted_or_t(trec))``'
|
246
|
+
RDL.type :Array, :combination, '(Integer) { (self) -> %any } -> self'
|
247
|
+
RDL.type :Array, :combination, '(Integer) -> Enumerator<self>'
|
248
|
+
RDL.type :Array, :push, '(``any_or_t(trec, true)``) -> ``append_push_output(trec, targs, :push)``'
|
249
|
+
RDL.type ::Array, :compact, '() -> ``RDL::Type::GenericType.new(RDL::Globals.types[:array], promoted_or_t(trec))``'
|
250
|
+
RDL.type :Array, :compact!, '() -> ``promote_tuple!(trec)``'
|
251
|
+
RDL.type :Array, :concat, '(``promote_tuple(trec)``) -> ``promote_tuple!(trec)``' ## could be more precise here
|
252
|
+
RDL.type :Array, :count, '() -> ``output_type(trec, targs, :count, "Integer")``'
|
253
|
+
RDL.type :Array, :count, '(``any_or_t(trec)``) -> Integer'
|
254
|
+
RDL.type :Array, :count, '() { (``promoted_or_t(trec)``) -> %bool } -> Integer'
|
255
|
+
RDL.type :Array, :cycle, '(?Integer) { (``promoted_or_t(trec)``) -> %any } -> %any'
|
256
|
+
RDL.type :Array, :cycle, '(?Integer) -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), promoted_or_t(trec))``'
|
257
|
+
RDL.type :Array, :delete, '(u) -> ``promote_tuple!(trec); targs[0]``'
|
258
|
+
RDL.type :Array, :delete, '(u) { () -> v } -> ``promote_tuple!(trec); RDL::Globals.parser.scan_str "#T u or v"``'
|
259
|
+
RDL.type :Array, :delete_at, '(Integer) -> ``promote_tuple!(trec)``'
|
260
|
+
RDL.type :Array, :delete_if, '() { (``promoted_or_t(trec)``) -> %bool } -> ``promote_tuple!(trec)``'
|
261
|
+
RDL.type :Array, :delete_if, '() -> ``promote_tuple!(trec); RDL::Globals.parser.scan_str "#T Enumerator<t>"``'
|
262
|
+
RDL.type :Array, :drop, '(Integer) -> ``promote_tuple!(trec)``'
|
263
|
+
RDL.type :Array, :drop_while, '() { (``promoted_or_t(trec)``) -> %bool } -> ``promote_tuple!(trec)``'
|
264
|
+
RDL.type :Array, :drop_while, '() -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), promoted_or_t(trec))``'
|
265
|
+
RDL.type :Array, :each, '() -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), promoted_or_t(trec))``'
|
266
|
+
RDL.type :Array, :each, '() { (``promoted_or_t(trec)``) -> %any } -> self'
|
267
|
+
RDL.type :Array, :each_index, '() { (Integer) -> %any } -> self'
|
268
|
+
RDL.type :Array, :each_index, '() -> Enumerator<Integer>'
|
269
|
+
RDL.type :Array, :empty?, '() -> ``output_type(trec, targs, :empty?, "%bool")``', effect: [:+, :+]
|
270
|
+
RDL.type :Array, :fetch, '(Integer) -> ``output_type(trec, targs, :[], :promoted_param, "t")``'
|
271
|
+
RDL.type :Array, :fetch, '(Integer, u) -> ``RDL::Type::UnionType.new(RDL::Globals.parser.scan_str("u"), output_type(trec, targs, :[], :promoted_param, "t"))``'
|
272
|
+
RDL.type :Array, :fetch, '(Integer) { (Integer) -> u } -> ``RDL::Type::UnionType.new(RDL::Globals.parser.scan_str("u"), output_type(trec, targs, :[], :promoted_param, "t"))``'
|
273
|
+
RDL.type :Array, :fill, '(``any_or_t(trec)``) -> ``fill_output(trec, targs)``'
|
274
|
+
|
275
|
+
|
276
|
+
def Array.fill_output(trec, targs)
|
277
|
+
case trec
|
278
|
+
when RDL::Type::TupleType
|
279
|
+
trec.params.map! { |e|
|
280
|
+
if RDL::Config.instance.weak_update_promote
|
281
|
+
Hash.weak_promote(RDL::Type::UnionType.new(e, targs[0]).canonical)
|
282
|
+
else
|
283
|
+
RDL::Type::UnionType.new(e, targs[0]).canonical
|
284
|
+
end
|
285
|
+
}
|
286
|
+
trec.check_bounds(true)
|
287
|
+
trec
|
288
|
+
else
|
289
|
+
RDL::Globals.parser.scan_str "#T Array<t>"
|
290
|
+
end
|
291
|
+
end
|
292
|
+
RDL.type Array, 'self.fill_output', "(RDL::Type::Type, Array<RDL::Type::Type>) -> RDL::Type::Type", typecheck: :type_code, wrap: false, effect: [:~, :+]
|
293
|
+
|
294
|
+
RDL.type :Array, :fill, '(``promoted_or_t(trec)``, Integer, ?Integer) -> ``promote_tuple!(trec)``' ## can be more precise for this one, but would require many cases
|
295
|
+
RDL.type :Array, :fill, '(``promoted_or_t(trec)``, Range<Integer>) -> ``promote_tuple!(trec)``'
|
296
|
+
RDL.type :Array, :fill, '() { (Integer) -> ``promoted_or_t(trec)`` } -> ``promote_tuple!(trec)``'
|
297
|
+
RDL.type :Array, :fill, '(Integer, ?Integer) { (Integer) -> ``promoted_or_t(trec)`` } -> ``promote_tuple!(trec)``'
|
298
|
+
RDL.type :Array, :fill, '() { (Range<Integer>) -> ``promoted_or_t(trec)`` } -> ``promote_tuple!(trec)``'
|
299
|
+
RDL.type :Array, :flatten, '() -> Array<%any>' # Can't give a more precise RDL.type
|
300
|
+
RDL.type :Array, :index, '(u) -> ``t = output_type(trec, targs, :index, "Integer", use_sing_val: false, nil_false_default: true)``'
|
301
|
+
RDL.type :Array, :index, '() { (``promoted_or_t(trec)``) -> %bool } -> Integer'
|
302
|
+
RDL.type :Array, :index, '() -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), promoted_or_t(trec))``'
|
303
|
+
RDL.type :Array, :first, '() -> ``output_type(trec, targs, :first, :promoted_param, "t")``'
|
304
|
+
RDL.type :Array, :first, '(Integer) -> ``output_type(trec, targs, :first, :promoted_array, "Array<t>")``'
|
305
|
+
RDL.type :Array, :include?, '(%any) -> ``output_type(trec, targs, :include?, "%bool", use_sing_val: false, nil_false_default: true)``'
|
306
|
+
|
307
|
+
|
308
|
+
def Array.include_output(trec, targs)
|
309
|
+
case trec
|
310
|
+
when RDL::Type::TupleType
|
311
|
+
case targs[0]
|
312
|
+
when RDL::Type::SingletonType
|
313
|
+
if trec.params.include?(targs[0])
|
314
|
+
RDL::Globals.types[:true]
|
315
|
+
else
|
316
|
+
## in this case, still can't say false because arg may be in tuple, but without singleton type.
|
317
|
+
RDL::Globals.types[:bool]
|
318
|
+
end
|
319
|
+
else
|
320
|
+
RDL::Globals.types[:bool]
|
321
|
+
end
|
322
|
+
else
|
323
|
+
RDL::Globals.types[:bool]
|
324
|
+
end
|
325
|
+
end
|
326
|
+
RDL.type Array, 'self.include_output', "(RDL::Type::Type, Array<RDL::Type::Type>) -> RDL::Type::Type", typecheck: :type_code, wrap: false, effect: [:+, :+]
|
327
|
+
|
328
|
+
|
329
|
+
RDL.type :Array, :insert, '(Integer, ``promoted_or_t(trec)``) -> ``promote_tuple!(trec)``'
|
330
|
+
RDL.type :Array, :inspect, '() -> String'
|
331
|
+
RDL.type :Array, :join, '(?String) -> String'
|
332
|
+
RDL.type :Array, :keep_if, '() { (``promoted_or_t(trec)``) -> %bool } -> ``promote_tuple!(trec)``'
|
333
|
+
RDL.type :Array, :last, '() -> ``output_type(trec, targs, :last, :promoted_param, "t")``'
|
334
|
+
RDL.type :Array, :last, '(Integer) -> ``output_type(trec, targs, :last, :promoted_array, "Array<t>")``'
|
335
|
+
RDL.type :Array, :member?, '(u) -> ``output_type(trec, targs, :member?, "%bool", use_sing_val: false, nil_false_default: true)``'
|
336
|
+
RDL.type :Array, :length, '() -> ``output_type(trec, targs, :length, "Integer")``'
|
337
|
+
RDL.type :Array, :permutation, '(?Integer) -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), promoted_or_t(trec))``'
|
338
|
+
RDL.type :Array, :permuation, '(?Integer) { (``promote_tuple(trec)``) -> %any } -> ``promote_tuple(trec)``'
|
339
|
+
RDL.type :Array, :pop, '(Integer) -> ``promote_tuple!(trec)``'
|
340
|
+
RDL.type :Array, :pop, '() -> ``promote_tuple(trec); RDL::Globals.parser.scan_str "#T t"``'
|
341
|
+
RDL.type :Array, :product, '(*Array<u>) -> ``RDL::Type::GenericType.new(RDL::Globals.types[:array], RDL::Type::GenericType.new(RDL::Globals.types[:array], RDL::Type::UnionType.new(promoted_or_t(trec), RDL::Globals.parser.scan_str("#T u"))))``'
|
342
|
+
RDL.type :Array, :rassoc, '(u) -> ``promoted_or_t(trec)``'
|
343
|
+
RDL.type :Array, :reject, '() { (``promoted_or_t(trec)``) -> %bool } -> ``promote_tuple(trec)``'
|
344
|
+
RDL.type :Array, :reject, '() -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), promoted_or_t(trec))``'
|
345
|
+
RDL.type :Array, :reject!, '() { (``promoted_or_t(trec)``) -> %bool } -> ``promote_tuple!(trec)``'
|
346
|
+
RDL.type :Array, :reject!, '() -> Enumerator<t>'
|
347
|
+
RDL.type :Array, :repeated_combination, '(Integer) { (``promote_tuple(trec)``) -> %any } -> ``promote_tuple(trec)``'
|
348
|
+
RDL.type :Array, :repeated_combination, '(Integer) -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), promoted_or_t(trec))``'
|
349
|
+
RDL.type :Array, :repeated_permutation, '(Integer) { (``promote_tuple(trec)``) -> %any } -> ``promote_tuple(trec)``'
|
350
|
+
RDL.type :Array, :repeated_permutation, '(Integer) -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), promoted_or_t(trec))``'
|
351
|
+
RDL.type :Array, :reverse, '() -> ``output_type(trec, targs, :reverse, :promoted_array, "Array<t>")``'
|
352
|
+
RDL.type :Array, :reverse!, '() -> ``reverse_output(trec)``'
|
353
|
+
|
354
|
+
|
355
|
+
def Array.reverse_output(trec)
|
356
|
+
case trec
|
357
|
+
when RDL::Type::TupleType
|
358
|
+
rev = trec.params.reverse
|
359
|
+
i = 0
|
360
|
+
trec.params.map! { |e|
|
361
|
+
un = RDL::Type::UnionType.new(e, rev[i]).canonical
|
362
|
+
i = i + 1
|
363
|
+
if RDL::Config.instance.weak_update_promote
|
364
|
+
Hash.weak_promote(un)
|
365
|
+
else
|
366
|
+
un
|
367
|
+
end
|
368
|
+
}
|
369
|
+
trec.check_bounds(true)
|
370
|
+
trec
|
371
|
+
else
|
372
|
+
RDL::Globals.parser.scan_str "#T Array<t>"
|
373
|
+
end
|
374
|
+
end
|
375
|
+
RDL.type Array, 'self.reverse_output', "(RDL::Type::Type) -> RDL::Type::Type", typecheck: :type_code, wrap: false, effect: [:~, :+]
|
376
|
+
|
377
|
+
RDL.type :Array, :reverse_each, '() { (``promoted_or_t(trec)``) -> %any } -> self'
|
378
|
+
RDL.type :Array, :reverse_each, '() -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), promoted_or_t(trec))``'
|
379
|
+
RDL.type :Array, :rindex, '(u) -> ``promoted_or_t(trec)``'
|
380
|
+
RDL.type :Array, :rindex, '() { (``promoted_or_t(trec)``) -> %bool } -> Integer'
|
381
|
+
RDL.type :Array, :rindex, '() -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), promoted_or_t(trec))``'
|
382
|
+
RDL.type :Array, :rotate, '(?Integer) -> ``output_type(trec, targs, :rotate, :promoted_array, "Array<t>")``'
|
383
|
+
RDL.type :Array, :rotate!, '(?Integer) -> ``promote_tuple!(trec)``'
|
384
|
+
RDL.type :Array, :sample, '() -> ``promoted_or_t(trec)``'
|
385
|
+
RDL.type :Array, :sample, '(Integer) -> ``promote_tuple(trec)``'
|
386
|
+
RDL.type :Array, :select, '() { (``promoted_or_t(trec)``) -> %bool } -> ``promote_tuple(trec)``'
|
387
|
+
RDL.type :Array, :select, '() -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), promoted_or_t(trec))``'
|
388
|
+
RDL.type :Array, :select!, '() { (``promoted_or_t(trec)``) -> %bool } -> ``promote_tuple!(trec)``'
|
389
|
+
RDL.type :Array, :select!, '() -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), promoted_or_t(trec))``'
|
390
|
+
RDL.type :Array, :shift, '() -> ``promote_tuple!(trec); RDL::Globals.parser.scan_str "#T t"``'
|
391
|
+
RDL.type :Array, :shift, '(Integer) -> ``promote_tuple!(trec)``'
|
392
|
+
RDL.type :Array, :shuffle, '() -> ``promote_tuple(trec)``'
|
393
|
+
RDL.type :Array, :shuffle!, '() -> ``promote_tuple!(trec)``'
|
394
|
+
RDL.rdl_alias :Array, :size, :length
|
395
|
+
RDL.rdl_alias :Array, :slice, :[]
|
396
|
+
RDL.type :Array, :slice!, '(Range<Integer>) -> ``promote_tuple!(trec)``'
|
397
|
+
RDL.type :Array, :slice!, '(Integer, Integer) -> ``promote_tuple!(trec)``'
|
398
|
+
RDL.type :Array, :slice!, '(Integer or Float) -> ``promote_tuple!(trec); RDL::Globals.parser.scan_str "#T t"``'
|
399
|
+
RDL.type :Array, :sort, '() -> ``promote_tuple(trec)``'
|
400
|
+
RDL.type :Array, :sort, '() { (``promoted_or_t(trec)``, ``promoted_or_t(trec)``) -> Integer } -> ``promote_tuple(trec)``'
|
401
|
+
RDL.type :Array, :sort!, '() -> ``promote_tuple!(trec)``'
|
402
|
+
RDL.type :Array, :sort!, '() { (``promoted_or_t(trec)``,``promoted_or_t(trec)``) -> Integer } -> ``promote_tuple!(trec)``'
|
403
|
+
RDL.type :Array, :sort_by!, '() { (``promoted_or_t(trec)``) -> u } -> ``promote_tuple!(trec)``'
|
404
|
+
RDL.type :Array, :sort_by!, '() -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), promoted_or_t(trec))``'
|
405
|
+
RDL.type :Array, :take, '(Integer) -> ``output_type(trec, targs, :take, :promoted_array, "Array<t>")``'
|
406
|
+
RDL.type :Array, :take_while, '() { (``promoted_or_t(trec)``) ->%bool } -> ``promote_tuple(trec)``'
|
407
|
+
RDL.type :Array, :take_while, '() -> ``RDL::Type::GenericType.new(RDL::Type::NominalType.new(Enumerator), promoted_or_t(trec))``'
|
408
|
+
RDL.type :Array, :to_a, '() -> self'
|
409
|
+
RDL.type :Array, :to_ary, '() -> self'
|
410
|
+
RDL.rdl_alias :Array, :to_s, :inspect
|
411
|
+
RDL.type :Array, :transpose, '() -> ``promote_tuple(trec)``'
|
412
|
+
RDL.type :Array, :uniq, '() -> ``promote_tuple(trec)``'
|
413
|
+
RDL.type :Array, :uniq!, '() -> ``promote_tuple!(trec)``'
|
414
|
+
RDL.type :Array, :unshift, '(``any_or_t(trec, true)``) -> ``promote_tuple!(trec)``'
|
415
|
+
RDL.type :Array, :values_at, '(*Integer) -> ``output_type(trec, targs, :values_at, :promoted_array, "Array<t>")``'
|
416
|
+
RDL.type :Array, :values_at, '(Range<Integer>) -> ``promote_tuple(trec)``'
|
417
|
+
RDL.type :Array, :zip, '(*Array<u>) -> ``RDL::Type::GenericType.new(RDL::Globals.types[:array], RDL::Type::GenericType.new(RDL::Globals.types[:array], RDL::Type::UnionType.new(promoted_or_t(trec), RDL::Globals.parser.scan_str("#T u"))))``'
|
418
|
+
RDL.type :Array, :|, '(*Array<u>) -> ``RDL::Type::GenericType.new(RDL::Globals.types[:array], RDL::Type::UnionType.new(promoted_or_t(trec), RDL::Globals.parser.scan_str("#T u")))``'
|
419
|
+
|
420
|
+
|
421
|
+
|
422
|
+
|
423
|
+
|
424
|
+
######### Non-dependet types below #########
|
425
|
+
|
426
|
+
RDL.type :Array, :<<, '(t) -> Array<t>', effect: [:-, :+]
|
427
|
+
RDL.type :Array, :[], '(Range<Integer>) -> Array<t>', effect: [:+, :+]
|
428
|
+
RDL.type :Array, :[], '(Integer or Float) -> t', effect: [:+, :+]
|
429
|
+
RDL.type :Array, :[], '(Integer, Integer) -> Array<t>', effect: [:+, :+]
|
9
430
|
RDL.type :Array, :&, '(Array<u>) -> Array<t>'
|
10
431
|
RDL.type :Array, :*, '(Integer) -> Array<t>'
|
11
432
|
RDL.type :Array, :*, '(String) -> String'
|
12
|
-
RDL.type :Array, :+, '(Enumerable<u>) -> Array<u or t>'
|
13
|
-
RDL.type :Array, :+, '(Array<u>) -> Array<u or t>'
|
433
|
+
RDL.type :Array, :+, '(Enumerable<u>) -> Array<u or t>', effect: [:+, :+]
|
434
|
+
RDL.type :Array, :+, '(Array<u>) -> Array<u or t>', effect: [:+, :+]
|
14
435
|
RDL.type :Array, :-, '(Array<u>) -> Array<u or t>'
|
15
436
|
RDL.type :Array, :slice, '(Range<Integer>) -> Array<t>'
|
16
437
|
RDL.type :Array, :slice, '(Integer) -> t'
|
17
438
|
RDL.type :Array, :slice, '(Integer, Integer) -> Array<t>'
|
18
|
-
RDL.type :Array, :[]=, '(Integer, t) -> t'
|
19
|
-
RDL.type :Array, :[]=, '(Integer, Integer, t) -> t'
|
439
|
+
RDL.type :Array, :[]=, '(Integer, t) -> t', effect: [:-, :+]
|
440
|
+
RDL.type :Array, :[]=, '(Integer, Integer, t) -> t', effect: [:-, :+]
|
20
441
|
# RDL.type :Array, :[]=, '(Integer, Integer, Array<t>) -> Array<t>'
|
21
442
|
# RDL.type :Array, :[]=, '(Range, Array<t>) -> Array<t>'
|
22
|
-
RDL.type :Array, :[]=, '(Range<Integer>, t) -> t'
|
443
|
+
RDL.type :Array, :[]=, '(Range<Integer>, t) -> t', effect: [:-, :+]
|
23
444
|
RDL.type :Array, :assoc, '(t) -> Array<t>'
|
24
445
|
RDL.type :Array, :at, '(Integer) -> t'
|
25
446
|
RDL.type :Array, :clear, '() -> Array<t>'
|
26
|
-
RDL.type :Array, :map, '() {(t) -> u} -> Array<u>'
|
27
|
-
RDL.type :Array, :map, '() -> Enumerator<t>'
|
28
|
-
RDL.type :Array, :map!, '() {(t) -> u} -> Array<u>'
|
29
|
-
RDL.type :Array, :map!, '() -> Enumerator<t>'
|
447
|
+
RDL.type :Array, :map, '() {(t) -> u} -> Array<u>', effect: [:blockdep, :blockdep]
|
448
|
+
RDL.type :Array, :map, '() -> Enumerator<t>', effect: [:blockdep, :blockdep]
|
449
|
+
RDL.type :Array, :map!, '() {(t) -> u} -> Array<u>', effect: [:-, :blockdep]
|
450
|
+
RDL.type :Array, :map!, '() -> Enumerator<t>', effect: [:-, :blockdep]
|
30
451
|
RDL.type :Array, :collect, '() { (t) -> u } -> Array<u>'
|
31
452
|
RDL.type :Array, :collect, '() -> Enumerator<t>'
|
32
453
|
RDL.type :Array, :combination, '(Integer) { (Array<t>) -> %any } -> Array<t>'
|
@@ -48,8 +469,8 @@ RDL.type :Array, :delete_if, '() -> Enumerator<t>'
|
|
48
469
|
RDL.type :Array, :drop, '(Integer) -> Array<t>'
|
49
470
|
RDL.type :Array, :drop_while, '() { (t) -> %bool } -> Array<t>'
|
50
471
|
RDL.type :Array, :drop_while, '() -> Enumerator<t>'
|
51
|
-
RDL.type :Array, :each, '() -> Enumerator<t>'
|
52
|
-
RDL.type :Array, :each, '() { (t) -> %any } -> Array<t>'
|
472
|
+
RDL.type :Array, :each, '() -> Enumerator<t>', effect: [:-, :blockdep]
|
473
|
+
RDL.type :Array, :each, '() { (t) -> %any } -> Array<t>', effect: [:-, :blockdep]
|
53
474
|
RDL.type :Array, :each_index, '() { (Integer) -> %any } -> Array<t>'
|
54
475
|
RDL.type :Array, :each_index, '() -> Enumerator<t>'
|
55
476
|
RDL.type :Array, :empty?, '() -> %bool'
|
@@ -68,25 +489,26 @@ RDL.type :Array, :index, '() { (t) -> %bool } -> Integer'
|
|
68
489
|
RDL.type :Array, :index, '() -> Enumerator<t>'
|
69
490
|
RDL.type :Array, :first, '() -> t'
|
70
491
|
RDL.type :Array, :first, '(Integer) -> Array<t>'
|
71
|
-
RDL.type :Array, :include?, '(u) -> %bool'
|
492
|
+
RDL.type :Array, :include?, '(u) -> %bool', effect: [:+, :+]
|
72
493
|
RDL.type :Array, :initialize, '() -> self'
|
73
494
|
RDL.type :Array, :initialize, '(Integer) -> self'
|
74
495
|
RDL.type :Array, :initialize, '(Integer, t) -> self<t>'
|
496
|
+
RDL.type :Array, :initialize, '(Array<k>) -> self<k>'
|
75
497
|
RDL.type :Array, :insert, '(Integer, *t) -> Array<t>'
|
76
498
|
RDL.type :Array, :inspect, '() -> String'
|
77
499
|
RDL.type :Array, :join, '(?String) -> String'
|
78
500
|
RDL.type :Array, :keep_if, '() { (t) -> %bool } -> Array<t>'
|
79
501
|
RDL.type :Array, :last, '() -> t'
|
80
502
|
RDL.type :Array, :last, '(Integer) -> Array<t>'
|
81
|
-
RDL.type :Array, :member
|
82
|
-
RDL.type :Array, :length, '() -> Integer'
|
503
|
+
RDL.type :Array, :member?, '(u) -> %bool', effect: [:+, :+]
|
504
|
+
RDL.type :Array, :length, '() -> Integer', effect: [:+, :+]
|
83
505
|
RDL.type :Array, :permutation, '(?Integer) -> Enumerator<t>'
|
84
506
|
RDL.type :Array, :permutation, '(?Integer) { (Array<t>) -> %any } -> Array<t>'
|
85
507
|
RDL.type :Array, :pop, '(Integer) -> Array<t>'
|
86
508
|
RDL.type :Array, :pop, '() -> t'
|
87
509
|
RDL.type :Array, :product, '(*Array<u>) -> Array<Array<t or u>>'
|
88
510
|
RDL.type :Array, :rassoc, '(u) -> t'
|
89
|
-
RDL.type :Array, :reject, '() { (t) -> %bool } -> Array<t>'
|
511
|
+
RDL.type :Array, :reject, '() { (t) -> %bool } -> Array<t>', effect: [:+, :blockdep]
|
90
512
|
RDL.type :Array, :reject, '() -> Enumerator<t>'
|
91
513
|
RDL.type :Array, :reject!, '() { (t) -> %bool } -> Array<t>'
|
92
514
|
RDL.type :Array, :reject!, '() -> Enumerator<t>'
|
@@ -94,7 +516,7 @@ RDL.type :Array, :repeated_combination, '(Integer) { (Array<t>) -> %any } -> Arr
|
|
94
516
|
RDL.type :Array, :repeated_combination, '(Integer) -> Enumerator<t>'
|
95
517
|
RDL.type :Array, :repeated_permutation, '(Integer) { (Array<t>) -> %any } -> Array<t>'
|
96
518
|
RDL.type :Array, :repeated_permutation, '(Integer) -> Enumerator<t>'
|
97
|
-
RDL.type :Array, :reverse, '() -> Array<t>'
|
519
|
+
RDL.type :Array, :reverse, '() -> Array<t>', effect: [:+, :+]
|
98
520
|
RDL.type :Array, :reverse!, '() -> Array<t>'
|
99
521
|
RDL.type :Array, :reverse_each, '() { (t) -> %any } -> Array<t>'
|
100
522
|
RDL.type :Array, :reverse_each, '() -> Enumerator<t>'
|
@@ -113,8 +535,6 @@ RDL.type :Array, :shift, '() -> t'
|
|
113
535
|
RDL.type :Array, :shift, '(Integer) -> Array<t>'
|
114
536
|
RDL.type :Array, :shuffle, '() -> Array<t>'
|
115
537
|
RDL.type :Array, :shuffle!, '() -> Array<t>'
|
116
|
-
RDL.rdl_alias :Array, :size, :length
|
117
|
-
RDL.rdl_alias :Array, :slice, :[]
|
118
538
|
RDL.type :Array, :slice!, '(Range<Integer>) -> Array<t>'
|
119
539
|
RDL.type :Array, :slice!, '(Integer, Integer) -> Array<t>'
|
120
540
|
RDL.type :Array, :slice!, '(Integer or Float) -> t'
|
@@ -129,7 +549,6 @@ RDL.type :Array, :take_while, '() { (t) ->%bool } -> Array<t>'
|
|
129
549
|
RDL.type :Array, :take_while, '() -> Enumerator<t>'
|
130
550
|
RDL.type :Array, :to_a, '() -> Array<t>'
|
131
551
|
RDL.type :Array, :to_ary, '() -> Array<t>'
|
132
|
-
RDL.rdl_alias :Array, :to_s, :inspect
|
133
552
|
RDL.type :Array, :transpose, '() -> Array<t>'
|
134
553
|
RDL.type :Array, :uniq, '() -> Array<t>'
|
135
554
|
RDL.type :Array, :uniq!, '() -> Array<t>'
|