Use of Double-Colon ::

ruby-talk
1

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

2

Alle mercoledì 9 maggio 2007, robninja@gmail.com 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
either the double column or the dot when calling a method:

class C
CONST=1
def C.a_method
  puts "a_method
end
end

C::a_method
=> "a_method"

C.a_method
=> "a_method"

puts C::CONST
=> 1

puts C.CONST
=> NoMetodError

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

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

Stefano

3

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

···

On Wednesday 09 May 2007 18:40, robninja@gmail.com wrote:

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

--
Marcin Raczkowski
---
Friends teach what you should know
Enemies Teach what you have to know

4

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

···

On May 9, 2007, at 2:40 PM, robninja@gmail.com wrote:

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

5

Hi --

···

On Thu, 10 May 2007, robninja@gmail.com wrote:

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)

6

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

···

On 9 May, 20:15, dbl...@wobblini.net wrote:

Hi --

On Thu, 10 May 2007, robni...@gmail.com wrote:
> 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)

7

Hi,

> 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:

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

···

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

On Wednesday 09 May 2007 18:40, robninja@gmail.com wrote:

--
Bertram Scharpf
Stuttgart, Deutschland/Germany
http://www.bertram-scharpf.de