Perhaps my examples were not clear enough. My point is that, unlike String#delete, the given string argument should not be interpreted as character classes, but rather as a substring. So, the following should also hold:

"abc".remove("cba") # => "abc"
"abc".remove("abc") # => ""

Active Support already has String#remove.

$ irb -r irb/completion --simple-prompt
>> require 'active_support/all'
=> true
>> "abcabc".remove("c")
=> "abab"
>> "abcabc".remove(/\zc/)
=> "abcabc"
>> "abcabc".remove(/c\z/)
=> "abcab"
>> "abcabc".remove(/\Aabc/)
=> "abc"

I assume that this makes sense; my only concern is that ruby people may
be confused as to what to use. We have lots of ways :)

.gsub
.sub
.delete
.tr
[] =

Actually, I think my biggest complaint is that .delete() would sound
so similar to .remove() - .delete(/regex_here/) might be nice too.

But anyway, to conclude, I concur with the threadstarter in principle,
I think that ruby should know what to do when either a string is
given as argument or a regex so I am in principle in favour of the
suggestion.

Yukihiro Matsumoto wrote:

I don't think it's worth adding which is easily done by sub/gsub.

Matz.

I think the problem goes beyond than that. String#delete takes a string as a parameter and natural thought progression would indicate that this acts as a substring delete. If String#delete took an array then its current behavior would make more sense.

matz (Yukihiro Matsumoto) wrote:

I don't think it's worth adding which is easily done by sub/gsub.

Easily done, yes, but Ruby being a very expressive language, the following two are not equally readable:

• "foo test bar".gsub(/ test/, '')
• "foo test bar".delete(/ test/)

Personally, I've never used String#delete in almost 10 years of Ruby coding. It will be much more useful a method (and still downwards compatible) if it shifts from String#delete([other_str]+) to String#delete([pattern|other_str]+).

matz (Yukihiro Matsumoto) wrote:

I don't think it's worth adding which is easily done by sub/gsub.

If put this way, it's easy to agree. But looking at it starting from String#delete, it feels annoying that String#delete doesn't accept a regular expression. If the above argument were taken to its full conclusion, it would mean that we could depreciate String#delete, because str.delete chars can be easily rewritten as str.gsub /[chars]/, ''.

String#count is a quite similar case, and even stronger, because in that case, it's not easy to replace it by sub/gsub. See feature .

The only other method on String that has a list of characters as an argument is String#tr. For that, I don't see how to add a regular expression as a parameter.

What about making the replacement of sub/gsub optional? (str.gsub(/re/, repl=''))
sub here might be considered as short for "subtract". 😆

The suggestion by @knu (Akinori MUSHA) is pretty cool if you think about it: Since both sub and gsub exist, the uncertainty whether only one or all occurrences are deleted is gone. Also, with this in place, delete could be deprecated IMO (and removed on Ruby 3 which will most likely break existing code in other places as well).

I now agree with https://bugs.ruby-lang.org/issues/12698#note-9. This issue can be considered to be along that line.