Initialize not being called on objects created from literals

ruby-talk
1

Initialize doesn't appear to get called.

class Object
  def initialize
    @foo = 'bar'
  end
  attr_reader :foo
end

a = Object.new # => #<Object:0x54c964 @foo="bar">
a.foo # => "bar"
'string'.foo # => nil
//.foo # => nil

I want to have //.foo and 'string.foo give me "bar" as they should. How
can I do that?

···

--
Posted via http://www.ruby-forum.com/.

2

Initialize doesn't appear to get called.

class Object
def initialize
@foo = 'bar'
end
attr_reader :foo
end

a = Object.new # => #<Object:0x54c964 @foo="bar">

see relation bw initialize and new

a.foo # => "bar"
'string'.foo # => nil
//.foo # => nil

I want to have //.foo and 'string.foo give me "bar" as they should. How
can I do that?

try defining a method, eg

class Object
  def foo
    "bar"
  end
end

=> nil

1.foo

=> "bar"

//.foo

=> "bar"

···

On Wed, May 27, 2009 at 8:26 AM, Oliver Saunders <oliver.saunders@gmail.com> wrote:

3

A class needs to explicitly invoke #initialize of the super class. I guess, since Object does not have any members by default String will not do the invocation.

class A
   def initialize
     puts "A"
   end
end

class B < A
   def initialize
     super
     # or super() in this case
     puts "B"
   end
end

Having said that, it's generally not a too good idea to mess with built in classes - even though you can. But you may produce unwanted side effects.

Kind regards

  robert

···

On 27.05.2009 02:26, Oliver Saunders wrote:

Initialize doesn't appear to get called.

class Object
  def initialize
    @foo = 'bar'
  end
  attr_reader :foo
end

a = Object.new # => #<Object:0x54c964 @foo="bar">
a.foo # => "bar"
'string'.foo # => nil
//.foo # => nil

I want to have //.foo and 'string.foo give me "bar" as they should. How
can I do that?

--
remember.guy do |as, often| as.you_can - without end
http://blog.rubybestpractices.com/

4

Initialize doesn't appear to get called.

class Object
def initialize
@foo = 'bar'
end
attr_reader :foo
end

a = Object.new # => #<Object:0x54c964 @foo="bar">
a.foo # => "bar"
'string'.foo # => nil
//.foo # => nil

I want to have //.foo and 'string.foo give me "bar" as they should. How
can I do that?

A class needs to explicitly invoke #initialize of the super class. I guess,
since Object does not have any members by default String will not do the
invocation.

This is true, see below

class A
def initialize
puts "A"
end
end

class B < A
def initialize
super
# or super() in this case
puts "B"
end
end

Having said that, it's generally not a too good idea to mess with built in
classes - even though you can. But you may produce unwanted side effects.

But that's not the whole story. As the OP suspected, literals are
created by the parser without going through the normal initialization
route:

class Object
  alias_method :old_initialize, :initialize
  attr_reader :boo

  def initialize(*args, &b) # !> redefining Object#initialize may
cause infinite loop
    puts "Object#initialize"
    old_initialize(*args, &b)
    @boo = "who"
  end
end

puts "calling String.new"
s1 = String.new
puts "back"
puts "s1.boo is #{s1.boo.inspect}"
puts "making String#initialize call super"
class String
  alias_method :old_initialize, :initialize
  def initialize(*args, &b)
    super
    puts "String#initialize"
    old_initialize(*args, &b)
  end

end

puts "calling String.new"
s2 = String.new
puts "s2.boo is #{s2.boo.inspect}"

puts "\"abc\".boo is #{"abc".boo.inspect}"

Produces the following

calling String.new
back
s1.boo is nil
making String#initialize call super
calling String.new
Object#initialize
String#initialize
s2.boo is "who"
"abc".boo is nil
untitled:5: warning: redefining Object#initialize may cause infinite loop

Note that warning pointing out a potential unwanted side effect.

···

On Wed, May 27, 2009 at 2:10 AM, Robert Klemme <shortcutter@googlemail.com> wrote:

On 27.05.2009 02:26, Oliver Saunders wrote:

--
Rick DeNatale

Blog: http://talklikeaduck.denhaven2.com/
Twitter: http://twitter.com/RickDeNatale
WWR: http://www.workingwithrails.com/person/9021-rick-denatale
LinkedIn: http://www.linkedin.com/in/rickdenatale

5

Thanks Rick. I poked around a bit more after the last few posts made
here and couldn't find an answer. I started looking at the Ruby's C code
but couldn't really get any useful information from it. Despite this I'm
fairly confident what I wanted to do can't be done. But I managed to
work around it in the end with a solution that was actually surprisingly
simple.

For those interested to know what I was doing I was trying to implement
a layer for prototype-based OO in Ruby. Didn't really work though. As
far as I know (and please correct me if I'm wrong) Ruby doesn't allow
you to call a method redefining the meaning of self for the purpose of
the call (e.g. apply() in JS) and without this feature you can't really
implement this layer in any useful way.

···

--
Posted via http://www.ruby-forum.com/.

6

For those interested to know what I was doing I was trying to implement a layer for prototype-based OO in Ruby. Didn't really work though.

Please correct me if I am wrong, but you seem to mean

Would this approximate what you're after?

prototype = Object.new
class <<prototype
   def foo
     printf "%p %p\n", self, self.class
   end
end
o1 = prototype.clone
o2 = prototype.clone
o1.foo
o2.foo

As far as I know (and please correct me if I'm wrong) Ruby doesn't allow you to call a method redefining the meaning of self for the purpose of the call (e.g. apply() in JS) and without this feature you can't really implement this layer in any useful way.

#instance_eval does exactly that: it temporarily sets self to point to a particular instance.

But it seems apply() in JS world is used to do something else

http://www.devguru.com/Technologies/ecmascript/quickref/apply.html

Basically you would need it to call "super class" methods. A few solutions come to mind. For construction you can do

def base
   o = Object.new
   class <<o
     def base_meth
     end
   end
   o
end

def derived
   o = base
   # alt: prototype.clone
   class <<o
     def derived_meth
     end
   end
   o
end

If your search the archives I am pretty sure you'll find something about prototype based OO in Ruby.

Kind regards

  robert

···

On 27.05.2009 22:08, Oliver Saunders wrote:

--
remember.guy do |as, often| as.you_can - without end
http://blog.rubybestpractices.com/