Forum: Ruby Dumb question: in documentation, why Object#method, and not

Announcement (2017-05-07): www.ruby-forum.com is now read-only since I unfortunately do not have the time to support and maintain the forum any more. Please see rubyonrails.org/community and ruby-lang.org/en/community for other Rails- und Ruby-related community platforms.
elf (Guest)
on 2005-11-30 21:21
(Received via mailing list)
I keep seeing this syntax in documentation: Object#method, but in actual
use sending a message to an object is usually

        object = Object.new
        object.method

Is this just to emphasize that method() operates on an instance of
Object and not the class Object?

                Elf
marcel (Guest)
on 2005-11-30 21:21
(Received via mailing list)
On Thu, Dec 01, 2005 at 04:17:30AM +0900, Elf M. Sternberg wrote:
> I keep seeing this syntax in documentation: Object#method, but in actual
> use sending a message to an object is usually
>
>         object = Object.new
>         object.method
>
> Is this just to emphasize that method() operates on an instance of
> Object and not the class Object?

The # is a naming convention.

Class#method means method is an instance method.
Class::method means method is a class method.

For example, do

  ri IO.read

There is IO::read and IO#read.

marcel
bob_showalter (Guest)
on 2005-11-30 21:25
(Received via mailing list)
Elf M. Sternberg wrote:
> I keep seeing this syntax in documentation: Object#method, but in actual
> use sending a message to an object is usually
>
>         object = Object.new
>         object.method
>
> Is this just to emphasize that method() operates on an instance of
> Object and not the class Object?

Yes.
jeff (Guest)
on 2005-11-30 21:25
(Received via mailing list)
Elf M. Sternberg wrote:
> I keep seeing this syntax in documentation: Object#method, but in actual
> use sending a message to an object is usually
>
>         object = Object.new
>         object.method
>
> Is this just to emphasize that method() operates on an instance of
> Object and not the class Object?

Yes.
transfire (Guest)
on 2005-11-30 21:29
(Received via mailing list)
Yes. ;-)
halostatue (Guest)
on 2005-11-30 21:29
(Received via mailing list)
On 11/30/05, Elf M. Sternberg <removed_email_address@domain.invalid> wrote:
> I keep seeing this syntax in documentation: Object#method, but in actual
> use sending a message to an object is usually
>
>         object = Object.new
>         object.method
>
> Is this just to emphasize that method() operates on an instance of
> Object and not the class Object?

As others have said, yes. As I understand it, though, it's a
smalltalkism.

-austin
dblack (Guest)
on 2005-11-30 21:33
(Received via mailing list)
Hi --

On Thu, 1 Dec 2005, Marcel Molina Jr. wrote:

> The # is a naming convention.
>
> Class#method means method is an instance method.
> Class::method means method is a class method.
>
> For example, do
>
>  ri IO.read
>
> There is IO::read and IO#read.

Interesting -- I never picked up on ri's use of :: in preference to
the dot.  I personally use Class.method for class methods (indeed for
any singleton method).


David
transfire (Guest)
on 2005-11-30 21:33
(Received via mailing list)
Notice that "Object" in "Object#method" is capitalized. We're talking
about a class here not an instance. So if you were to say Object.method
you'd be refering to an instance method of the class itself --generally
called a _class method_, as opposed to an instance method defined by
the class. It's tricky because its relative --a class is itself an
instance of Class.

HTH,
T.
Daniel S. (Guest)
on 2005-11-30 22:38
(Received via mailing list)
David A. Black wrote:
>>>
>>  ri IO.read
>>
>> There is IO::read and IO#read.
>
> Interesting -- I never picked up on ri's use of :: in preference to
> the dot.  I personally use Class.method for class methods (indeed for
> any singleton method).

I believe that to be the convention, too.

   Klass.method         <- Class method
   Klass#method         <- Instance method
   Klass::FOO           <- Class constant
   Klass::AnotherKlass  <- Class constant (class or module)
justin.w.smith (Guest)
on 2005-12-01 17:41
(Received via mailing list)
Hmm...so Class is an instance of itself?
mental (Guest)
on 2005-12-01 17:45
(Received via mailing list)
On Fri, 2005-12-02 at 00:37 +0900, jwesley wrote:
> Hmm...so Class is an instance of itself?

Yep.

Class.class # => Class

-mental
dblack (Guest)
on 2005-12-01 17:49
(Received via mailing list)
Hi --

On Fri, 2 Dec 2005, jwesley wrote:

> Hmm...so Class is an instance of itself?

Yes.  And Object is a Class, and Class is an Object :-)  Ruby
object-space chases its own tail a bit at the top of the hierarchy,
for the sake of bootstrapping itself into existence.


David
gb l. (Guest)
on 2009-07-28 22:17
elf wrote:
> I keep seeing this syntax in documentation: Object#method, but in actual
> use sending a message to an object is usually
>
>         object = Object.new
>         object.method
>
> Is this just to emphasize that method() operates on an instance of
> Object and not the class Object?
>
>                 Elf

Where is this documented? I can't find it in any book...and searching
google on Ruby object#method doesn't lead to an explanation of this. You
get reams of hits  using object#method syntax but not where it comes
from.
James C. (Guest)
on 2009-07-28 22:23
(Received via mailing list)
2009/7/28 Gary L. <removed_email_address@domain.invalid>

> >                 Elf
>
> Where is this documented? I can't find it in any book...and searching
> google on Ruby object#method doesn't lead to an explanation of this. You
> get reams of hits  using object#method syntax but not where it comes
> from.


http://ruby-doc.org/core/classes/Object.html#M000336
Nicolai R. (Guest)
on 2009-07-28 22:24
(Received via mailing list)
>
> Where is this documented? I can't find it in any book...and searching
> google on Ruby object#method doesn't lead to an explanation of this.

I immediately found it on ruby-doc.org:
http://www.ruby-doc.org/core/classes/Object.html#M000336

Regards
Nicolai
gb l. (Guest)
on 2009-07-28 23:06
Nicolai Reuschling wrote:
>>
>> Where is this documented? I can't find it in any book...and searching
>> google on Ruby object#method doesn't lead to an explanation of this.
>
> I immediately found it on ruby-doc.org:
> http://www.ruby-doc.org/core/classes/Object.html#M000336
>
> Regards
> Nicolai

Thanks for taking the time, I suspect I didn't make my question
clear,there is nothing that I can see on the link Object.html#M000336
that specifies what object#method means vs object::method but your link
lead me to search on the site and I found it here
http://ruby-doc.org/documentation-guidelines.html, somewhat buried but
certainly clear.

Style Guidelines

Use :: for describing class methods,
     # for describing instance methods,
     . for example code.
Matthias R. (Guest)
on 2009-07-29 05:25
(Received via mailing list)
Gary L. schrieb:
>>                 Elf
>
> Where is this documented? I can't find it in any book...and searching
> google on Ruby object#method doesn't lead to an explanation of this. You
> get reams of hits  using object#method syntax but not where it comes
> from.

The 1st edition of "Programming Ruby"[1] (a.k.a. the "Pickaxe") mentions
this notation:
> Within the text, Fred#doIt is a reference to an instance method (doIt) of
> class Fred, while Fred.new [In some other Ruby documentation, you may
> see class methods written as Fred::new. This is perfectly valid Ruby
> syntax; we just happen to feel that Fred.new is less distracting to
> read.] is a class method, and Fred::EOF is a class constant.

The first appearance in the Ruby changelog[2] dates back to 1995,
suggesting that Matz himself may have introduced this convention.

-Matthias

[1]: http://www.rubycentral.com/pickaxe/preface.html
[2]:
http://svn.ruby-lang.org/cgi-bin/viewvc.cgi/tags/v...
This topic is locked and can not be replied to.