Re: method names in 1.9

On Mon, Nov 12, 2007 at 11:00:55AM +0900, Jordi wrote:
> Summing it up:
>=20
> - Surprising or not, sending messages is not the same that calling
> methods in Ruby (there is  a real difference, see method_missing email
> of Matthew in this thread).
> - Honoring visibility is not the same that don't honoring it (obviously)
>=20
> So, we can have potentially 4 operations in Ruby 1.8.x:
>=20
> 1.- Call method honoring visibility
> 2.- Call method not honoring visibility
> 3.- Send message honoring visibility
> 4.- Send message not honoring visibility
>=20
> In Ruby 1.8.x ,  1 is implemented with "." and 4 is implemented with
> "send". AFAIK, 2 and 3 are not implemented.
> IMHO they don't need to!
> The difference between sending a message and calling a method is so
> subtle (in real Ruby implemented world) that most of the times can be
> used like the honoring/not honoring pair of the same operation.
>=20
> My personal opinion is make "." behave like "send" respect to
> method_missing. In other words, move "." from 1 to 3. Then kill the
> "call method" concept in Ruby. As I think that concept __is not
> intended to exist__ in the language anyway.
>=20
> Also I'd rename "send" for something more like "respond" as the object
> is not sending but receiving, but that is much more of a personal
> taste. :P
>=20
> --
> Jordi
>=20

I'm not sure I follow you here. It seems to me that the 'dot' is #3; in fac=
t,=20
it's the only real way to send a message that will fall back to method_miss=
ing=20
AND honor visibility. Here's the example:

  class Z
   public
    def pub() 'pub' end=20
   protected=20
    def prot() 'prot' end=20
   private
    def priv() 'priv' end
    def method_missing(msg, *args); "method_missing: #{msg}"; end
  end

  # PUBLIC METHODS
  test.pub
  # =3D=3D> "pub"
  test.send(:pub)
  # =3D=3D> "pub"
  test.method(:pub).call
  # =3D=3D> "pub"

  # PROTECTED METHODS
  test.prot
  # =3D=3D> "method_missing: prot"
  test.send(:prot)
  # =3D=3D> "prot"
  test.method(:prot).call
  # =3D=3D> "prot"

  # PRIVATE METHODS
  test.priv
  # =3D=3D> "method_missing: priv"
  test.send(:priv)
  # =3D=3D> "priv"
  test.method(:priv).call
  # =3D=3D> "priv"

  # METHODS THAT DON'T EXIST
  test.doesnt_exist
  # =3D=3D> "method_missing: doesnt_exist"
  test.send(:doesnt_exist)
  # =3D=3D> "method_missing: doesnt_exist"
  test.method(:doesnt_exist).call
  #! #<NameError: (eval):1:in `method': undefined method `doesnt_exist' for=
 class `Z'>

--
Matthew Boeh