Private #initialize


#1

My apologies if this has been discussed before, but I couldn’t find
anything in a Google search, searching this particular list/group on
Google, or my first attempt at blade. (Later attempts complained about
not being able to access the index.)

So, in Ruby a private method is one that can only be called by the
object itself, and that’s enforced by the simple rule of disallowing
an explicit receiver. Of course, there are ways around this; any
message can be passed if you just know what to do. Maybe I’m late to
the game, but I didn’t realize it was okay to have #initialize be a
private method. More than that, I didn’t realize #initialize was
always private. This confuses me because I think of SomeClass.new to
be

def new(*args, &block)
  instance = allocate
  instance.initialize(*args, &block)
  instance
end

But that obviously can’t be the case if #initialize is private.
Instead, it has to be

def new(*args, &block)
  instance = allocate
  instance.send(:initialize, *args, &block)
  instance
end

It’s a small change, but significant. And it seems odd to have
something this central to the language skirting the boundaries of
access control. Is it simply because an object shouldn’t be re-
initialized once it’s created? And if so, is that so horrible?


#2

On Thu, Nov 27, 2008 at 12:38 PM, Yossef M. removed_email_address@domain.invalid
wrote:

Is it simply because an object shouldn’t be re-
initialized once it’s created? And if so, is that so horrible?

I don’t think the issue is that an object shouldn’t be re-initialized, I
think
it’s that (in general) an object shouldn’t be re-initialized by anyone
except itself. If I’m writing a class, I’ll declare certain instance
methods
private, because I don’t want clients calling them. initialize seems
like
a method that I rarely want clients to be able to call.

Best regards,

Wayne


Wayne V.
No Bugs Software
Agile Ruby (but preferably not Rails) Contract Programming in Silicon
Valley since 2001


#3

Hi,

In message “Re: private #initialize
on Fri, 28 Nov 2008 05:38:47 +0900, Yossef M.
removed_email_address@domain.invalid writes:

|And it seems odd to have
|something this central to the language skirting the boundaries of
|access control. Is it simply because an object shouldn’t be re-
|initialized once it’s created? And if so, is that so horrible?

#initialize is, by its design, supposed to be called only from within
#new to separate per object/class initialization from the #new, thus
you don’t have to redefine #new. When you need/want to redefine #new,
it’s a sign of a bad design, I believe.

One of the reason #initialize being private is to tell you bad design.

          matz.

#4

On Fri, Nov 28, 2008 at 12:32 AM, Yukihiro M.
removed_email_address@domain.invalid wrote:

#initialize is, by its design, supposed to be called only from within
#new to separate per object/class initialization from the #new, thus
you don’t have to redefine #new. When you need/want to redefine #new,
it’s a sign of a bad design, I believe.
I am delivering this code to your judgment

module Immutable
def new *args, &blk
o = allocate
o.send( :initialize, *args, &blk )
o.freeze
end
end

One of the reason #initialize being private is to tell you bad design.

I can not come up with a better design as the above. But I am
listening of course.
Calling freeze on self at the end of #initialize is really asking for
trouble with subclasses.

Now that all said, it is good that #initialize is private because it
makes you think before doing tricky things as above
but I would not call it bad design.

Cheers
Robert


Ne baisse jamais la tête, tu ne verrais plus les étoiles.

Robert D. :wink:


#5

Hi,

In message “Re: private #initialize
on Fri, 28 Nov 2008 10:24:24 +0900, “Robert D.”
removed_email_address@domain.invalid writes:

|On Fri, Nov 28, 2008 at 12:32 AM, Yukihiro M. removed_email_address@domain.invalid wrote:
|
|> #initialize is, by its design, supposed to be called only from within
|> #new to separate per object/class initialization from the #new, thus
|> you don’t have to redefine #new. When you need/want to redefine #new,
|> it’s a sign of a bad design, I believe.
|I am delivering this code to your judgment
|
|module Immutable
| def new *args, &blk
| o = allocate
| o.send( :initialize, *args, &blk )
| o.freeze
| end
|end

It’s far better than normal #new replacement. But it’s still not
worth making #initialize public though. Honestly speaking, tasks like
the code you’ve presented should be solved by AOP or method
combination, which unfortunately Ruby does not have right now.
Maybe in the future.

          matz.

#6

Michael N. wrote:

How about this?
module Immutable
def self.included(klass)
class << klass
alias __old_new new
def new(*args, &blk)
__old_new(*args, &blk).freeze
end
end
end
end

Wrong hook. new is a class method, so you’ll want to extend, so def
self.extended.

Regards
Stefan R.


#7

Robert D. schrieb:

o = allocate
o.send( :initialize, *args, &blk )
o.freeze

end
end

How about this?

module Immutable
def new(*args, &blk)
super.freeze
end
end

Okay, this will not work if you redefine #new yourself. Or that?

module Immutable
def self.included(klass)
class << klass
alias __old_new new
def new(*args, &blk)
__old_new(*args, &blk).freeze
end
end
end
end

(will not work when including into a module)

Regards,

Michael