[lnkForumImage]
TotalShareware - Download Free Software
Confronta i prezzi di migliaia di prodotti.
Asp Forum
 Home | Login | Register | Search 


 

Forums >

comp.lang.ruby

Subclassing self

gruby

9/9/2003 7:54:00 PM

X-No-archive: yes

I'm a new ruby user. I have the Ruby Way book.

My question is, in what case would you use

class TheClass
class << self
def foo

Couldn't you just say

class TheClass
def foo

?
5 Answers

Mark J. Reed

9/9/2003 8:06:00 PM

0

On Tue, Sep 09, 2003 at 12:54:01PM -0700, John wrote:
> My question is, in what case would you use
>
> class TheClass
> class << self
> def foo
>
> Couldn''t you just say
>
> class TheClass
> def foo

No; that would define an *instance* method called ''foo''.
The first example defines a *class* method called ''foo''.

That is, in the first example, you would call it like this:

TheClass.foo

And within the method, ''self'' would refer to TheClass.

In your version, TheClass.foo doesn''t exist; instead, you
have to instantiate the class and call foo on the object:

obj = TheClass.new
obj.foo

And within the method, ''self'' will refer to obj.

Instead of using the class << self notation, you could do this:

class TheClass
def TheClass::foo

But that can get tedious when defining multiple class methods,
plus you run the risk of missing a change if you rename the class
later.

-Mark

Gavin Sinclair

9/9/2003 10:45:00 PM

0

On Wednesday, September 10, 2003, 6:06:26 AM, John wrote:

> X-No-archive: yes

> I''m a new ruby user. I have the Ruby Way book.

> My question is, in what case would you use

> class TheClass
> class << self
> def foo

> Couldn''t you just say

> class TheClass
> def foo

Take a look at http://www.rubygarden.org/ruby?Cl...

Gavin

Fredrik Jagenheim

9/10/2003 9:00:00 PM

0

On Wed, Sep 10, 2003 at 05:06:28AM +0900, Mark J. Reed wrote:
>
> Instead of using the class << self notation, you could do this:
>
> class TheClass
> def TheClass::foo
>
> But that can get tedious when defining multiple class methods,
> plus you run the risk of missing a change if you rename the class
> later.

I was just shown:

class TheClass
def self.foo

This way you don''t risk the missing a change when you rename the
class. You still get the tedious typing though. :)

However, what does ''class << self'' really mean? Why is this one
of the ''obvious'' ways to define class methods?

No, I''m not being sarcastic, just realizing that I don''t know the ruby
language as well as I would want to. To me it looks like we''re
shifting the current class into an anonymous class, and how that can
spell ''class methods'' I really can''t see. :)

//F

Mauricio Fernández

9/10/2003 10:27:00 PM

0

On Thu, Sep 11, 2003 at 06:00:00AM +0900, Fredrik Jagenheim wrote:
> On Wed, Sep 10, 2003 at 05:06:28AM +0900, Mark J. Reed wrote:
> >
> > Instead of using the class << self notation, you could do this:
> >
> > class TheClass
> > def TheClass::foo
> >
> > But that can get tedious when defining multiple class methods,
> > plus you run the risk of missing a change if you rename the class
> > later.
>
> I was just shown:
>
> class TheClass
> def self.foo
>
> This way you don''t risk the missing a change when you rename the
> class. You still get the tedious typing though. :)
>
> However, what does ''class << self'' really mean? Why is this one
> of the ''obvious'' ways to define class methods?

class << obj opens the singleton class of obj. In a class context,
self points to the Class object, therefore in

class A
self # this is A
class << self # same as class << A but needs not be changed if
# if A is renamed
# we''re in A''s singleton class
end
end

Class methods are in fact class singleton methods (ie. singleton methods
of the object of class Class). You sometimes want to use the class << self
idiom to create attribute accessors for the class, etc:

class A
class << self
attr_accessor :foo
end
end

A.foo = 1
A.foo # => 1

--
_ _
| |__ __ _| |_ ___ _ __ ___ __ _ _ __
| ''_ \ / _` | __/ __| ''_ ` _ \ / _` | ''_ \
| |_) | (_| | |_\__ \ | | | | | (_| | | | |
|_.__/ \__,_|\__|___/_| |_| |_|\__,_|_| |_|
Running Debian GNU/Linux Sid (unstable)
batsman dot geo at yahoo dot com

Make it idiot-proof, and someone will breed a better idiot.
-- Oliver Elphick

Gavin Sinclair

9/10/2003 10:33:00 PM

0

On Thursday, September 11, 2003, 7:00:00 AM, Fredrik wrote:

> On Wed, Sep 10, 2003 at 05:06:28AM +0900, Mark J. Reed wrote:
>>
>> Instead of using the class << self notation, you could do this:
>>
>> class TheClass
>> def TheClass::foo
>>
>> But that can get tedious when defining multiple class methods,
>> plus you run the risk of missing a change if you rename the class
>> later.

> I was just shown:

> class TheClass
> def self.foo

> This way you don''t risk the missing a change when you rename the
> class. You still get the tedious typing though. :)

> However, what does ''class << self'' really mean? Why is this one
> of the ''obvious'' ways to define class methods?

It''s not necessarily obvious; it''s an idiom, but it makes perfect
sense once you know, and it involves core Ruby concepts, so it is
worth knowing.

s = "Hi"
class << s
def foo # Singleton method on object s
5
end
end
s.foo # -> 5

s = String
class << s
def foo # Singleton method on object String
5
end
end
s.foo # -> 5
String.foo # -> 5

See http://www.rubygarden.org/ruby?Cl... for more info.

Gavin