Re: Enumerable::Enumerator#with_memo

On Wed, Jun 4, 2008 at 4:16 AM, Akinori MUSHA <[e-mail]> wrote:

> At Wed, 4 Jun 2008 03:38:48 +0900,
> David Flanagan wrote:
> > Akinori MUSHA wrote:
> > > Hi,
> > >
> > > Earlier today I added a new instance method named `with_memo' to
> > > Enumerable::Enumerator, but I'm not 100% sure if the name fits the
> > > function.
> >
> > What does the method do?  What's the use-case?
>
> From rdoc:
>
>    call-seq:
>      e.with_memo(obj) {|(*args), memo_obj| ... }
>      e.with_memo(obj)
>
>    Iterates the given block for each element with an arbitrary
>    object given, and returns the memo object.
>
>    If no block is given, returns an enumerator.
>
> For example:
>
>    class Array
>      def my_map
>        return with_memo([]) {|i, memo| memo << yield(i) }
>
>        # Instead of:
>        ary = []
>        each {|i| ary << yield(i) }
>        return ary
>
>        ## Using a throwaway variable within a block is fine, but
>        ## initializing it beforehand and returning it afterwards
>        ## outside the block is ugly.
>
>        # Or:
>        return inject([]) {|memo, i| memo << yield(i); memo }
>
>        ## This is fine but a bit less comprehensive and awkward
>        ## because you have to care about the return value when memo
>        ## is constant here.
>      end
>    end
>
>
>    a = [2,5,2,1,5,3,4,2,1,0]
>
>    # Remove element duplicates:
>    a.delete_if.with_memo({}) {|i, seen|
>      if seen.key?(i)
>        true
>      else
>        seen[i] = true
>        false
>      end
>    }
>
>    p a  # [2, 5, 1, 3, 4, 0]
>

>
>    ## The point is `seen' is only seen in the block, and there is no
>    ## leftover variable after the operation.
>    ##
>    ## Note that you cannot easily do the equivalent job with
>    ## inject().
>
>
> The method is for eliminating the typical need for a local variable to
> accumulate into or look up on from within a block.
>

So this looks like an iterating variant of the K combinator.  The name
with_memo really doesn't seem to get the meaning across, at least to me.

A lot of Rubyists use the name returning for the K combinator (due in part
to Rails)

http://weblog.jamisbuck.org/2006/10/27/mining-activesupport-object-returning

So returning might be another candidate for the name of this method,
although I think that it's clearer if the 'returned' object were moved to
the beginning of the block args rather than the end, following the lead of
Enumerable#inject:

e.each.returning({}) {|result, args...| ...}

I also note that the example in the rdoc has the disadvantage in that it
doesn't really use the result of the method invocation so it doesn't show
why the memo object should be returned.

-- 
Rick DeNatale

My blog on Ruby
http://talklikeaduck.denhaven2.com/