Issue #6727 has been updated by duckinator (Nick Markwell).


> @duckinator: Could you show us a real use case for Array#rest ?

I'll add another update in a bit with examples.


Marc-Andre:

You raised some good objections. If you don't think I answer all of them let me know, because I want this added, but I want it added properly.


> How is the result of dropping the first element not clear? Drop the first element and give me the rest...

Sorry, that was bad phrasing on my part. I meant it's not as clear as it *could be.*

> It would be interesting to see examples in actual code / gems. In the whole of Rails' code, I found exactly *one* case of `array[1..-1]`

I'll look around for some and add another update in a bit.

> "rest" from what?

The "rest" of the Array, since it goes with "first." An alternative name would be "tail," but it's usually head/tail so may lead people to expect "head" to work. It's also serving the same purpose as "cdr," but this isn't lisp, and that name's about as clear as mud to anyone who's not used a lisp dialect before. Do you have a name you feel would fit better than "rest"?

> Is the distinction between `[].rest == nil` and `[1].rest == []` useful? How/when? In particular, in what kind of case would the *only* difference between `arr.drop(1)` and `arr.rest` be useful?

To be honest, I'm not entirely sure. That was probably an issue not worth raising. Which return value is really "expected" is rather iffy because some of the languages I have seen that implement a similar function are languages that implement their equivalent of nil as an empty list. If nobody else (@programble, @tsion?) can come up with a need for `[].rest == nil`, I'd be more than willing to let it return an empty list if that turned out to be simpler.

> The '_' part was, but not the pattern. When you deal with the first part of the array, the pattern can be very useful.

Alright. I apologize if I came off as rude: my (rather foolish, admittedly) assumption was that you meant that as a way to *only* get `rest`, and that came across as a bit odd, to put it mildly.



Thomas:

> Rather then haphazard method additions in this area I still think a better approach would be a common mixin.

I did not know about Indexable, thanks for mentioning it. I agree that using a common mixin would be a far better approach. Will take a closer look at that after I have lunch.
----------------------------------------
Feature #6727: Add Array#rest (with implementation)
https://bugs.ruby-lang.org/issues/6727#change-28013

Author: duckinator (Nick Markwell)
Status: Assigned
Priority: Normal
Assignee: matz (Yukihiro Matsumoto)
Category: 
Target version: 


=begin
I run into many instances where I end up using (({arr[1..-1]})), so I decided to add (({arr.rest})) to make that a bit less hideous.

Branch on github: ((<URL:https://github.com/duckinator/ruby/compare/feature/array_rest>))

Patch: ((<URL:https://github.com/duckinator/ruby/compare/feature/array_rest.patch>))

Diff: ((<URL:https://github.com/duckinator/ruby/compare/feature/array_rest.diff>))
=end


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