Ruby constants in singleton methods

Question

I have a Ruby C extension; I call that class FooC defined in ext/foo/foo.c, in that file I have

void Init_foo(void)
{
  VALUE cFoo = rb_const_get(rb_cObject, rb_intern("FooC"));
  :
  rb_define_const(cFoo, "BAR", 7);
  :

That is included in the "Ruby part" of the extension in lib/foo.rb like

class FooC ; end

require 'foo/foo'

class Foo < FooC
  class << self
    def puts_bar
      puts BAR
    end
    :
  end
  :
end

Unexpectedly, I get an error

NameError: uninitialized constant #<Class:Foo>::BAR

I was expecting that Ruby would not find BAR in the Foo namespace, but would then search FooC where it would find it. Strangely, if I use Foo::BAR or self::BAR, the error goes away, and a similar usage in a Foo instance method gives me no errors at all.

Anyone have an idea as to why I need this seemingly redundant qualification of constants in singleton methods?

[edit]

Following the interesting answer below, I confirm that this qualification is not needed in a proper class method:

class Foo < FooC
  def self.puts_bar
    # no NameError here
    puts BAR
  end
  :
end

rather than a instance method of the eigenclass.

score 2 · Accepted Answer · edited May 07 '22 at 04:39

2

You are looking the constant up in the eigenclass of Foo, not in the Foo itself. Start with figuring out what’s what without any c bindings.

class FooC; end
class Foo < FooC
  BAR = 42
  puts "Foo: #{self}, DEF: #{const_defined?(:BAR)}"
  class << self
    def puts_bar
      puts "Foo.class: #{self} DEF: #{self.class.const_defined?(:BAR)}"
      puts self.class.const_get(:BAR)
    end
  end
  def puts_bar
    puts "Foo.class: #{self} DEF: #{self.class.const_defined?(:BAR)}"
    puts self.class.const_get(:BAR)
  end
end

And see how it works:

#  Foo: Foo, DEF: true

[2] pry(main)> Foo.puts_bar
#⇒ Foo.class: Foo DEF: false
#   NameError: uninitialized constant Class::BAR
#   from (pry):8:in `const_get'

[3] pry(main)> Foo.new.puts_bar
#⇒ Foo.class: #<Foo:0x0000556e174b91c0> DEF: true
#   42

Constants are made visible within instance functions by looking up the class’ constants. #<Class:Foo> in the error message you’ve got is explicitly pointing out to that.

edited May 07 '22 at 04:39

Nakilon

34,866
14
107
142

answered Jun 25 '21 at 06:48

Aleksei Matiushkin

119,336
10
100
160

Ah, I was thinking that this was something to do with C, and I find that defining a "proper" class method rather than an instance method in the eigenclass, then this odd behaviour doesn't happen. Still not entirely clear to me why though ... I've edited the question a little. – jjg Jun 25 '21 at 09:47
1

`class << self` introduces a new scope, `def` does not. That said, `BAR` is visible in your edited version because of a closure. – Aleksei Matiushkin Jun 25 '21 at 10:12
Welcome back to ruby. :) Technically speaking shouldn't `BAR=42` be in `FooC` based on the C extension code? – engineersmnky Jun 25 '21 at 18:17
@engineersmnky thanks :) indeed, I was trapped by all these `cFoo`, `FooC` naming collisions. Still, to access the constant from the eigenclass, as in the example, one should fully qualify it, while the instance has an unqualified access to it. – Aleksei Matiushkin Jun 25 '21 at 19:29
1

Agreed the impact is the same although `class Foo < FooC; class << self; def puts_bar; const_get(:BAR); end; end; end;` would work but just `BAR` will not (as is already shown in OP) – engineersmnky Jun 25 '21 at 20:33
Thank-you both for these helpful comments, clearly my mental-model of the Ruby eigenclass needs some work (not for the first time), I'll study it some more. – jjg Jun 26 '21 at 13:03
As you guys both said, neither `const_get` nor `self.class.const_get` would work in the first method. But note that `self.const_get` works perfectly. – Nakilon May 07 '22 at 04:46

Ruby constants in singleton methods

1 Answers1