Here seems to be the traditional inside-out class :

package PointX;

use strict;
use warnings;
use Scalar::Util qw(refaddr);
use Carp qw(carp cluck croak confess);


our $VERSION = '0.1b';
{
    my %xcord;
    my %ycord;

    sub new {
        my ($class, $cords) = @_;
        my $new_object = bless \do{my $anon_scalar;}, $class;
        $xcord{refaddr $new_object} = $cords->{'x'};
        $ycord{refaddr $new_object} = $cords->{'y'};
        return $new_object;
    }

    sub DESTROY {
        my ($self) = @_;
        delete $cord{refaddr $self};
        return;
    }

    sub set_x {
        my($self, $xcord) = @_;
        $xcord{refaddr $self} = $xcord;
        return ($xcord{refaddr $self});
    }

    sub get_x {
        my($self) = @_;
        return ($xcord{refaddr $self});
    }

    sub set_y {
        my($self, $ycord) = @_;
        $ycord{refaddr $self} = $ycord;
        return ($ycord{refaddr $self});
    }

    sub get_y {
        my($self) = @_;
        return ($ycord{refaddr $self});
    }


} # end of internal scoping.
1;
[download]

But am I wrong if I get rid of the multiple hashes and go with a single hash ref like this?

package PointX;

use strict;
use warnings;
use Scalar::Util qw(refaddr);
use Carp qw(carp cluck croak confess);


our $VERSION = '0.1b';
{
    my %cord;

    sub new {
        my ($class, $cords) = @_;
        my $new_object = bless \do{my $anon_scalar;}, $class;
        $cord{refaddr $new_object}->{'x'} = $cords->{'x'};
        $cord{refaddr $new_object}->{'y'} = $cords->{'y'};
        return $new_object;
    }

    sub DESTROY {
        my ($self) = @_;
        delete $cord{refaddr $self};
        return;
    }

    sub set_x {
        my($self, $xcord) = @_;
        $cord{refaddr $self}->{'x'} = $xcord;
        return ($cord{refaddr $self}->{'x'});
    }

    sub get_x {
        my($self) = @_;
        return ($cord{refaddr $self}->{'x'});
    }

    sub set_y {
        my($self, $ycord) = @_;
        $cord{refaddr $self}->{'y'} = $ycord;
        return ($cord{refaddr $self}->{'y'});
    }

    sub get_y {
        my($self) = @_;
        return ($cord{refaddr $self}->{'y'});
    }


} # end of internal scoping.
1;
[download]

In the second example, I wrote a test program that seems to work just fine and as I'd expect.

#!/usr/bin/perl

use strict;
use warnings;
use PointX;


my $point = PointX->new({x=>3, y=>20});

print "The x cord is ".$point->get_x()."\n";
print "The y cord is ".$point->get_y()."\n";

$point->set_x(10);

print "The x cord is ".$point->get_x()."\n";
print "The y cord is ".$point->get_y()."\n";
[download]

which produces the output:

The x cord is 3
The y cord is 20
The x cord is 10
The y cord is 20
[download]

So why do most things just keep adding internal hashes instead of using 1 hash for everything? I'm new to this inside out class way of doing things, so I want to nip any bad habits in the bud (if indeed this is a bad habit).

This is a trivial example of just having 2 items tracked with a single hash. My current application will track around a dozen. I'd prefer not to have a dozen hashes, but I will if it's deemed to be The-Right-Thing (tm).