From: "danh337 (Dan H)" Date: 2022-02-22T19:02:27+00:00 Subject: [ruby-core:107718] [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). Eregon (Benoit Daloze) wrote in #note-10: > I meant code in a gem or in some open-source repository, so we can see the context and the need. My team has needed this in its own code. I have given a pattern for it. I don't have time to search for examples from all gems or repos in the world. > That example seems a clear case for String interpolation: > ```ruby > "#{some_object.send(a_method)}blah" > ``` That is not the same code. You are always making a new String. I thought `.+@` only dups if the receiver is frozen. The `a_method` result could be mutable. > > and I don't want to raise exception if I don't absolutely have to > > That is I believe an anti-pattern. > Concretely, a method should either take a String and will never mutate it, or it needs a mutable String/a buffer (and will or can mutate it). > What I'm saying is "might or might not mutate the argument (depending on frozen state)" is a bad design. > A method should be clear about what it expects, it's very hard to work with a method which might mutate or not what you give it. Thanks for sharing your opinions. I know your job here is to weed out frivolous requests, but this experience makes me sad. Wasting time. My team will continue to use the awkward `.+@` where we need it, or I will add a name for it in our own extensions lib. ---------------------------------------- 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-96641 * 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 ``` -- https://bugs.ruby-lang.org/ Unsubscribe: