Use of Double-Colon ::

[robninja]

Hi,

I'm new to Ruby and throughly enjoying learning the language. I'm
currently working my way through the Pickaxe book, but have a couple
of questions I hope someone can help me out with.

As I understand it the double-colon ( :: ) can be used when calling
class methods or class constants, but could correctly be replaced by a
single dot ( . ) if preferred:

SongList::is_too_long(song1)
SongList.is_too_long(song1)

I was wondering if someone more experience could tell me which method
is used by the majority of Rubyists and whether it is thought of as
"best practice" to use the double colon?

I suspect this is probably down to personal preference. I personally
prefer the double-colon but I would like to get into good habits now
whilst I'm learning the language. The Pickaxe book doesn't use ::
except when referring to modules (not sure if that is the correct
term), e.g.,

class TestRoman < Test::Unit::TestCase
#...
end

Could someone explain whether this is convention or if there is
another reason for this?

Many thanks!
Robin

 

[Stefano Crocco]

Alle mercoled=EC 9 maggio 2007, (e-mail address removed) ha scritto:

Hi,

I'm new to Ruby and throughly enjoying learning the language. I'm
currently working my way through the Pickaxe book, but have a couple
of questions I hope someone can help me out with.

As I understand it the double-colon ( :: ) can be used when calling
class methods or class constants, but could correctly be replaced by a
single dot ( . ) if preferred:

SongList::is_too_long(song1)
SongList.is_too_long(song1)

I was wondering if someone more experience could tell me which method
is used by the majority of Rubyists and whether it is thought of as
"best practice" to use the double colon?

I suspect this is probably down to personal preference. I personally
prefer the double-colon but I would like to get into good habits now
whilst I'm learning the language. The Pickaxe book doesn't use ::
except when referring to modules (not sure if that is the correct
term), e.g.,

class TestRoman < Test::Unit::TestCase
#...
end

Could someone explain whether this is convention or if there is
another reason for this?

Many thanks!
Robin

You need to use the double column when referring to a constant. You can use=
=20
either the double column or the dot when calling a method:

class C
CONST=3D1
def C.a_method
puts "a_method
end
end

C::a_method
=3D> "a_method"

C.a_method
=3D> "a_method"

puts C::CONST
=3D> 1

puts C.CONST
=3D> NoMetodError

In the last case, ruby is trying to find a class method of C named CONST=20
(because the dot can only be used to call a method). Since such a method=20
doesn't exist, a NoMethodError exception is raised. In the example of class=
=20
TestRoman, the double columns can't be replaced by dots because TestCase an=
d=20
Unit are constants (respectively, a constant referring to a Module declared=
=20
in the Test module and a constant referring to a Class declared in the Unit=
=20
module).

As for which form is most used, I'm not an expert, but I think that the dot=
is=20
most used to call class methods.

Stefano

 

[Marcin Raczkowski]

Hi,

I'm new to Ruby and throughly enjoying learning the language. I'm
currently working my way through the Pickaxe book, but have a couple
of questions I hope someone can help me out with.

As I understand it the double-colon ( :: ) can be used when calling
class methods or class constants, but could correctly be replaced by a
single dot ( . ) if preferred:

SongList::is_too_long(song1)
SongList.is_too_long(song1)

I was wondering if someone more experience could tell me which method
is used by the majority of Rubyists and whether it is thought of as
"best practice" to use the double colon?

I suspect this is probably down to personal preference. I personally
prefer the double-colon but I would like to get into good habits now
whilst I'm learning the language. The Pickaxe book doesn't use ::
except when referring to modules (not sure if that is the correct
term), e.g.,

class TestRoman < Test::Unit::TestCase
#...
end

Could someone explain whether this is convention or if there is
another reason for this?

Many thanks!
Robin

If i remember correctly you use :: for Classes, constants etc and . for
methods, it was here before - read archives first

 

[Gary Wright]

Could someone explain whether this is convention or if there is
another reason for this?

As the other responders have pointed out, you have to use :: when
you are accessing constants within modules. And since classes
are modules, the same applies for classes.

While both :: and . work for calling methods, I prefer . because
it emphasizes the idea that a module (or a class) is *just*
another object and isn't 'special' with respect to method
invocation.

Gary Wright

 

[dblack]

Hi --

Hi,

I'm new to Ruby and throughly enjoying learning the language. I'm
currently working my way through the Pickaxe book, but have a couple
of questions I hope someone can help me out with.

As I understand it the double-colon ( :: ) can be used when calling
class methods or class constants, but could correctly be replaced by a
single dot ( . ) if preferred:

SongList::is_too_long(song1)
SongList.is_too_long(song1)

I was wondering if someone more experience could tell me which method
is used by the majority of Rubyists and whether it is thought of as
"best practice" to use the double colon?

I suspect this is probably down to personal preference. I personally
prefer the double-colon but I would like to get into good habits now
whilst I'm learning the language. The Pickaxe book doesn't use ::
except when referring to modules (not sure if that is the correct
term), e.g.,

class TestRoman < Test::Unit::TestCase
#...
end

Could someone explain whether this is convention or if there is
another reason for this?

I think it's clearer just to use a dot to mean "send this to the
object", and :: to drill down constant scope. I don't think there's
any reason to use a different operator just because the receiver is a
class or module. You're still doing the same thing: sending a message
to an object. So I'd just use the dot.


David

--
Q. What is THE Ruby book for Rails developers?
A. RUBY FOR RAILS by David A. Black (http://www.manning.com/black)
(See what readers are saying! http://www.rubypal.com/r4rrevs.pdf)
Q. Where can I get Ruby/Rails on-site training, consulting, coaching?
A. Ruby Power and Light, LLC (http://www.rubypal.com)

 

[Robin]

Hi --










I think it's clearer just to use a dot to mean "send this to the
object", and :: to drill down constant scope. I don't think there's
any reason to use a different operator just because the receiver is a
class or module. You're still doing the same thing: sending a message
to an object. So I'd just use the dot.

David

--
Q. What is THE Ruby book for Rails developers?
A. RUBY FOR RAILS by David A. Black (http://www.manning.com/black)
(See what readers are saying! http://www.rubypal.com/r4rrevs.pdf)
Q. Where can I get Ruby/Rails on-site training, consulting, coaching?
A. Ruby Power and Light, LLC (http://www.rubypal.com)

Thanks everyone. That all makes sense.

I first met double-colon in the Class methods section of "why's guide
to ruby" ( http://poignantguide.net/ruby/chapter-3.html ), it doesn't
mention using dot as an alternative in that section so I assumed
double-colon was the standard. Thanks for clearing it up.

Robin

 

[Bertram Scharpf]

Hi,

Am Donnerstag, 10. Mai 2007, 03:52:55 +0900 schrieb Marcin Raczkowski:

If i remember correctly you use :: for Classes, constants etc and . for
methods, it was here before - read archives first

Classes are mostly referred to by constants

class C
X = "x"
class << self
def X ; "y" ; end
end
end

c = C # C is a constant

cobj = c.new

c::X # => "x"
c.X # => "y"
C::X # => "x"
C.X # => "y"

Bertram