[ruby-core:97487] [Ruby master Feature#16665] Add an Array#except_index method

Issue #16665 has been updated by alex_golubenko (Alex Golubenko).


Dan0042 (Daniel DeLorme) wrote in #note-9:
> That implementation would return an empty array for `[true,nil,nil].except_index(0)`
> Probably something a bit more like this:
> 
> ```ruby
>   @@undef = Object.new #using Qundef in C
>   def except_index(*indexes)
>     result = dup
>     indexes.each do |ind|
>       if ind.is_a?(Range)
>         ind.each{ |i| result[i] = @@undef }
>       else
>         result[ind] = @@undef
>       end
>     end
>     result.reject!{ |e| e == @@undef }
>     result
>   end
> ```
> 
> It's fun enough to implement, but is there a real-world use for this? I can't think of one. Usually if you want to remove elements from a list you'd use `reject`; having a list of indexes as an intermediary step seems like quite an unusual situation to me. Just because there's a positive counterpart doesn't mean we need a negative counterpart "for the sake of consistency".

Sure, the final implementation was:

``` ruby
  def except_index(*indicies)
    to_delete = Array.new(length)
    indicies.each do |ind|
      if ind.is_a?(Range)
        ind.each { |i| i > length ? break : to_delete[i] = true }
      else
        to_delete[ind] = true
      end
    end
    reject.with_index { |_, ind| to_delete[ind] }
  end
```

As I said in the first message, I proposed it mostly because I found that questions on StackOverflow about this realization helpful for many developers, so I thought mostly about it rather than just something opposite to `values_at` :)

I agree with you that this method would not the most popular but I also heard from developers, that they faced tricky challenges where this method could help. :)

----------------------------------------
Feature #16665: Add an Array#except_index method
https://bugs.ruby-lang.org/issues/16665#change-84635

* Author: alex_golubenko (Alex Golubenko)
* Status: Open
* Priority: Normal
----------------------------------------
The main idea is to implement a method that we can use to exclude elements from the array by their indices.

For example:

``` ruby
%w( a b c d e f).except_index(0, -1) 
=> ["b", "c", "d", "e"]

%w( a b c d e f g h ).except_index(0..1, 3, -2..-1)
=> ["c", "e", "f"]
```

I was meeting many questions on the StackOverflow about how to do such functionality also found many topics about it.
So I think it might a helpful addition.

I spent a few days finding the proper solution on Ruby that might be acceptable with integers and ranges(both positive and negative) and has good performance: 

```ruby
  def except_index(*indexes)
    indexes.each_with_object(dup) do |ind, obj|
      ind.is_a?(Range) ? ind.each { |i| obj[i] = false } : obj[ind] = false
    end.select(&:itself)
  end
```

As you can see it's have not the best readability so I think it's a good point to add a built-in method on C.



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

Unsubscribe: <mailto:[e-mail]?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>