[ruby-core:107695] [Ruby master Feature#16295] Chainable aliases for String#-@ and String#+@

["danh337 (Dan H)" <noreply@ruby-lang.org>]

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


Eregon (Benoit Daloze) wrote in #note-7:
> @danh337 `-@` and the proposed `dedup` intern/deduplicate.
> This is the main feature of those methods and it is *very much* part of the semantics (as the docs say).
> It's the whole point of these methods really, to reduce the number of duplicate strings and reduce memory usage (which @byroot and others successfully used in many gems).
> 
> `freeze` does not intern/deduplicate. That has the advantage it's faster, but it doesn't help memory footprint if there are many duplicates of the same string.
> 
> Regarding `+@`/`dup` feel free to continue discussing that on #16295, this issue should remain focused on `dedup`, that is the purpose of the new issue.

The `.@+` is still not resolved, even though #16295 is closed. If the *behavior* of `.+@` and `.dup` is the same, that's fine and I get your point, but `x = "".dup` is semantically weird. I realize that `x = +""` is probably what most would use anyway, but for method chains that mutate a String, where I know the String is *expected* to mutate, a "fast" inverse of `.freeze` would be nice instead of always `.dup`. If a String is already mutable, we do not want to duplicate it.

----------------------------------------
Feature #16295: Chainable aliases for String#-@ and String#+@
https://bugs.ruby-lang.org/issues/16295#change-96613

* Author: byroot (Jean Boussier)
* Status: Closed
* Priority: Normal
----------------------------------------
Original discussion https://bugs.ruby-lang.org/issues/16150?next_issue_id=16147&prev_issue_id=16153#note-40

In #16150, @headius raised the following concern about `String#-@` and `String#+@`:

headius (Charles Nutter) wrote:
> > Not exactly, -@ and +@ makes this much simpler
> 
> I do like the unary operators, but they also have some precedence oddities:
> 
> ```
> >> -"foo".size
> => -3
> >> (-"foo").size
> => 3
> ```
> 
> And it doesn't work at all if you're chaining method calls:
> 
> ```
> >> +ary.to_s.frozen?
> NoMethodError: undefined method `+@' for false:FalseClass
> 	from (irb):8
> 	from /usr/bin/irb:11:in `<main>'
> ```
> 
> But you are right, instead of the explicit `dup` with possible freeze you could use `-` or `+` on the result of `to_s`. However it's still not safe to modify it since it would modify the original string too.

After working for quite a while with those, I have to say I agree. They very often force to use parentheses, which is annoying, and an indication that regular methods would be preferable to unary operators.


In response @matz proposed to alias them as `String#+` and `String#-` without arguments:

>  How about making String#+ and #- without argument behave like #+@ and #-@ respectively, so that we can write:
>  
>  ```
>  "foo".-.size
>  ary.to_s.+.frozen?
>  ```


My personal opinion is that descriptive method names would be preferable to `+/-`:

> IMHO `.-` and `.+` is not very elegant. Proper method names explaining the intent would be preferable.
> 
>   - `-@` could be `dedup`, or `deduplicate`.
>   - `+@` could be `mutable` or `mut`.





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