On Mon, 12 Jul 1999, you wrote:
>Hello, there.

Hello again,

>
>In message "[ruby-talk:00442] Re: Now another totally different ;-)"
>    on 99/07/09, Clemens Hintze <c.hintze / gmx.net> writes:
>
>|But I have another opinion! May I explain my reasons?
>
>Sure.  In summary, I have to admit I treat Enumerable as ordered
>sequence for some methods, e.g. index, sort, etc.  So I can agree with
>adding a number indexing method to Enumerable.  But not [], because it
>is used by Hash in different meaning.  I want methods sharing same
>name also share same conceptual meaning, at least among standard class
>library.

I know I seem to be the devil's advocat, but... 

You have done the same for e.g. `Hash#include?'. This method works
also different than `Array#include?' or `Enumerable#include?'.

Furthermore you have also a method `Hash#member?' which is directly
coming from Enumerable, and did not work at all (at least I have not
found a way to bring it to do some interesting)! Same for `index'.

So why do not the same for `[]'. In Perl we have different operators
for Array and Hash: `[]' and `{}'. I don't like it!

And whether it has a different meaning or not, depends from your
point of view! You may see it as: The method `[]' delivers the
element stored under the index. Array elements are indexed by its
position, Hash elements by its key, etc. So `[]' works equal to both
classes. Or what do you think?

>
>|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:
>|	c = <any class import Enumeration>::new
>|	# ... fill c
>|        a1 = c.collect{|e| e}
>|	a2 = c.collect{|e| e}
>|	a1 == a2
>
>File, for example.

Ah?!? I have to admit, that I have not thought of it! But that is
also a good example of behaving of methods in different classes.
Normally I would expect, that `collect' works ever and ever again
like in Array.

[...]
>                                                matz.

\cle