Issue #8909 has been updated by headius (Charles Nutter).


A couple questions:

* If you have literal arrays/strings/hashes within a frozen literal array/hash, should the "f" suffix do a "deep freeze" or do you have to specify each one?

in other words, if I want this whole thing to be frozen, do I need to do:

[[1, 2]f, {foo: 3}f, "blah"f]f

or

[[1, 2], {foo: 3}, "blah"]f

I can see pros and cons both ways.

* Is there any problem with "f" suffixes always returning the same object when the contents are the same and also immutable? I have not looked at the implementation in MRI for "foo"f, but it *should* be totally ok for it to always return the same object. [:foo, 1, 2.0]f should be the same thing.

* Special syntax for frozen empty array

A great number of wasted Ruby objects are caused by needing to simply pass or return an empty array. Because Arrays are mutable by default, [] always has to return a new object. The same goes for hashes.

For example, in method definitions:

def foo(opts = {}) # new hash created every time and probably doesn't need to be mutable
def bar(args = []) # new array created every time and probably doesn't need to be mutable

So with this proposal, we'd have []f and {}f, which aren't too bad...but I wanted to throw out the possibility of some other magic syntax. I have no strong preference or ideas.
----------------------------------------
Feature #8909: Expand "f" frozen suffix to literal arrays and hashes
https://bugs.ruby-lang.org/issues/8909#change-41805

Author: headius (Charles Nutter)
Status: Open
Priority: Normal
Assignee: 
Category: 
Target version: 


The "f" suffix to declare a frozen string was recently accepted into 2.1, and I think it's a spectacular addition. I would very much like to see it work for literal arrays and hashes too:

[1, 2, 3, 4, 5]f

{foo: 1, bar: 2, baz: 3}f

There are many, many cases where this could reduce allocation (frozen array with literal elements would only need to be allocated once) and improve thread-safety (explicitly create frozen arrays and hashes when creating structures that might be used across threads).

Is there any reason why we could not do this? I believe both of the above syntaxes would be invalid today, as was the case with the String "f" suffix, and hopefully that means the work to add this syntax would be similar.


-- 
http://bugs.ruby-lang.org/