[ruby-core:112482] [Ruby master Feature#18597] Strings need a named method like `dup` that doesn't duplicate if receiver is mutable

Issue #18597 has been updated by danh337 (Dan H).


rubyFeedback (robert heiler) wrote in #note-18:
> > And it feels like I cannot convince anyone here with any amount of rationale
> 
> Ultimately you only have to convince matz, so you could ignore what others write.
> 
> But one reason why there was a reference to real-needs above is that the ruby
> core/dev team said that they focus on real needs (although they may evaluate
> what is real and what is not ultimately, as well as the cost of addition of
> methods).
> 
> My personal opinion is that, usage aside, the .dup_if_immutable feels very clunky.
> [...]

This is a great response, cheers and thanks for your time. Honestly I never thought this was a huge thing, and in fact we already fixed it with the "thaw" method I mentioned in comment #13 above. 

It was an issue that came up for me, integrating with old code, in a couple different ways, but the team considers it solved now.

I think I confused the issue early on, not clearly describing the issue for Strings first, then generalizing to Object.

As usual the Ruby community has some cool and helpful folks, thanks again for responding here.


----------------------------------------
Feature #18597: Strings need a named method like `dup` that doesn't duplicate if receiver is mutable
https://bugs.ruby-lang.org/issues/18597#change-101925

* Author: danh337 (Dan H)
* Status: Open
* Priority: Normal
----------------------------------------
This is related to #16295, but focuses only on the `.+@` part.

Currently we can use `.dup` in a method chain when we need to mutate a String.

However there are cases where the code's context *expects* the String to be mutated. In cases like this, `.dup` always works, but we don't want to duplicate a String that is already mutable.

Since `.+@` looks more like an operator, it can be unintuitive in a method chain, so this is asking for a new named method that can be used in its place, instead of always `.dup`.

For example:
```
def add_result_text(buffer, new_result)
  text = "#{new_result.count} #{new_result.input} #{do_fancy_calc(new_result)}\n"
  buffer.dup_if_immutable << text
  #      ^^^^^^^^^^^^^^^^ new method?
end

buffer = "" # ...maybe immutable

get_lots_of_results.each do |result|
  buffer = add_result_text(buffer, result) # In case it was dup'ed
end
```


---Files--------------------------------
driver.rb (12.3 KB)
driver.rb (12.7 KB)


-- 
https://bugs.ruby-lang.org/
 ______________________________________________
 ruby-core mailing list -- [e-mail]
 To unsubscribe send an email to [e-mail]
 ruby-core info -- https://ml.ruby-lang.org/mailman3/postorius/lists/ruby-core.ml.ruby-lang.org/