[ruby-core:32461] Re: [ruby-core:32453] Why doesn’t Enumerable define a #last method?

On 17 September 2010 12:19, Nikolai Weibull <[e-mail]> wrote:
> Hi!
>
> Why doesn=92t Enumerable define a #last method that=92s analogous to #fir=
st?

Well, I believe #last will always be very inefficient.

In fact, if you do not improve Enumerator, you will have to iterate
over all the elements, which would be almost equivalent to:
  enum.to_a.last(n)
except you would not need to take all the elements before in the
Array, but you would iterate over them (and since GC will likely not
run during the iteration, you will anyway have all the elements in
memory, the only difference is then the Array containing them).

A few months ago, somebody asked how to efficiently get the last n
lines from a text file.
Enumerable#last, could not be efficient, except if it is implemented
specially for String#lines, which means it should then be implemented
for each Enumerator possible, which is very much work I think.

However, you probably saw that Marc-Andre proposed a way to
efficiently calculate the size of an Enumerator:
http://redmine.ruby-lang.org/issues/show/3715
And he did indeed implemented #size for every Enumerator which size
calculation could be improved.

But #size seems easier than #last, no?
The subject is rather interesting, and it would be nice to see one day
a #reverse_each which can actually efficiently iterate in the reverse
order (and that would greatly help your #last, it would then just be a
shortcut for #reverse_each.first(n).reverse).

(The current documentation states: "Builds a temporary array and
traverses that array in reverse order."
Actually, the C implementation does #to_a and just yield in reverse order)

As others mentioned, it just does not make sense to want the "end" of
some Enumerator, like the custom and the infinite ones (while it
always make sense to have the beginning of them).

So, I think it is normal we get edge cases for infinite iterators
(which would then loop forever), and for the custom ones (which would
then use the inefficient but the only way by calling #to_a).

I am against returning nil, because that is making bad code and it is
totally useless in this context.
I prefer having a infinite loop, which is logical on infinite enumerators.

Sorry for this (too) long message, but hopefully there are some
interesting points which should be discussed further.

Regards,
B.D.