Feature #14680 ยป freeze.patch
array.c | ||
---|---|---|
}
|
||
/*
|
||
* call-seq:
|
||
* +ary -> ary (mutable)
|
||
*
|
||
* If the array is frozen, then return duplicated mutable array.
|
||
*
|
||
* If the array is not frozen, then return the array itself.
|
||
*/
|
||
static VALUE
|
||
rb_ary_uplus(VALUE ary)
|
||
{
|
||
if (OBJ_FROZEN(ary)) {
|
||
return rb_ary_dup(ary);
|
||
}
|
||
else {
|
||
return ary;
|
||
}
|
||
}
|
||
/*
|
||
* call-seq:
|
||
* -ary -> ary (frozen)
|
||
*
|
||
* If the array is frozen, then return the array itself.
|
||
*
|
||
* If the array is not frozen, return a frozen copy of it.
|
||
*/
|
||
static VALUE
|
||
rb_ary_uminus(VALUE ary)
|
||
{
|
||
if (OBJ_FROZEN(ary)) {
|
||
return ary;
|
||
}
|
||
else {
|
||
return rb_ary_freeze(ary);
|
||
}
|
||
}
|
||
/*
|
||
* Arrays are ordered, integer-indexed collections of any object.
|
||
*
|
||
* Array indexing starts at 0, as in C or Java. A negative index is assumed
|
||
... | ... | |
rb_define_method(rb_cArray, "dig", rb_ary_dig, -1);
|
||
rb_define_method(rb_cArray, "sum", rb_ary_sum, -1);
|
||
rb_define_method(rb_cArray, "+@", rb_ary_uplus, 0);
|
||
rb_define_method(rb_cArray, "-@", rb_ary_uminus, 0);
|
||
id_random = rb_intern("random");
|
||
}
|
hash.c | ||
---|---|---|
return hash_le(other, hash);
|
||
}
|
||
/*
|
||
* call-seq:
|
||
* +hsh -> hsh (mutable)
|
||
*
|
||
* If the hash is frozen, then return duplicated mutable hash.
|
||
*
|
||
* If the hash is not frozen, then return the hash itself.
|
||
*/
|
||
static VALUE
|
||
rb_hash_uplus(VALUE hsh)
|
||
{
|
||
if (OBJ_FROZEN(hsh)) {
|
||
return rb_hash_dup(hsh);
|
||
}
|
||
else {
|
||
return hsh;
|
||
}
|
||
}
|
||
/*
|
||
* call-seq:
|
||
* -hsh -> hsh (frozen)
|
||
*
|
||
* If the hash is frozen, then return the hash itself.
|
||
*
|
||
* If the hash is not frozen, return a frozen copy of it.
|
||
*/
|
||
static VALUE
|
||
rb_hash_uminus(VALUE hsh)
|
||
{
|
||
if (OBJ_FROZEN(hsh)) {
|
||
return hsh;
|
||
}
|
||
else {
|
||
return rb_hash_freeze(hsh);
|
||
}
|
||
}
|
||
static VALUE
|
||
hash_proc_call(VALUE key, VALUE hash, int argc, const VALUE *argv, VALUE passed_proc)
|
||
{
|
||
... | ... | |
rb_define_method(rb_cHash, ">=", rb_hash_ge, 1);
|
||
rb_define_method(rb_cHash, ">", rb_hash_gt, 1);
|
||
rb_define_method(rb_cHash, "+@", rb_hash_uplus, 0);
|
||
rb_define_method(rb_cHash, "-@", rb_hash_uminus, 0);
|
||
/* Document-class: ENV
|
||
*
|
||
* ENV is a hash-like accessor for environment variables.
|
test/ruby/test_array.rb | ||
---|---|---|
assert_raise(TypeError) {[1].sum("")}
|
||
end
|
||
def test_uplus
|
||
a = [1, 2, 3].freeze
|
||
assert a.frozen?
|
||
refute (+a).frozen?
|
||
a = [1, 2, 3]
|
||
assert_equal a, +a
|
||
end
|
||
def test_uminus
|
||
a = [1, 2, 3]
|
||
refute a.frozen?
|
||
assert (-a).frozen?
|
||
a = [1, 2, 3].freeze
|
||
assert_equal a, -a
|
||
end
|
||
private
|
||
def need_continuation
|
||
unless respond_to?(:callcc, true)
|
test/ruby/test_hash.rb | ||
---|---|---|
assert_equal(0, 1_000_000.times.count{a=Object.new.hash; b=Object.new.hash; 0 + a + b != 0 + b + a}, bug14218)
|
||
end
|
||
def test_uplus
|
||
a = { a: 1, b: 2, c: 3 }.freeze
|
||
assert a.frozen?
|
||
refute (+a).frozen?
|
||
a = { a: 1, b: 2, c: 3 }
|
||
assert_equal a, +a
|
||
end
|
||
def test_uminus
|
||
a = { a: 1, b: 2, c: 3 }
|
||
refute a.frozen?
|
||
assert (-a).frozen?
|
||
a = { a: 1, b: 2, c: 3 }.freeze
|
||
assert_equal a, -a
|
||
end
|
||
class TestSubHash < TestHash
|
||
class SubHash < Hash
|
||
def reject(*)
|