In message "[ruby-talk:00465] Re: Now another totally different ;-)"
    on 99/07/12, Clemens Hintze <c.hintze / gmx.net> writes:
>>I'm very sorry. I understand your request now (as far as I believe). 
>
>Ahem?!? You are sorry for understanding my request now?? ;-))))

Oops! I would say "I'm very sorry for misunderstatnding. But ..." :-(

>>>1. Your class is tricky coded. It seems to be a open-end enumeration.
>>>   So you cannot simply include Enumerable, as that module awaits
>>>   self-determinish enumerations. Here no method of Enumerable would
>>>   work well, you have to break that enumeration manually by break.
>>>   These are not the conditions Enumerable would like to use the
>>>   `each' method.
>>
>>But IO<Enumerable has the same characteristics. IO is essentially a 
>>nondeterministic class. 
>
>I hope not so ;-) I hope, that the IO stream would end some time
>with a EOF. So that would make it a deterministic one, wouldn't it?

It is true too, however, we can't determine before EOF whether a
stream eventually reaches end or not.  So, IO sometimes behave as same
as my example of Trajectory#each, which never finish itself. In this
sense, even IO#collect or IO#collect might not finish. 

In [ruby-talk:00442]
>3. I have not thought very deeply, but I would think, that every class
>   which provides an `each' method, would define a certain kind of
>   sequence then! I don't believe that there would be a class, which
>   would deliver different sequences during two successive calls of
>   e.g. Enumeration#collect. That means:

All I claim is a never-ending series should be allowed having the
right to be a instance of Sequence.  

>[exellent examples of code deleted...]

(it might be dirty :-)

>>Well, This solution may be not ellegant. 
>
>I fear, that I must agree. It is tricky, but I think a little
>overblasted for my simple and humble desire ;-)

Well, another solution is letting the external iterator be able to be
given steping proc, which may require big change of the syntax:

  for i in from..to step lambda{|i| i+0.2}
    ...  
  end

or 

  for i in (from..to).with_step{|i| i+0.2}
    ...
  end

-- gotoken