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

Hi,

Quinn Dunkan wrote:
# > [e-mail] writes:
# > # >
# > # > I have to admit `filter' is not a best name; some proposed
`collect!',
# > # > but I don't feel it's not collecting anything.
# > # >
# > # >
# > # >                                matz.
# > #
# > # Would convert/convert! or transform/transform! be better that
# > collect/filter?
# > # Of course they could mean something like "to_s", but in iterator
context,
# > # I will not be confused.
# >
# > Well, filter once kind of made a sort of idiosyncratic sense in the
distant
# > past when it was a semi-common UNIX idiom for something like a
# > sed/awk/nroff stage in a pipeline.
#
# filter also makes sense to anyone who's used any language other than
smalltalk
# that has this function (except perl, of course, which uses 'grep'
apparently
# in an attempt to confuse shell programmers).  Uh, the non-destructive
version,
# I mean (that ruby calles `detect').

??? "this function" WRT Ruby? Then I think the previous but snipped ref to
Perl's map (versus grep here) was correct.

(I also don't understand the your last sentence above, since
detect returns just the first item meeting some condition.)

From a previous Matz note to a question I had posed about this:

========================================================
Enumerable's collect and select replace Perl's map/grep.

e.g.

  [1,2,3,4].collect{|x| x*2}            #=> [2,4,6,8]
  [1,2,3,4].select{|x| x % 2 == 0}      #=> [2,4]
========================================================

IIUC, then:

     filter (exists) == collect! (doesn't exist?)

# I think ruby's use of filter is non-intuitive and potentially dangerous
for
# everyone other than smalltalkers.  However, even though I too prefer map,
 I
# think collect isn't so bad, and it's certainly not going anywhere.  I
would
# also highly discourage convert, transform, or other non-standard
# not-invented-here stuff (smalltalk has a sort of excuse of being old :)

(Then smalltalk should know better by now :-)

# *Most* of the standard methods have nice behavior here: given a method
# `foo' I don't have to look in the docs to know what `foo!' will do.
# That's a big win, I think.

I hope this will eventually *always* be true (for alphabetically
named methods, in Ruby 3000)

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 though old code would still have the old
forms, at least the new code could be written consistently as if the
mutator-always-has-! convention was implemented from the start.  (And
either way, there would never be a case where a non-mutator method has
an !, AFAIK.)

map, map!

Conrad Schneiker
(This note is unofficial and subject to improvement without notice.)