in reply to Re: $class = ref $class || $class
in thread Constructor/Factory Orthodoxy

I usually take 'ref $class || $class' to allow me to use an extant object to call the constructor instead of uaing a class name.

Sure. I've used and written such myself. I wrote such code only because I was following the examples given me in the docs. No other reason.

The point is Why? Why do you let users of your package use objects to call constructors? Why do you want to be able to write $obj->new vs Obj->new? What is the benefit of this more complicated and slower code?

Replies are listed 'Best First'.
Re: Re: Re: $class = ref $class || $class
by herveus (Prior) on Feb 28, 2003 at 13:06 UTC
    Howdy!

    Why? Re: Re5: Constructor/Factory Orthodoxy by steves spoke to this.

    For myself, if I have a bunch of classes that inherit from a base class that provides the constructor (or at least a default constructor), and I want "another one of these", where I don't necessarily know exactly what package "this" is blessed in to, I either have to do ref($this) everywhere I do this, or just expect that $this can(new) and let new figure it out.

    Sure, if I call $obj->new, Perl may have to dredge through @INC@ISA to find the method, where Class->new is explicit, but that may force me (the lazy programmer) to have to discern Class from $obj every time. If I bury that discovery in new, I only have to do it in one place.

    I'm not clear on what you mean by "more complicated and slower". Well, I can see the "slower" part, but "more complicated"?

    yours,
    Michael

    Update: corrected erroneous reference to @INC (where I should have said @ISA) (slaps forehead)

[reply]
      @INC is only consulted when doing a use or require. It's not consulted for object or method calls.

      Don't expect there to be much difference in speed between $obj -> new and Class -> new. The overhead of calling the method dwarves any finding of the class.

      Abigail

[reply]
[d/l]
[select]
      Most of the code I've seen with this construct in new does not have the usage you describe as a justification. And I don't find your justification compelling where it does apply.

      I would prefer to write (ref $obj)->new instead of $obj->new because that tells the reader that the type of $obj is variable or questionable. If I write Obj->new there is no doubt of the type. There is less chance the reader will research the wrong package if he wants to do something with the created object.
      If I just write $obj->new as a convenient shorthand I hide this info. Thus I make the code more complicated to understand.

[reply]
[d/l]
[select]
        Howdy!

        I don't see a compelling argument either way.

        Assuming the situation I posit holds, the reader or user will, of necessity, have consulted the documentation for the modules that would, of course, speak to matters relevant to "what can I do with this thingy". It pretty much follows from the posited situation that the possible values of ref($obj) are closely related in some useful manner, so as to permit generalization. Heck, they may all have an identical set of methods, differing only in how those methods do stuff.

        If I am in a situation where I need "another ref($obj)", I, in my laziness, don't want to be forced to say ref($obj) just for the sake of truth and beauty. I do not see that having "new" take the ref() if necessary as being, per se, a Bad Thing.

        Perhaps we will have to agree to disagree.

        yours,
        Michael

[reply]
[d/l]
[select]

In Section Meditations