my($scalar, @restofarray) = @array;
[download]

my $scalar = shift(@array);
[download]

disclaimer: ignoring differences between arrays and lists for the sake of simplicity

Perl allows many ways, depending on whether you want Haskell-style list partition, or imperative list manipulation:

# Haskell programmer:
my ($head,@tail) = @list;

# Shell programmer
my ($head) = shift @list;
my @tail = @list;

# Perlfunc Author
($head) = splice @list, 0, 1;
@tail = @list;
[download]

Put $head in list context for the splice example

You left out "C programmer":

/\* how are we supposed to declare the size of variables again? */;
my $head; /\* scalar (could be number OR string) */;
my @tail; /\* array of scalars (could be numbers or strings, and grows
+ dynamically) */;
$head = $list[0]; /\* why isn't this @list[0] ? */;
for (my $i = 1; $i <= $#list; $i++) {
  $tail[$i - 1] = $list[$i];
}
[download]

-- Randal L. Schwartz, Perl hacker
Be sure to read my standard disclaimer if this is a reply.

...and Java Programmer:

Package ArraySeperator;

sub new {
    my ( $class, @rest ) = @_;
    my $self = [@rest];
    bless $self, $class;
    return $self; 
}

sub head {
    my $self = shift;
    return $self->[0];
}

sub rest {
    my $self = shift;
    my $size = scalar @$self;
    return @$self->[ 1 .. $size ];
}

Package main;

my $head;
my @rest;
my $seperator = ArraySeperator->new( @list );

$head = $seperator->head();
@rest = $seperator->rest();
[download]

Update:
merlyn, that is not part of the joke. You just have too good of an eye, I guess! It's fixed now. Thanks!

$self->[ 1 .. $size ];
[download]

So, is part of the joke that this doesn't work at all? Perhaps you wanted @$self[1..$size]?

-- Randal L. Schwartz, Perl hacker
Be sure to read my standard disclaimer if this is a reply.

s/Package/package/ :)

shift and splice don't work on lists.

These only work on arrays:

# Haskell programmer:
my ($head, @tail) = @array;

# Shell programmer
my $head = shift @array;
my @tail = @array;

# Perlfunc Author
my $head = splice @array, 0, 1;
my @tail = @array;
[download]

These work on lists (including arrays):

# Haskell programmer:
my ($head, @tail) = list;

# Shell programmer
my @tail = list;
my $head = shift @tail;

# Perlfunc Author
my @tail = list;
my $head = splice @tail, 0, 1;
[download]

By the way, there's no need to put $head in list context for this splice.

Are you sure you don't want to use Lisp? :)

Frank Antonsen had an article about this is The Perl Review 1.1 when he talked about "Functional Programming in Perl".

Besides getting the head and tail of a list, you also have to decide if you want the original array to stay intact.

Non-destructive

You can keep the original array as it is with a bit of copying.

my( $head, @tail ) = @array;
[download]

Destructive

my $head = shift @array;
my @tail = @array
[download]

#!/usr/bin/perl -w

my @list = qw( 1 2 3 4 5 );

my @head = $list[0];
my @tail = @list[1..$#list];

print "List: $_\n" foreach @list;
print "Head: $_\n" foreach @head;
print "Tail: $_\n" foreach @tail;

__END__
List: 1
List: 2
List: 3
List: 4
List: 5
Head: 1
Tail: 2
Tail: 3
Tail: 4
Tail: 5
[download]