[ruby-talk:02439] Re: Function of Array.filter surprises me

Since I started this thread I feel I have some responsibility to 
give finishing touch to it. :=)

> [ Conrad ]
> # Meanwhile, I would like to see *every* mutator method without an !-form have
> # a standard alias to the corresponding !-form in the mean time. Then even
> 
> Even though I think ruby already has too many aliases, this makes some sense,
> but only for methods for which a mutating version would be useful.  But then,
> I don't think ruby's `filter' mutation is useful, so who am I to judge?

I can't agree that there's too many mutators, since those give you the 
possibility to write your code to be self-descriptive. Many times
there just is need for different names for same operation in different
contexts. My opinion applies as long as current alias count doesn't explode.

But I do agree we need simple rules for !-form (among others). There's
two facets: mutating, destructing. I'm not sure if we should make this separation at the code level but it's good to know that not all mutating methods are
destructive. For example: array.sort! hardly loses information 
(unless it's coded in the order of the array's content :).


Matz:
> > I'm not going to change `filter' behavior, so there would not be
> > `filter!'.  But I may declare it deprecated in the future if I find
> > better name.

Good idea, indeed! I like your way to freeze things so that they can work
but at the same time make a promise for better future (tm). :)

> > Agreed.  The reason for collect/filter is that I felt
> > 
> >   collect values in place
> > 
> > is weird, comparing e.g.
> > 
> >   sort elements in place
> >   substitute string in place
> > 
> > But if you guys feel OK for collect!/map!, I sould seriously consider
> > renaming `filter'.
> 
> Then don't think of it as `collect'!  Think of it as `apply operation to each
> element of the list'.  Coming from functional land, I think of map / collect
> as `for loop' (or rather, `for loop' as `map').  Maybe this is just a sign
> that collect isn't the best name :)

Ok. Here I have to say you both (Matz and Conrad) are right on my opinion.
I except the functions to have following behaviour:

p ['a', 'b', 'c', 'a', 'd'].collect{|i| i=='a'}  # => ['a', 'a']
p ['a', 'b', 'c', 'a', 'd'].map    {|i| i=='a'}  # => [true, false, false,
                                                       true, false ]

I expect filter to have same functionality as above collect.
So I propose Matz should seriously consider to rename filter and whether
and under what names to introduce collect and some map variant.

> But I do agree with you that we should avoid semantic weirdness.  But
> consistency always wins, at least for me.

I agree, totally! In about every case we should have both method and method!.
And as I said in other mail, method! is more important since method could be
usually coded as thing.dup.method!.

But it's not so obvious it would work everywhere. thing.dupping makes me
wonder what are the semantics of the dup, especially whether it does shallow,
deeper or deep copy.

In any case, Matz, whatever path you choose, let it be as systematical 
as possible.

I mean, that while nowadays most of the people assume thing.delete to really
modify something let them do it in obvious way thing.delete! . Newcomers
are totally right with their possible belief thing.delete to make a 
copy first.