Issue #16047 has been updated by ioquatix (Samuel Williams).


I started using `frozen_string_literal` and I also wish `frozen_literal` (generally applies to Array `[]`, Hash `{}`, etc).

The model I use:

Mutable string: `String.new`

Constant string: `"CONSTANT"`

I've experienced bugs because strings (and other things) were mutated after being passed as an argument to an object constructor.

I feel immutable by default is the safest and most efficient option, and users should opt into mutability when required, using constructors, e.g. as shown above for string, or `[]` (immutable) vs `Array.new` (mutable). We can establish some standard pattern.

With good CoW implementation, calling `.dup` should almost be a no-op for most data structures, so we should encourage that in object constructors, e.g.

```
class Box
  def initialize(items)
    @items = items # risky
    @items = items.dup # safe but maybe expensive?
  end
end
```

This is also made more efficient by immutable by default.

Finally, we should provide better performance guarantees to users and give some general purpose rules like using `#dup` when you are receiving arguments and saving into instance variables. Right now, I see many code doing different things.


----------------------------------------
Misc #16047: Reconsider impact of frozen_string_literal on dynamic strings
https://bugs.ruby-lang.org/issues/16047#change-80402

* Author: Dan0042 (Daniel DeLorme)
* Status: Open
* Priority: Normal
* Assignee: matz (Yukihiro Matsumoto)
----------------------------------------
The rationale for introducing `frozen_string_literal` was because rubyists were starting to litter their code with `"".freeze` for optimization, and it's ugly.

But by using frozen_string_literal we introduce the opposite problem: we must litter the code with `"".dup` in order to have mutable strings, and it's ugly.

The rationale for freezing all strings including dynamic was because it's [easy to explain]
(https://docs.google.com/document/u/1/d/1D0Eo5N7NE_unIySOKG9lVj_eyXf66BQPM4PKp7NvMyQ/pub)
This may be true, but at the expense of making it cumbersome to use. And also completely useless for memory optimization.

In my personal experience using frozen_string_literal, I find that static strings are usually ok to freeze without changing anything else, but that freezing dynamic strings often create bugs that require `+""` or `"".dup` boilerplate to circumvent. So in the end I found myself stopping regular use of that feature, since it's more trouble than it's worth.

As such I'd like to ask other rubyists how has been their experience with **actually using** frozen_string_literal on a day-to-day basis; if my experience is unique or common. Thank you for sharing your thoughts.



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

Unsubscribe: <mailto:ruby-core-request / ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>