Beefy Boxes and Bandwidth Generously Provided by pair Networks
laziness, impatience, and hubris

comment on

( #3333=superdoc: print w/replies, xml ) Need Help??
What does that mean? What global scope shall these attributes have?

You can get at the attributes of a class in it's sub-classes, for example:

package Inc; use base 'OO'; sub next { my $self = shift; my $next = $self->oo_get('inc'); $self->oo_set('inc', ++$next); return($next); }; package Inc2; use base qw(Inc); sub current { my $self = shift; $self->oo_get('inc', 'Inc'); };

Some people consider being able to do this sort of thing bad. You cannot hide implementation details so you can change them without affecting other classes. With inside-out objects the hash can be lexically scoped to the class - so there is no way you can get at it from the super-class.

{ package Inc; my %Value = (); sub new { bless [], shift; }; sub next { ++$Value{+shift}; }; }; { package Inc2; # ... no way to get at %Value here ... };

While you may not want this feature yourself, it is something that inside objects can do, that your implementation cannot.

Typing $self->{fo} when you meant to type $self->{foo} won't give you a compile time error.
You can't solve this problem as long as you use a hash at all. But the danger can be limited to inside the class by enforcing accessor methods. Your Code doesn't help this either.

You can solve it with inside out objects - one of their great advantages. For example, If I made a typo when I implemented Inc using your module.

sub next { my $self = shift; my $next = $self->oo_get('inc'); $self->oo_set('incc', ++$next); return($next); };

I won't get any compile-time error - it will just fail silently.

If make a typo with the field name with the inside-out object implementation.

sub next { ++$Valuee{+shift}; };

I'll get a compile time error with use strict because %Value isn't defined.

I know the code I showed didn't solve the problem. I wasn't trying to. I was demonstrating that you could get most of what your modules gives you using hash-based objects, rather than a global hash.

You can't inherit from classes implemented with non-hash references.
You can. You cannot implement non-hash objects using the OO module, but you can inherit from any object, because _your_ class' data is kept somehwere else. Anyways: the new() was in question. It's probably no good idea, although you're always allowed to override it.

If you read what I wrote again, you'll see I said:

Having your own new() method makes mixing this into an existing class hard.

Having a new function means that you have to take care with the order of your classes in the inheritence hierarchy, otherwise your new will override the new from the other class you are inheriting from.

For example:

package AppointmentDate; use base qw(OO Date::Simple); sub appointment { my ($self, $appointment) = @_; $self->oo_set('appointment', $appointment) if $appointment; return( $self->oo_get('appointment') ); };

won't work because it needs to be use base qw(Date::Simple OO) to get the correct new() method called. In general classes that you intend to mixin to existing class hierarchies should avoid constructors.

oo_get/set allows you to get the attribute from any class through your optional third argument.
Just as Perl gives you symbolic references. This is for example needed when you create accessor methods automatically.

Just because you can do it, doesn't mean that it's a good idea :-) The fact that you cannot do this with Abigail-II's implementation of inside out objects as lexically scoped hashes is a feature, not a bug.

There are many other ways to make accessor methods without having the ability to get arbritary attributes from objects (e.g. with source filters or like this).

The idea of putting the data back into the object seperated by classes is great. It makes the object classically serializable and gets us rid of complicated DESTROY methods because it's all in one place. "Ay, there's the rob", it is then impossible to inherit from classes that don't use that new scheme.

Completely true. The point I was trying to make was that this was the only advantage your system gave you - while dropping the other advantages of using lexically scoped hashes:-)

In reply to Re^3: A different OO approach by adrianh
in thread A different OO approach by fruiture

Use:  <p> text here (a paragraph) </p>
and:  <code> code here </code>
to format your post; it's "PerlMonks-approved HTML":

  • Are you posting in the right place? Check out Where do I post X? to know for sure.
  • Posts may use any of the Perl Monks Approved HTML tags. Currently these include the following:
    <code> <a> <b> <big> <blockquote> <br /> <dd> <dl> <dt> <em> <font> <h1> <h2> <h3> <h4> <h5> <h6> <hr /> <i> <li> <nbsp> <ol> <p> <small> <strike> <strong> <sub> <sup> <table> <td> <th> <tr> <tt> <u> <ul>
  • Snippets of code should be wrapped in <code> tags not <pre> tags. In fact, <pre> tags should generally be avoided. If they must be used, extreme care should be taken to ensure that their contents do not have long lines (<70 chars), in order to prevent horizontal scrolling (and possible janitor intervention).
  • Want more info? How to link or or How to display code and escape characters are good places to start.
Log In?

What's my password?
Create A New User
Domain Nodelet?
and the web crawler heard nothing...

How do I use this? | Other CB clients
Other Users?
Others cooling their heels in the Monastery: (3)
As of 2022-08-19 11:33 GMT
Find Nodes?
    Voting Booth?

    No recent polls found