[ruby-core:99380] [Ruby master Feature#17056] Array#index: Allow specifying start index to search like String#index does

[ruby-core:99380] [Ruby master Feature#17056] Array#index: Allow specifying start index to search like String#index does

[tyler]

Issue #17056 has been reported by TylerRick (Tyler Rick).

----------------------------------------
Feature #17056: Array#index: Allow specifying start index to search like String#index does
https://bugs.ruby-lang.org/issues/17056

* Author: TylerRick (Tyler Rick)
* Status: Open
* Priority: Normal
----------------------------------------
The docs for `String#index` say:

> If the second parameter is present, it specifies the position in the string to begin the search.

So you can do:

```ruby
> 'abcabc'.index('a',2)
#=> 3

'abcabc'.index('a')
#=> 0
```

I would expect to also be able to do:
```ruby
'abcabc'.chars.index('a')
#=> 0

'abcabc'.chars.index('a', 2)
ArgumentError: wrong number of arguments (given 2, expected 0..1)
from (pry):19:in `index'
```

After using this feature on strings, it is surprising to find that it is not available on arrays.

This would also give Ruby better parity with other programming languages that support this, like Python:

```python
>>> list('abcabc')
['a', 'b', 'c', 'a', 'b', 'c']
>>> list('abcabc').index('a')
0
>>> list('abcabc').index('a', 2)
3
```

Ideally, we would also add an optional end index arg as well, but `String#index` does not have one, so we could a separate proposal to add `end` to both methods at the same time.

Other languages that allow specifying both start and end indexes:
- [Python](https://docs.python.org/3/tutorial/datastructures.html)
- [C#](https://docs.microsoft.com/en-us/dotnet/api/system.array.indexof?view=netcore-3.1)
- ...



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

[ruby-core:99681] [Ruby master Feature#17056] Array#index: Allow specifying the position to start search as in String#index

[marcandre-ruby-core]

Issue #17056 has been updated by marcandre (Marc-Andre Lafortune).


👍

I'd like to have optional `start` and `stop` arguments for `find_index`, `find`, `bsearch` and `bsearch_index`.

As mentionned, a typical usecase is to repeat a lookup, but another one is to lookup a range of indices (e.g. which elements of a sorted array are between 10 and 20).

I've had to [iterate on the indices instead](https://github.com/whitequark/parser/blob/master/lib/parser/source/tree_rewriter/action.rb#L145-L148) but it is not elegant and is less performant.

----------------------------------------
Feature #17056: Array#index: Allow specifying the position to start search as in String#index
https://bugs.ruby-lang.org/issues/17056#change-87168

* Author: TylerRick (Tyler Rick)
* Status: Open
* Priority: Normal
----------------------------------------
I have a use case of finding the first matching line within a given section in a file. After finding the line number of the start of the section, I want to find the first match after that line.

My workaround for now is to use `with_index`:

```ruby
lines = pathname.read.lines
section_start_line = lines.index {|line| line.start_with?(/#* #{section_name}/) }
lines.index.with_index {|line, i| i > section_start_line && line.include?(sought) }
```

I'd like to do it in a more concise way using a feature of `Array#index` that I propose here, which is analogous to `String#index`.

If the second parameter of `String#index` is present, it specifies the position in the string to begin the search:

```ruby
'abcabc'.index('a') # => 0
'abcabc'.index('a',2) # => 3
```

I would expect to also be able to do:

```ruby
'abcabc'.chars.index('a') # => 0
'abcabc'.chars.index('a', 2)
```

Using such feature, I would be able to do:

```ruby
lines.index(sought, section_start_line)
```

This would give Ruby better parity with other programming languages like Python:

```python
>>> list('abcabc')
['a', 'b', 'c', 'a', 'b', 'c']
>>> list('abcabc').index('a')
0
>>> list('abcabc').index('a', 2)
3
```

## End index

We can further think of an optional parameter to specify the position to end the search. The following languages allow specifying both start and end indexes:

- [Python](https://docs.python.org/3/tutorial/datastructures.html)
- [C#](https://docs.microsoft.com/en-us/dotnet/api/system.array.indexof?view=netcore-3.1)

Ruby's `String#index` does not have one, so we could make a separate proposal to add `end` to both methods at the same time.



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

[ruby-core:99780] [Ruby master Feature#17056] Array#index: Allow specifying the position to start search as in String#index

[fatkodima123]

Issue #17056 has been updated by fatkodima (Dima Fatko).


I have implemented an `offset` parameter for `Array#index` - https://github.com/ruby/ruby/pull/3448
Will adjust to more methods if asked.

----------------------------------------
Feature #17056: Array#index: Allow specifying the position to start search as in String#index
https://bugs.ruby-lang.org/issues/17056#change-87297

* Author: TylerRick (Tyler Rick)
* Status: Open
* Priority: Normal
----------------------------------------
I have a use case of finding the first matching line within a given section in a file. After finding the line number of the start of the section, I want to find the first match after that line.

My workaround for now is to use `with_index`:

```ruby
lines = pathname.read.lines
section_start_line = lines.index {|line| line.start_with?(/#* #{section_name}/) }
lines.index.with_index {|line, i| i > section_start_line && line.include?(sought) }
```

I'd like to do it in a more concise way using a feature of `Array#index` that I propose here, which is analogous to `String#index`.

If the second parameter of `String#index` is present, it specifies the position in the string to begin the search:

```ruby
'abcabc'.index('a') # => 0
'abcabc'.index('a',2) # => 3
```

I would expect to also be able to do:

```ruby
'abcabc'.chars.index('a') # => 0
'abcabc'.chars.index('a', 2)
```

Using such feature, I would be able to do:

```ruby
lines.index(sought, section_start_line)
```

This would give Ruby better parity with other programming languages like Python:

```python
>>> list('abcabc')
['a', 'b', 'c', 'a', 'b', 'c']
>>> list('abcabc').index('a')
0
>>> list('abcabc').index('a', 2)
3
```

## End index

We can further think of an optional parameter to specify the position to end the search. The following languages allow specifying both start and end indexes:

- [Python](https://docs.python.org/3/tutorial/datastructures.html)
- [C#](https://docs.microsoft.com/en-us/dotnet/api/system.array.indexof?view=netcore-3.1)

Ruby's `String#index` does not have one, so we could make a separate proposal to add `end` to both methods at the same time.



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

[ruby-core:100126] [Ruby master Feature#17056] Array#index: Allow specifying the position to start search as in String#index

[matz]

Issue #17056 has been updated by matz (Yukihiro Matsumoto).


Accepted. 

How do you think about end index? Do we need it? If so, should we add end index to `String#index` as well?

Matz.


----------------------------------------
Feature #17056: Array#index: Allow specifying the position to start search as in String#index
https://bugs.ruby-lang.org/issues/17056#change-87695

* Author: TylerRick (Tyler Rick)
* Status: Open
* Priority: Normal
----------------------------------------
I have a use case of finding the first matching line within a given section in a file. After finding the line number of the start of the section, I want to find the first match after that line.

My workaround for now is to use `with_index`:

```ruby
lines = pathname.read.lines
section_start_line = lines.index {|line| line.start_with?(/#* #{section_name}/) }
lines.index.with_index {|line, i| i > section_start_line && line.include?(sought) }
```

I'd like to do it in a more concise way using a feature of `Array#index` that I propose here, which is analogous to `String#index`.

If the second parameter of `String#index` is present, it specifies the position in the string to begin the search:

```ruby
'abcabc'.index('a') # => 0
'abcabc'.index('a',2) # => 3
```

I would expect to also be able to do:

```ruby
'abcabc'.chars.index('a') # => 0
'abcabc'.chars.index('a', 2)
```

Using such feature, I would be able to do:

```ruby
lines.index(sought, section_start_line)
```

This would give Ruby better parity with other programming languages like Python:

```python
>>> list('abcabc')
['a', 'b', 'c', 'a', 'b', 'c']
>>> list('abcabc').index('a')
0
>>> list('abcabc').index('a', 2)
3
```

## End index

We can further think of an optional parameter to specify the position to end the search. The following languages allow specifying both start and end indexes:

- [Python](https://docs.python.org/3/tutorial/datastructures.html)
- [C#](https://docs.microsoft.com/en-us/dotnet/api/system.array.indexof?view=netcore-3.1)

Ruby's `String#index` does not have one, so we could make a separate proposal to add `end` to both methods at the same time.



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

[ruby-core:100134] [Ruby master Feature#17056] Array#index: Allow specifying the position to start search as in String#index

[eregontp]

Issue #17056 has been updated by Eregon (Benoit Daloze).


What if a block is given, and one want to use a start index? (for efficiency and not run the block for the first `start` elements).

`ary.index(start) { |i| ... }` seems confusing.

Probably keyword arguments are better:
`ary.index(from: start) { |i| ... }` or `ary.index(start: start) { |i| ... }`

Although personally I'm not convinced we need these complications.
One can do `'abcabc'.chars[2..].index('a') + 2` instead of `'abcabc'.chars.index('a', 2)`.
And the `[2..]` is quite cheap considering that arrays use copy-on-write.

It can also be done with `ary = 'abcabc'.chars; (2...ary.size).find { |i| ary[i] == 'a' }`.
That's a little bit more complicated, but it's also usable in many more situations than just `index`.
I would expect it's fairly rare to need a start offset, so I think there is no need for a shortcut.

----------------------------------------
Feature #17056: Array#index: Allow specifying the position to start search as in String#index
https://bugs.ruby-lang.org/issues/17056#change-87705

* Author: TylerRick (Tyler Rick)
* Status: Open
* Priority: Normal
----------------------------------------
I have a use case of finding the first matching line within a given section in a file. After finding the line number of the start of the section, I want to find the first match after that line.

My workaround for now is to use `with_index`:

```ruby
lines = pathname.read.lines
section_start_line = lines.index {|line| line.start_with?(/#* #{section_name}/) }
lines.index.with_index {|line, i| i > section_start_line && line.include?(sought) }
```

I'd like to do it in a more concise way using a feature of `Array#index` that I propose here, which is analogous to `String#index`.

If the second parameter of `String#index` is present, it specifies the position in the string to begin the search:

```ruby
'abcabc'.index('a') # => 0
'abcabc'.index('a',2) # => 3
```

I would expect to also be able to do:

```ruby
'abcabc'.chars.index('a') # => 0
'abcabc'.chars.index('a', 2)
```

Using such feature, I would be able to do:

```ruby
lines.index(sought, section_start_line)
```

This would give Ruby better parity with other programming languages like Python:

```python
>>> list('abcabc')
['a', 'b', 'c', 'a', 'b', 'c']
>>> list('abcabc').index('a')
0
>>> list('abcabc').index('a', 2)
3
```

## End index

We can further think of an optional parameter to specify the position to end the search. The following languages allow specifying both start and end indexes:

- [Python](https://docs.python.org/3/tutorial/datastructures.html)
- [C#](https://docs.microsoft.com/en-us/dotnet/api/system.array.indexof?view=netcore-3.1)

Ruby's `String#index` does not have one, so we could make a separate proposal to add `end` to both methods at the same time.



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

[ruby-core:100138] [Ruby master Feature#17056] Array#index: Allow specifying the position to start search as in String#index

[fatkodima123]

Issue #17056 has been updated by fatkodima (Dima Fatko).



Eregon (Benoit Daloze) wrote in #note-7:
> What if a block is given, and one want to use a start index? (for efficiency and not run the block for the first `start` elements).
> 
> `ary.index(start) { |i| ... }` seems confusing.
> 
> Probably keyword arguments are better:
> `ary.index(from: start) { |i| ... }` or `ary.index(start: start) { |i| ... }`
ary.index(from: start) { |i| ... } or ary.index(start: start) { |i| ... }

Agreed.

Eregon (Benoit Daloze) wrote in #note-7:
> 
> It can also be done with `ary = 'abcabc'.chars; (2...ary.size).find { |i| ary[i] == 'a' }`.
> That's a little bit more complicated, but it's also usable in many more situations than just `index`.
> I would expect it's fairly rare to need a start offset, so I think there is no need for a shortcut.

Personally, I had a need for start index a couple of times. What I have seen most of the times, developers just slice an array (allocating a new array; is there a CoW here?) in needed range. And it will be convenient to have a start index argument. And it will be consistent with `String#index`. 

matz (Yukihiro Matsumoto) wrote in #note-6:
> Accepted. 
> 
> How do you think about end index? Do we need it? If so, should we add end index to `String#index` as well?
> 
> Matz.

As for end index, I think this is truly would be rarely needed and can be simulated with something like `...with_index ... { |..., index| ... break if index > end_index ... }`

As @marcandre pointed out, other methods would probably also benefit from such method arguments, but to avoid updating all of them, I would prefer just add start index argument to `Array#index`, for consistency with `String#index`, and it can be used in user code for emulating other methods, like
```ruby
# find with start index
index = array.index(start: 10) { |e| e % 10 == 0 }
item = array[index] if index
```

----------------------------------------
Feature #17056: Array#index: Allow specifying the position to start search as in String#index
https://bugs.ruby-lang.org/issues/17056#change-87709

* Author: TylerRick (Tyler Rick)
* Status: Open
* Priority: Normal
----------------------------------------
I have a use case of finding the first matching line within a given section in a file. After finding the line number of the start of the section, I want to find the first match after that line.

My workaround for now is to use `with_index`:

```ruby
lines = pathname.read.lines
section_start_line = lines.index {|line| line.start_with?(/#* #{section_name}/) }
lines.index.with_index {|line, i| i > section_start_line && line.include?(sought) }
```

I'd like to do it in a more concise way using a feature of `Array#index` that I propose here, which is analogous to `String#index`.

If the second parameter of `String#index` is present, it specifies the position in the string to begin the search:

```ruby
'abcabc'.index('a') # => 0
'abcabc'.index('a',2) # => 3
```

I would expect to also be able to do:

```ruby
'abcabc'.chars.index('a') # => 0
'abcabc'.chars.index('a', 2)
```

Using such feature, I would be able to do:

```ruby
lines.index(sought, section_start_line)
```

This would give Ruby better parity with other programming languages like Python:

```python
>>> list('abcabc')
['a', 'b', 'c', 'a', 'b', 'c']
>>> list('abcabc').index('a')
0
>>> list('abcabc').index('a', 2)
3
```

## End index

We can further think of an optional parameter to specify the position to end the search. The following languages allow specifying both start and end indexes:

- [Python](https://docs.python.org/3/tutorial/datastructures.html)
- [C#](https://docs.microsoft.com/en-us/dotnet/api/system.array.indexof?view=netcore-3.1)

Ruby's `String#index` does not have one, so we could make a separate proposal to add `end` to both methods at the same time.



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

[ruby-core:100145] [Ruby master Feature#17056] Array#index: Allow specifying the position to start search as in String#index

[mame]

Issue #17056 has been updated by mame (Yusuke Endoh).


Hi, 

fatkodima (Dima Fatko) wrote in #note-8:
> to avoid updating all of them, I would prefer just add start index argument to `Array#index`, for consistency with `String#index`,

I agree with your approach. However, your PR changes not only `Array#index` but also `Array#find_index`. This brings another inconsistency: `Enumerable#find_index` does not accept "start", but `Array#find_index` does.

We discussed this ticket at today's dev-meeting, and @ko1 proposed removing `Array#find_index` so that `ary.find_index` invokes `Enumerable#find_index` instead of keeping it as an alias to `Array#index`, and matz agreed with the removal.

----------------------------------------
Feature #17056: Array#index: Allow specifying the position to start search as in String#index
https://bugs.ruby-lang.org/issues/17056#change-87720

* Author: TylerRick (Tyler Rick)
* Status: Open
* Priority: Normal
----------------------------------------
I have a use case of finding the first matching line within a given section in a file. After finding the line number of the start of the section, I want to find the first match after that line.

My workaround for now is to use `with_index`:

```ruby
lines = pathname.read.lines
section_start_line = lines.index {|line| line.start_with?(/#* #{section_name}/) }
lines.index.with_index {|line, i| i > section_start_line && line.include?(sought) }
```

I'd like to do it in a more concise way using a feature of `Array#index` that I propose here, which is analogous to `String#index`.

If the second parameter of `String#index` is present, it specifies the position in the string to begin the search:

```ruby
'abcabc'.index('a') # => 0
'abcabc'.index('a',2) # => 3
```

I would expect to also be able to do:

```ruby
'abcabc'.chars.index('a') # => 0
'abcabc'.chars.index('a', 2)
```

Using such feature, I would be able to do:

```ruby
lines.index(sought, section_start_line)
```

This would give Ruby better parity with other programming languages like Python:

```python
>>> list('abcabc')
['a', 'b', 'c', 'a', 'b', 'c']
>>> list('abcabc').index('a')
0
>>> list('abcabc').index('a', 2)
3
```

## End index

We can further think of an optional parameter to specify the position to end the search. The following languages allow specifying both start and end indexes:

- [Python](https://docs.python.org/3/tutorial/datastructures.html)
- [C#](https://docs.microsoft.com/en-us/dotnet/api/system.array.indexof?view=netcore-3.1)

Ruby's `String#index` does not have one, so we could make a separate proposal to add `end` to both methods at the same time.



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

[ruby-core:124861] [Ruby Feature#17056] Array#index: Allow specifying the position to start search as in String#index

[Earlopain (Earlopain _) via ruby-core]

Issue #17056 has been updated by Earlopain (Earlopain _).


I often use the offset parameter from `String#byteindex` and was a bit surprised there is not yet something for arrays. It's a bit unfortunate with the ambiguity between block/noblock usage but a keyword argument `offset` seems like a perfectly fine solution for that.

----------------------------------------
Feature #17056: Array#index: Allow specifying the position to start search as in String#index
https://bugs.ruby-lang.org/issues/17056#change-116515

* Author: TylerRick (Tyler Rick)
* Status: Open
----------------------------------------
I have a use case of finding the first matching line within a given section in a file. After finding the line number of the start of the section, I want to find the first match after that line.

My workaround for now is to use `with_index`:

```ruby
lines = pathname.read.lines
section_start_line = lines.index {|line| line.start_with?(/#* #{section_name}/) }
lines.index.with_index {|line, i| i > section_start_line && line.include?(sought) }
```

I'd like to do it in a more concise way using a feature of `Array#index` that I propose here, which is analogous to `String#index`.

If the second parameter of `String#index` is present, it specifies the position in the string to begin the search:

```ruby
'abcabc'.index('a') # => 0
'abcabc'.index('a',2) # => 3
```

I would expect to also be able to do:

```ruby
'abcabc'.chars.index('a') # => 0
'abcabc'.chars.index('a', 2)
```

Using such feature, I would be able to do:

```ruby
lines.index(sought, section_start_line)
```

This would give Ruby better parity with other programming languages like Python:

```python
>>> list('abcabc')
['a', 'b', 'c', 'a', 'b', 'c']
>>> list('abcabc').index('a')
0
>>> list('abcabc').index('a', 2)
3
```

## End index

We can further think of an optional parameter to specify the position to end the search. The following languages allow specifying both start and end indexes:

- [Python](https://docs.python.org/3/tutorial/datastructures.html)
- [C#](https://docs.microsoft.com/en-us/dotnet/api/system.array.indexof?view=netcore-3.1)

Ruby's `String#index` does not have one, so we could make a separate proposal to add `end` to both methods at the same time.



-- 
https://bugs.ruby-lang.org/
______________________________________________
 ruby-core mailing list -- ruby-core@ml.ruby-lang.org
 To unsubscribe send an email to ruby-core-leave@ml.ruby-lang.org
 ruby-core info -- https://ml.ruby-lang.org/mailman3/lists/ruby-core.ml.ruby-lang.org/