Just a random thought that I think was inspired by several people on
the list asking about getting the name of the method from within the
method - why don't we have Method.new? In other words, what if this:
def foo(x, y=1)
end
Was the equivalent of this?
x = Method.new(:name => 'foo', :parameters => ['x', 'y'], :defaults =>
{'y' => 1})
Object.include(x) # or bind(x) or something
Similar to an UnboundMethod I suppose, but with more options. Wouldn't
it be easier to get method metadata with this approach? And give
programmers the ability to associate any methods with any class or
module?
class Bar
def foo(x, y=1)
p method(:foo).metadata # => @name => 'foo', @parameters =>
['x','y'], :defaults => {'y' => 1})
end
end
Or is this totally stupid?
If this has been discussed before just point me to the thread.
On 04/02/2009, at 5:20 PM, Daniel Berger <djberg96@gmail.com> wrote:
Hi,
Just a random thought that I think was inspired by several people on
the list asking about getting the name of the method from within the
method - why don't we have Method.new? In other words, what if this:
def foo(x, y=1)
end
Was the equivalent of this?
x = Method.new(:name => 'foo', :parameters => ['x', 'y'], :defaults =>
{'y' => 1})
Object.include(x) # or bind(x) or something
Similar to an UnboundMethod I suppose, but with more options. Wouldn't
it be easier to get method metadata with this approach? And give
programmers the ability to associate any methods with any class or
module?
class Bar
def foo(x, y=1)
p method(:foo).metadata # => @name => 'foo', @parameters =>
['x','y'], :defaults => {'y' => 1})
end
end
Or is this totally stupid?
If this has been discussed before just point me to the thread.
Not stupid at all. I would even suggest that we do not bind methods to
object's class anymore.
Class is just a convenient? place for method err forget that word,
behavior lookup after all.
a = def a *args, &blk; whatever end
shall yield exactly the same as
a = lambda{ |*args,&blk| whatever }
But than a could implement the whole API above.
In other words, either Proc or Method has to die, one is redundant!
object.define_method a
object.extend a
Now the language implementors will probably just kill me, but that is
a risk I have to take ;).
R.
···
On Wed, Feb 4, 2009 at 7:20 AM, Daniel Berger <djberg96@gmail.com> wrote:
Hi,
Just a random thought that I think was inspired by several people on
the list asking about getting the name of the method from within the
method - why don't we have Method.new? In other words, what if this:
def foo(x, y=1)
end
Was the equivalent of this?
x = Method.new(:name => 'foo', :parameters => ['x', 'y'], :defaults =>
{'y' => 1})
Object.include(x) # or bind(x) or something
Similar to an UnboundMethod I suppose, but with more options. Wouldn't
it be easier to get method metadata with this approach? And give
programmers the ability to associate any methods with any class or
module?
class Bar
def foo(x, y=1)
p method(:foo).metadata # => @name => 'foo', @parameters =>
['x','y'], :defaults => {'y' => 1})
end
end
Or is this totally stupid?
If this has been discussed before just point me to the thread.
Regards,
Dan
--
It is change, continuing change, inevitable change, that is the
dominant factor in society today. No sensible decision can be made any
longer without taking into account not only the world as it is, but
the world as it will be ... ~ Isaac Asimov
In message "Re: Method.new - why not?" on Wed, 4 Feb 2009 15:20:21 +0900, Daniel Berger <djberg96@gmail.com> writes:
Just a random thought that I think was inspired by several people on
the list asking about getting the name of the method from within the
method - why don't we have Method.new? In other words, what if this:
def foo(x, y=1)
end
Was the equivalent of this?
x = Method.new(:name => 'foo', :parameters => ['x', 'y'], :defaults =>
{'y' => 1})
Object.include(x) # or bind(x) or something
Or is this totally stupid?
I don't think the idea itself is stupid at all, but I am afraid that
it doesn't go quite well with Ruby's Lisp-2 semantics. That idea
would shine better in Lisp-1-ish languages like Scheme or Python.
On 05/02/2009, at 2:29 AM, Yukihiro Matsumoto <matz@ruby-lang.org> wrote:
Hi,
In message "Re: Method.new - why not?" > on Wed, 4 Feb 2009 15:20:21 +0900, Daniel Berger <djberg96@gmail.com > > writes:
>Just a random thought that I think was inspired by several people on
>the list asking about getting the name of the method from within the
>method - why don't we have Method.new? In other words, what if this:
>
>def foo(x, y=1)
>end
>
>Was the equivalent of this?
>
>x = Method.new(:name => 'foo', :parameters => ['x', 'y'], :defaults =>
>{'y' => 1})
>Object.include(x) # or bind(x) or something
>Or is this totally stupid?
I don't think the idea itself is stupid at all, but I am afraid that
it doesn't go quite well with Ruby's Lisp-2 semantics. That idea
would shine better in Lisp-1-ish languages like Scheme or Python.