Issue #18035 has been updated by ioquatix (Samuel Williams).
If this is accepted, should Data classes all be immutable? To quote the docs:
By default, it does not look like Data is considered immutable as nested values can mutate. However, this proposal would allow for immutable Data instances, e.g. ```ruby irb(main):001> Person = Data.define(:name, :age, :hobbies) => Person irb(main):002> bob = Person.new("Bob", 20, ["Ruby"]) => #<data Person name="Bob", age=20, hobbies=["Ruby"]> irb(main):003> bob.hobbies << "Fishing" => ["Ruby", "Fishing"] irb(main):004> bob => #<data Person name="Bob", age=20, hobbies=["Ruby", "Fishing"]> irb(main):005> Immutable bob => #<data Person name="Bob", age=20, hobbies=["Ruby", "Fishing"]> irb(main):006> bob.hobbies << "Biking" (irb):6:in `<main>': can't modify frozen Array: ["Ruby", "Fishing"] (FrozenError) from <internal:kernel>:187:in `loop' from -e:1:in `<main>' ``` ---------------------------------------- Feature #18035: Introduce general model/semantic for immutability. https://bugs.ruby-lang.org/issues/18035#change-106215 * Author: ioquatix (Samuel Williams) * Status: Open * Priority: Normal ---------------------------------------- It would be good to establish some rules around mutability, immutability, frozen, and deep frozen in Ruby. I see time and time again, incorrect assumptions about how this works in production code. Constants that aren't really constant, people using `#freeze` incorrectly, etc. I don't have any particular preference but: - We should establish consistent patterns where possible, e.g. - Objects created by `new` are mutable. - Objects created by literal are immutable. We have problems with how `freeze` works on composite data types, e.g. `Hash#freeze` does not impact children keys/values, same for Array. Do we need to introduce `freeze(true)` or `#deep_freeze` or some other method? Because of this, frozen does not necessarily correspond to immutable. This is an issue which causes real world problems. I also propose to codify this where possible, in terms of "this class of object is immutable" should be enforced by the language/runtime, e.g. ```ruby module Immutable def new(...) super.freeze end end class MyImmutableObject extend Immutable def initialize(x) @x = x end def freeze return self if frozen? @x.freeze super end end o = MyImmutableObject.new([1, 2, 3]) puts o.frozen? ``` Finally, this area has an impact to thread and fiber safe programming, so it is becoming more relevant and I believe that the current approach which is rather adhoc is insufficient. I know that it's non-trivial to retrofit existing code, but maybe it can be done via magic comment, etc, which we already did for frozen string literals. Proposed PR: https://github.com/ruby/ruby/pull/4879 -- https://bugs.ruby-lang.org/