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

Re^3: A different OO approach

by adrianh (Chancellor)
on Dec 15, 2002 at 16:39 UTC ( #220023=note: print w/replies, xml ) Need Help??

in reply to Re: Re: A different OO approach
in thread A different OO approach

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:-)

Log In?

What's my password?
Create A New User
Node Status?
node history
Node Type: note [id://220023]
and all is quiet...

How do I use this? | Other CB clients
Other Users?
Others having an uproarious good time at the Monastery: (3)
As of 2017-09-21 03:48 GMT
Find Nodes?
    Voting Booth?
    During the recent solar eclipse, I:

    Results (241 votes). Check out past polls.