Issue #3715 has been updated by Marc-Andre Lafortune.


Hi,

On Thu, Aug 19, 2010 at 9:08 PM, Run Paint Run Run <redmine / ruby-lang.org> wrote:
> An enumerator is effectively immutable. 

Indeed, it would be better to specify the size (value or proc) at creation time. I suggest some possibilities further down. 

> I find the semantics of Enumerator#size's block argument confusing.

Maybe if it was called "count" instead which is also a verb, it would less confusing?

> It will often be the case that `obj.e(&b)` returns an object that responds to #size itself, allowing the general case of `obj.e(&b).size`.

I'm suggesting the block form just for completion's sake. The main gain is the lazy form without block and if it is deemed too confusing, the block form can definitely be left out.


On Fri, Aug 20, 2010 at 12:25 AM, Yukihiro Matsumoto <matz / ruby-lang.org> wrote:
> Hi,
>
> In message "Re: [ruby-core:31785] [Feature #3715] Enumerator#size and #size="
>  on Fri, 20 Aug 2010 10:08:44 +0900, Run Paint Run Run <redmine / ruby-lang.org> writes:
>
> We have discussed the issue in the ruby-dev before. The conclusion we
> had then was that:
>
> * it is nice to have a way to tell the number of items without
>  actual iteration.

Indeed

> * but Enumerator#size is not a good API, since not all enumerators
>  would have the way to tell the numbers of items. Permutations and
>  combinations are rather exceptions.

I'm not sure I follow. The builtin enumerators can tell the numbers of items (more than 70), except a very small number of exceptions (mainly the IO ones). Users programming their own enumerators would decide to specify a lazy counter if they choose to.

> * Enumerator#size= was worse, since it would make enumerators mutable.

Agreed, I should have thought about this better. Has the following possibility been discussed on the ruby-dev thread?

Enumerator.new's call sequence could be:

 *    Enumerator.new(obj, method = :each, *args)
 *    Enumerator.new(obj, count, method = :each, *args)
 *    Enumerator.new { |y| ... }
 *    Enumerator.new(count) { |y| ... }

where count is either a value or a Proc/method.

Similarly, to_enum's call sequence would be:

 *    obj.to_enum(method = :each, *args)
 *    obj.to_enum(count, method = :each, *args)

--
Marc-André

----------------------------------------
http://redmine.ruby-lang.org/issues/show/3715

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