[ruby-core:107661] [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-16:
> `+@` is rarely safe to use (only if you know what allocated it and that it was never captured in another variable) as it might mutate an argument inplace, if that object is not frozen.
> In most cases, people actually want to use `.dup` and that already exists.
> 
> @danh337 `-@` is not the same as `freeze`, see discussion above.

`.dup` is not quite as good, as it always allocates a copy. The `.thaw` semantics would be to allocate a new copy only if the receiver is already frozen.

I realize that "unfreeze" does not exist, but I'm making the assumption (yes dangerous) that `+@` and `-@` on existing Strings do their best to avoid allocating new objects, and currently there is no method equivalent to do that for `+@`.

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

* Author: byroot (Jean Boussier)
* Status: Open
* 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/