Create method using define_method with all sort of args?

ruby-talk
1

Hi all

I know that one can create new methods using define_method...

def new_method
end

is equivalent to

define_method(:new_method) do
end

def new_method(some_param)
end

is equivalent to

define_method(:new_method) do |some_param|
end

def new_method(some_param, *args)
end

is equivalent to

define_method(:new_method) do |some_param, *args|
end

But what's equivalent to...

def new_method(some_param, options = {}, *args)
end

??? Thanks for help.
Josh

···

--
Posted via http://www.ruby-forum.com/.

2

Oh yeah, forgot one...

def new_method(some_param, options = {}, *args, &block)
end

What's the equivalent to this...?

···

--
Posted via http://www.ruby-forum.com/.

3

define_method 'new_method' do |some_param, *argv|
   options, *argv = argv
   options ||= {}

   ...
end

a @ http://codeforpeople.com/

···

On Nov 22, 2007, at 2:59 AM, Joshua Muheim wrote:

But what's equivalent to...

def new_method(some_param, options = {}, *args)
end

--
share your knowledge. it's a way to achieve immortality.
h.h. the 14th dalai lama

4

You have to use a predefined function if you want to pass a block,
e.g,

class A
  def new_method1(somep, opts={}, *args, &block)
    p opts
  end
  private
  def _foo(somep, opts={}, *args, &block)
    p opts
  end
  public
  define_method(:new_method2, instance_method(:_foo))
end

Also, you can't pass an optional argument to a block, you'd have to
write something like...

class A
  define_method(:new_method3) { |somep, *args|
    opts = {}
    if args.length > 0 && args[0].class == Hash
      opts = args[0]
    end
    p opts
  }
end

Regards,
Jordan

···

On Nov 22, 6:52 am, Joshua Muheim <fo...@josh.ch> wrote:

What's the equivalent to this...?

5

Ara,

Isn't that dangerous in case new_method is called like:

a.new_method("a", other, args)

...where the optional 'option' arg is left out? It seems that your
version would consume the 'other' operand in that case. I think you'd
need to do something like I posted above to be safe.

Regards,
Joran

···

On Nov 23, 2:23 pm, "ara.t.howard" <ara.t.how...@gmail.com> wrote:

define_method 'new_method' do |some_param, *argv|
   options, *argv = argv
   options ||= {}

   ...
end

6

Your question implies to me that you think that if I define a method
like this:
  def foo( name, age=0, weight=170 )
    ...
  end
that I can then call it like this:
  foo( "Gavin", 175 ) # use default age.

In case I'm properly understanding you, then you should know that you
cannot do that. You can't 'skip' an optional argument and have other
optional or non-optional arguments later. So, by definition, the
'other' you use in your example is necessarily the second parameter to
the method, and thus satisfies the OPs desired functionality.

···

On Nov 23, 7:26 pm, MonkeeSage <MonkeeS...@gmail.com> wrote:

On Nov 23, 2:23 pm, "ara.t.howard" <ara.t.how...@gmail.com> wrote:

> define_method 'new_method' do |some_param, *argv|
> options, *argv = argv
> options ||= {}

> ...
> end

Ara,

Isn't that dangerous in case new_method is called like:

a.new_method("a", other, args)

...where the optional 'option' arg is left out? It seems that your
version would consume the 'other' operand in that case. I think you'd
need to do something like I posted above to be safe.

7

Err...my brain broke for a minute there (bad brain!), heh. Thanks for
the correction.

Regards,
Jordan

···

On Nov 23, 10:16 pm, Phrogz <phr...@mac.com> wrote:

In case I'm properly understanding you, then you should know that you
cannot do that.