How to return two values in getter method in Perl?

Question

use strict;
use warnings;

package LineSegment;

sub new
{       
        my $class = shift; 
        my ($ax, $ay, $bx, $by) = @_;
        my $self = {"ax"=>$ax,
                    "ay"=>$ay,
                    "bx"=>$bx,
                    "by"=>$by,
                   }; 
        bless ($self, $class);
        return $self;
}
sub getA{
        #Issue on get A
        my $self = shift;
        return ($self->{ax}, $self->{ay});
}
sub getB{
        #Issue on get B
        my $self = @_;
        return ($self->{bx}, $self->{by});
}
sub setA{
        #Can print correct value. Is the return statement where it goes wrong?
        my($self, $ax, $ay) = @_;
        $self->{ax} = $ax if defined($ax);
        $self->{ay} = $ay if defined($ay);
        print "Setting ax: $self->{ax}\n";
        print "Setting ay: $self->{ay}\n";

        return ($self->{ax}, $self->{ay});
}
sub setB{
         #Can print correct value. Is the return statement where it goes wrong?
        my($self, $bx, $by) = @_;
        $self->{bx} = $bx if defined($bx);
        $self->{by} = $by if defined($by);
        return $self->{bx}, $self->{by};
}
1;

I am trying to create a class called LineSegment. ax and ay are a point and so are bx and by. I cannot get getA or getB to return what I want. They only return the second value, which would be ay for getA and by for getB. I want it to return both values (ax, ay) or (bx,by). How do I get it to do this? In my setA and setB methods, the values will print. However, could I be returning them wrong in setA and setB? Or does my problem lie in my getter methods?

Here is my main:

print "Starting Line Segment\n";
use LineSegment;
$line = new LineSegment(10,20,30,40);
$line->setA(15,10);
$a = $line->getA();
print "Point A is: $a\n";

Here is my Point class:

use strict;
use warnings;

#class name 
package Point;

#constructor
sub new
{
        my $class = shift;
        my($x, $y) = @_;
        my $self = {"x"=>$x,
                    "y"=>$y,
                   };
        bless ($self, $class);
        return $self;
}

sub getX{
        my($self) = @_;
        return $self->{x};
}
sub setX{
        my ($self, $x) = @_;
        $self->{x} = $x if defined($x);
        return $self->{x};
}
sub setY{
        my ($self, $y) = @_;
        $self->{y} = $y if defined($y);
        return $self->{y};
}
sub random{
        my $self = shift;
        my $range = 50;
        $self->{x} = int(rand($range));
        $self->{y} = int(rand($range));

        return ($self->{x}, $self->{y});
}
1;

Updated main:

use strict;
use warnings;

    use Point;
    use LineSegment;

    my $line = LineSegment->new(Point->new()->random, Point->new()->random);
    my $pointA = $line->getA;
    my $pointB = $line->getB;
    printf "Point = (%d,%d)\n", $pointA->getX, $pointA->getY;

Answer 1

As Tanktalus has pointed out, you are returning a list of two values and expecting to be able to treat it as a single Point object. A list in scalar context evaluates to the last element of the list, so you are getting just the Y coordinate

I've written some functioning code below. One thing that may confuse you is the hash slice syntax @{$self}{qw/ _x _y /} = @_ which is the same as

$self->{_x} = $_[0];
$self->{_y} = $_[1];

You should remember to use strict and use warnings at the top of every Perl source file. You should also avoid using $a and $b as they are used internally by Perl. Longer, more descriptive identifiers are better anyway

If I alter your Point.pm so that its constructor takes parameters (I have also fixed your random method) like this

Point.pm

use strict;
use warnings 'all';

package Point;

sub new {
    my $class = shift;

    my $self = { };
    @{$self}{qw/ _x _y /} = @_ if @_;

    bless $self, $class;
}

sub getX{
    my $self = shift;

    return $self->{_x};
}

sub getY{
    my $self = shift;

    return $self->{_y};
}

sub setX {
    my $self = shift;

    $self->{_x} = $_[0] if @_;

    return $self->{_x};
}

sub setY {
    my $self = shift;

    $self->{_y} = $_[0] if @_;

    return $self->{_y};
}

use constant RANGE => 50;

sub random {
    my $self = shift;

    $self->{_x} = int rand RANGE;
    $self->{_y} = int rand RANGE;

    return $self;
}

1;

and write LineSegment.pm like this

LineSegment.pm

use strict;
use warnings 'all';

package LineSegment;

sub new {
    my $class = shift;

    my $self = { };
    @{$self}{qw/ _pA _pB /} = @_ if @_;

    bless $self, $class;
}

sub getA {
    my $self = shift;

    return $self->{_pA};
}

sub getB {
    my $self = shift;

    return $self->{_pB};
}

sub setA {
    my $self = shift;

    $self->{_pA} = $_[0] if @_;

    return $self->{_pA};
}

sub setB {
    my $self = shift;

    $self->{_pB} = $_[0] if @_;

    return $self->{_pB};
}

1;

then I can write a program which does what I think you want like this

main.pl

use strict;
use warnings 'all';

use Point;
use LineSegment;

my $line = new LineSegment(
    Point->new(10, 20),
    Point->new(30, 40),
);

$line->setA( Point->new(15, 10) );

my $point = $line->getA;

printf "Point = (%d,%d)\n",
    $point->getX,
    $point->getY;

output

Point = (15,10)

Answer 2

my ($ax, $ay) = $line->getA();

getA() is returning a list of variables, you need to receive it into a list of variables. An array would work as well, but this is probably clearer.

But that's not really what you want. What you want to do is to have a line segment be made up of two Point objects (which you may have to create as well), and each Point object store its own x and y coordinates. And then you can return the points as objects, and query their x and y coordinates, e.g.:

my $a_point = $line->getA();
print "Point A is (", $a_point->getX(), ",", $a_point->getY(), ")";

(You can also have the Point class override stringification, but I suspect that's more than you want to think about just yet.)

Apologies for not catching this the first time, but not only are single-letter variable names poor taste in general, $a and $b are particularly bad in perl because they're reserved for the sort function. So I've renamed it here.

---

With your update, your Point class is missing the getY method. Your main script becomes:

use strict;
use warnings;
use LineSegment;

print "Starting Line Segment\n";
my $line = new LineSegment(10,20,30,40);
$line->setA(15,10);
my $p = $line->getA();
print "Point A is: (", $p->getX(), ",", $p->getY(), ")\n";

and your LineSegment.pm becomes:

package LineSegment;

use strict;
use warnings;
use Point;

sub new
{
    my $class = shift;

    my @points;
    if (@_ == 4)
    {
        @points = (
                   Point->new($_[0], $_[1]),
                   Point->new($_[2], $_[3]),
                  );
    }
    else
    {
        @points = @_;
    }
    my $self = \@points;
    bless ($self, $class);
    return $self;
}
sub getA{
    #Issue on get A
    my $self = shift;
    return $self->[0];
}
sub getB{
    #Issue on get B
    my $self = shift;
    return $self->[1];
}
sub setA{
    #Can print correct value. Is the return statement where it goes wrong?
    my $self = shift;
    my $point = $_[0];
    if (@_ > 1)
    {
        $point = Point->new(@_);
    }
    $self->[0] = $point;
}

sub setB{
    my $self = shift;
    my $point = $_[0];
    if (@_ > 1)
    {
        $point = Point->new(@_);
    }
    $self->[1] = $point;
}
1;

This may be a bit overkill, but the right answer is to only pass in/around Point objects in your LineSegment, and let the caller create the Point objects instead of massaging them in here. In my experience, this makes the whole thing clearer.

Answer 3

You have complete answers by Borodin and Tanktalus showing how to write this class, with other comments. They also emphasize that a segment class should fully utilize a point class.

This is an important point. We encapsulate a certain aspect of our problem in a class. Then we want to use that class for other aspects of the problem, and this is crucial in the object-oriented approach. It usually requires iterations in design and coding, to get those classes right.

This post demonstrates the process by adding a method for the length of a segment, what prompts addition of other methods. I also add a few other pieces to your classes

• A couple of utility methods are added in the Point class that are helpful for the length method, and that belong there in general. This is typical -- we desire new functionality and realize that the other classes should provide a part (or all) of it.

• Defaults are added to the constructors. Once new is called the objects should be initialized and ready to go, if possible. Your Point::random method is used for this.

• A setter and getter are combined in one method, which sets data when called with parameters

Some comments follow the code.

Point.pm

package Point;

use strict;
use warnings;

sub new {
    my $class = shift;
    my $self = { };
    bless $self, $class;           # now we can call methods on $self
    if (@_) {
        @{$self}{qw(_x _y)} = @_;  # initialize via parameters
    } else { 
        $self->random();           # initialize using random()
    }
    return $self;
}

sub x {
    my $self = shift;
    $self->{_x} = $_[0] if $_[0];  # set if parameter was passed
    return $self->{_x};
}

sub y {
    my $self = shift;
    $self->{_y} = $_[0] if $_[0];
    return $self->{_y};
}

sub coords {
    my $self = shift;
    @{$self}{qw(_x _y)} = @_ if @_;
    return $self->{_x}, $self->{_y};
}

sub distance {
    my ($self, $pt) = @_; 
    my ($x1, $y1) = $self->coords();
    my ($x2, $y2) = $pt->coords();
    return sqrt( ($x1 - $x2)**2 + ($y1 - $y2)**2 );
}

sub random {
    my $self = shift;
    my $range = $_[0] // 50;
    $self->{_x} = int rand $range;
    $self->{_y} = int rand $range;
    return $self;
}

1;

The random method takes an optional range, so both $pt->random() and $pt->random(10) set random coordinates for $pt. It has default 50, set using defined-or operator, //. Since it returns the object itself you can chain methods, like

my $pt = Point->new(10, 20);
my @coords = $pt->random()->coords();
print "@coords\n";

or, since new itself also returns the object, even

my @coords = Point->new()->random(10)->coords();

This wouldn't be of much use though as we now don't get the object.

LineSegment.pm

package LineSegment;

use strict;
use warnings;
use Point;

sub new {
    my $class = shift;
    my $self = { };
    bless $self, $class;
    if (@_) { @{$self}{qw(_pA _pB)} = @_ }
    else    { @{$self}{qw(_pA _pB)} = (Point->new, Point->new) }
    return $self;
}

sub pA {
    my $self = shift;
    $self->{_pA} = $_[0] if $_[0];
    return $self->{_pA};
}

sub pB {
    my $self = shift;
    $self->{_pB} = $_[0] if $_[0];
    return $self->{_pB};
}

sub pts {
    my $self = shift;
    @{$self}{qw(_pA _pB)} = @_ if @_;
    return @{$self}{qw(_pA _pB)};
}

sub len {
    my $self = shift;
    return $self->{_pA}->distance($self->{_pB});
}

1;

The default in the constructor calls Point's default constructor for each point, if no arguments were passed to initialize the segment object.

The len() method doesn't need coordinates, since we added distance() method to Point. It is natural and needed in a point class and this is better than having LineSegment compute. Often we need to calculate in the class, of course. Think of mid_point (of a segment), intersection (between two segments), etc.

main.pl

use warnings 'all';
use strict;
use feature 'say';

use Point;
use LineSegment;

my $line = LineSegment->new(
    Point->new(10, 20),
    Point->new(30, 40),
);

my $pt_A = $line->pA( Point->new(15, 10) );
my $pt_B = $line->pB;

printf "Point A = (%d,%d)\n", $pt_A->coords();
printf "Point B = (%d,%d)\n", $pt_B->coords();    
printf "Length of the segment: %.3f\n", $line->len();

my @coords = $pt_A->random(10)->coords();
say "Random point, set on existing object: @coords";

my $segm = LineSegment->new();
my @ends = $segm->pts();

print "Segment created with defaults, ends: ";
printf "(%d,%d) ", $_->coords()  for @ends;
say '';

This prints

Point A = (15,10)
Point B = (30,40)
Length of the segment: 33.541
Random point, set on existing object: 3 8
Segment created with defaults, ends: (34,19) (16,14)

What is notably missing here are checks of various kinds. However, once that becomes important one should probably start looking toward Moose or the similar but much lighter Moo.

---

A comment on new LineSegment() syntax used in the question.

A constructor in Perl is just a method, but the one that blesses the object into the class (package). The name new is indeed common but that is merely a convention. Thus the "normal" way to call a constructor is like any other method, ClassName->new().

One can use new ClassName, which is called "indirect object notation" (or syntax). However, here is what perlobj itself has to say about it (original emphasis)

Outside of the file handle case, use of this syntax is discouraged as it can confuse the Perl interpreter. See below for more details.

Also see this post and its links, for example. Just use ClassName->new().