Are all singleton methods public?

Question

Is a singleton method necessarily public? If not, when would a private/protected singleton method be useful?

score 5 · Accepted Answer · answered Jan 28 '15 at 23:23

Singleton methods do not necessarily need to be public. Private/protected singleton methods are useful in the same situations as regular private/protected methods - for example as a helper method that you do not intend to be called outside of the class.

class Foo
end

f = Foo.new

class << f
  def foo
    helper
    # other stuff
  end

  private
  def helper
  end
end

score 1 · Answer 2 · answered Jan 28 '15 at 23:24

You can make a singleton method private if you want:

class Foo
end

f = Foo.new
def f.bar
  "baz"
end

f.singleton_class.send :private, :bar
f.bar # => NoMethodError: private method `bar' called for #<Foo:0x007f8674152a00>
f.send :bar # => "baz"

whether or not this is actually useful depends on what you're doing.

spickermann · Answer 3 · 2015-01-29T02:39:40.817

1

You can make a singleton method private if you want:

class Foo

  def self.bar
    # ...
  end
  private_class_method :bar

end

edited Jan 29 '15 at 02:39

answered Jan 29 '15 at 00:50

spickermann

100,941
9
101
131

BTW: in recent versions of Ruby, method definition expressions (`def`) evaluate to a `Symbol` corresponding to the name of the method being defined, so that you can do `private_class_method def self.bar; end` or `protected def foo; end` or something like that. – Jörg W Mittag Jan 29 '15 at 00:59
This doesn't really seem to answer the question of 'Are all singleton methods public?' – hichris123 Jan 29 '15 at 01:07
@hichris123, do we need more than one singleton method that is not public to disprove the assertion that they are all public? – Cary Swoveland Feb 02 '15 at 04:20

Cary Swoveland · Answer 4 · 2015-02-02T14:39:04.870

Could they be useful? Hmmm. For Ruby 2.2

ObjectSpace.each_object(Module).flat_map { |m|
  m.singleton_class.private_methods(false) }.size
  #=> 900

Most are private methods of classes' singleton classes:

ObjectSpace.each_object(Class).flat_map { |c|
  c.singleton_class.private_methods(false) }.size
  #=> 838

[Edit: The following is an edit of my original post, to present more useful information.)

I am puzzled by one thing. Let:

a = ObjectSpace.each_object(Class).map { |c|
      [c, c.singleton_class.private_methods(false)] }.to_h

b = ObjectSpace.each_object(Class).map { |c|
      [c, c.private_methods(false)] }.to_h

def diff(a,b) 
  a.map {|k,v| b.key?(k) ? [k,v-b[k]] : [k,v] }.reject { |_,a| a.empty?}.to_h
end

I expected diff(a,b) == diff(b,a) == {}. Let's see:

diff(a,b)
  #=> {} 

diff(b,a)
  #=> {Gem::Specification=>[:skip_during, :deprecate],
  #    Complex=>[:convert],
  #    Rational=>[:convert],
  #    Random=>[:state, :left],
  #    Time=>[:_load]}

Hmmmm.

Are all singleton methods public?

4 Answers4