[#107430] [Ruby master Feature#18566] Merge `io-wait` gem into core IO — "byroot (Jean Boussier)" <noreply@...>
Issue #18566 has been reported by byroot (Jean Boussier).
22 messages
2022/02/02
[ruby-core:107714] [Ruby master Feature#18597] Strings need a named method like `dup` that doesn't duplicate if receiver is mutable
From:
"danh337 (Dan H)" <noreply@...>
Date:
2022-02-22 14:56:19 UTC
List:
ruby-core #107714
Issue #18597 has been updated by danh337 (Dan H).
Eregon (Benoit Daloze) wrote in #note-8:
> A real-world example would be interesting. But I guess there isn't a compelling one.
There are good examples in the other ticket where `.+@` is used but is clunky, so the method name is desirable. I am adding to that this case, where I need optimal code, that doesn't raise exception or duplicate a String as the only two options.
I'm not sure what you mean by "real-world" example using a feature that doesn't yet exist. This is from #16295.
> This already has made some of my production code ugly, when using tap. I have to say:
> `(+some_object.send(a_method)).tap { |value| value << "blah" }`
> or
> `some_object.send(a_method).+@.tap { |value| value << "blah" }`
>
> Neither of these looks like good Ruby. I'd rather say some_object.send(a_method).thaw.tap { |value| value << "blah" }
If I'm on a team of devs, and I have other people calling my code, and I want it to be as optimized as possible, and I don't want to raise exception if I don't absolutely have to, then it's not basically useless to have a clearly named method that ensures at most 1 duplication.
I don't believe `.+@` is useless. I mean, it's useless until you need it. But it's not Ruby-ish to be required to use that in a method chain.
----------------------------------------
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-96638
* 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: <mailto:ruby-core-request@ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>