From: David MacMahon <davidm@...>
Date: 2013-03-08T15:44:59+09:00
Subject: [ruby-core:53217] Re: [ruby-trunk - Feature #8046] allow Object#extend to take a block


On Mar 7, 2013, at 6:53 PM, charliesome (Charlie Somerville) wrote:

> There are two ways to do this
> 
>    def extend(&bk)
>      singleton_class.class_eval(&bk)
>    end
> 
> or
> 
>    def extend(&bk)
>      singleton_class.send(:include, Module.new(&bk))
>    end

At the risk of being overly pedantic, since we're talking about Object#extend, I think it would be more like:

  def extend(*modules, &bk)
    # extend singleton_class with modules, if any
    singleton_class.class_eval(&bk) if bk
  end

or

  def extend(module=nil, &bk)
    # extend singleton_class with modules, if any
    singleton_class.send(:include, Module.new(&bk)) if bk
  end

Which raises another question: what would be the order of extending if #extend is passed one or more modules *and* given a block?  IOW, should the passed in module(s) be included first thereby giving the block the opportunity to override them or vice versa (or should this be explicitly disallowed)?  I guess I'd favor the first way (include module(s) first, then block can override).

On the original question I tend to agree with @phluid61 that it would be preferable to avoid inserting an anonymous Module in the singleton_class's ancestors.  Would having the anonymous module provide any advantage over not having it?

Thanks,
Dave

P.S.  Why "singleton_class.send(:include, Module.new(&bk))" instead of just "singleton_class.include(Module.new(&bk))"?  Are these somehow not equivalent?