How to use plain arrays with Perl Moose

MyRealArray.pm

package MyRealArray;
use Moose;
use namespace::autoclean;

has 'arr' => (
    is      => 'rw',
    isa     => 'ArrayRef',
    default => sub { [] },
);

# sub to assign a plain old array to arr
# called by my $mra=MyRealArray->new();my @arr = (1,2,3); $mra->set_arr(@arr);
sub set_arr {
    my ( $self, @arr ) = @_;
    $self->arr( \@arr );
}

# sub to return a plain old array from arr
# called by my $mra=MyRealArray->new();my @arr = $mra->get_arr();
sub get_arr {
    my ($self) = @_;
    return @{$self->arr};
}

# sub to assign an array reference to arr
# called by my $mra=MyRealArray->new();my @arr = (1,2,3); $mra->set_arr_using_ref(\@arr);
sub set_arr_using_ref {
    my ( $self, $arr_ref ) = @_;
    $self->arr($arr_ref);
}

# sub to return an array reference from arr
# called by my $mra=MyRealArray->new();my $arr_ref = $mra->get_arr_as_ref();
sub get_arr_as_ref {
    my ($self) = @_;
    return $self->arr;
}

# set_array_internally to 3 numbers and return nothing
# called by my $mra=MyRealArray->new();$mra->set_array_internally();
sub set_array_internally {
    my ($self) = @_;
    my @new_array = ( 3, 7, 6 );
    $self->arr(\@new_array);
}

# access_elements_internally by returning the 3rd element arr
# called by my $mra=MyRealArray->new();my $third_element = $mra->access_elements_internally();
sub access_elements_internally {
    my ($self) = @_;
    my $value = $self->arr->[2];
    return $value;
}

# operate_on_array_internally_normally returns string of array elements with \n after each
# the idea is to make a @arr coz it's easier to work with
# called by my $mra=MyRealArray->new();my $string = $mra->operate_on_array_internally_normally1();
sub operate_on_array_internally_normally1 {
    my ($self) = @_;
    my $arr_ref = $self->arr;
    my @arr = @$arr_ref;

    my $string;
    foreach my $elem (@arr) {
        $string .= $elem . "\n";
    }
    return $string;
}

# another way to work with @arr in a sub
sub operate_on_array_internally_normally2 {
    my ($self) = @_;
    my @arr = @{$self->arr};

    my $string;
    foreach my $elem (@arr) {
        $string .= $elem . "\n";
    }
    return $string;
}

# operate_on_array_internally_using_moose returns string of array elements with \n after each
# the idea is to use Moose's array methods
# called by my $mra=MyRealArray->new();my $string = $mra->operate_on_array_internally_using_moose();
sub operate_on_array_internally_using_moose {
    my ($self) = @_;
    my $string;
    foreach my $elem ( @{ $self->arr } ) {
        $string .= $elem . "\n";
    }
    return $string;
}

# demonstrate how to use $#arr
# called by my $mra=MyRealArray->new();my $string = $mra->use_dollar_hash();
sub use_dollar_hash {
    my ($self) = @_;
    my $string;
    my $last_index = $#{ $self->arr };
    foreach my $index ( 0 .. $last_index ) {
        $string .= $self->arr->[$index] . "\n";
    }
    return $string;
}

# where you'd use $#arr in a normal code, you can use scalar and - 1
sub use_dollar_hash2 {
    my ($self) = @_;
    my $string;
    my $i = 0;
    my $last_index = scalar( @{ $self->arr } ) - 1;
    # in a normal code, this would be $i <= $#arr
    while ( $i <= $last_index ) {
        $string .= $self->arr->[$i++] . "\n";
    }
    return $string;
}

# demonstrate push
# called by my $mra=MyRealArray->new();$mra->demonstrate_push();my $string=$mra->get_arr()
sub demonstrate_push {
    my ($self) = @_;
    my $val = 6;
    push @{ $self->arr }, $val;
}

# sub demonstrate_splice
# name the sub demonstrate_splice
# called by my $mra=MyRealArray->new();$mra->demonstrate_splice();my $string=$mra->get_arr()
sub demonstrate_splice {
    my ($self) = @_;
    my $index = 1;
    my $length = 2;
    my @replacement = ( 9, 8, 7 );
    splice @{ $self->arr }, $index, $length, @replacement;
}






__PACKAGE__->meta->make_immutable;

1;