This will do it, but I don't know how you would score it for comparison.

perl -anF"\|" -le"$f{shift@F}=[@F[1..$#F]]" pipe.txt
[download]

And you need this to prove it worked

P:\test>perl -MData::Dumper -anF"\|" -le"$f{shift@F}=[@F[1..$#F]]}{pri
+nt Dumper \%f" pipe.txt
$VAR1 = {
          '6' => [
                   'foo',
                   'bar',
                   'bax'
                 ],
          '3' => [
                   'foo',
                   'bar',
                   'bax'
                 ],
          '7' => [
                   'foo',
                   'bar',
                   'bax'
                 ],
          '9' => [
                   'foo',
                   'bar',
                   'bax'
                 ],
          '2' => [
                   'foo',
                   'bar',
                   'bax'
                 ],
          '8' => [
                   'foo',
                   'bar',
                   'bax'
                 ],
          '1' => [
                   'foo',
                   'bar',
                   'bax'
                 ],
          '4' => [
                   'foo',
                   'bar',
                   'bax'
                 ],
          '10' => [
                    'foo',
                    'bar',
                    'bax'
                  ],
          '5' => [
                   'foo',
                   'bar',
                   'bax'
                 ]
        };
[download]

very nice, but unfortunately my command line doesn't like it at all:

Bareword found where operator expected at -e line 1, near "0F"
        (Missing operator before F?)
syntax error at -e line 1, near "}="
Execution of -e aborted due to compilation errors.
[download]

This is how you'd score it:

#1234567890123456789012345678901234567890123456789012345
perl -anF"\|" -le"$f{shift@F}=[@F[1..$#F]]" pipe.txt
[download]

42.

my command line doesn't like it at all

Then adapt it to your shell. Something like this might work,

perl -anF'|' -le'$f{shift@F}=[@F[1..$#F]]' pipe.txt
[download]

but I don't use your shell so that is a guess, and I cannot test it as it wouldn't work on my shell.

This is how you'd score it:

That doesn't seem quite fair, as to use your example, you would need at least this to make it work:

#!/usr/bin/perl
#12345678901234567890123456789012345678901234567890123456789012345
open SRC, '<pipe.txt';%prod=map{chomp;split/\|/;shift@_,[@_]}<SRC>
[download]

Which I get to be a total of 89 and that's without the command line to run it!

---

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

Lingua non convalesco, consenesco et abolesco. -- Rule 1 has a caveat! -- Who broke the cabal?

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

This will do it, but I don't know how you would score it for comparison.

Well, no matter how you score it, I gotcha by two. :-)

perl -F'\|' -lane'($k,@v)=@F;$f{$k}=[@v]'
[download]

-sauoq
"My two cents aren't worth a dime.";

Update: Oh crap!

In that case, gotcha by 1 :)

perl -F'\|' -lane'($k,@v)=@F;$f{$k}=\@v'
[download]

---

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

Lingua non convalesco, consenesco et abolesco. -- Rule 1 has a caveat! -- Who broke the cabal?

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

perl -MData::Dumper -lanF'\|' -e '$p{$F[0]}=[@F[1..$#F]]}END{print Dum
+per \%p' abcd
[download]

Assuming standard golfing rules where you give the body of a function that takes whatever parameters are useful:

#!/usr/bin/perl
my %p;

sub func {
my($x,@x)=$_[0]=~/([^\|\n]+)/g;$p{$x}=\@x
# Or ...
chomp(my($x,@x)=split'\|',pop);$p{$x}=\@x
}

open SRC, 'abcd';
while (<SRC>) {
    func($_);
}

use Data::Dumper;
print Dumper \%p;
[download]

Your first solution will misbehave if you run across a line like:

foo||bar
[download]

Your second solution can be shortened by 3 characters:

sub func {
#23456789_123456789_123456789_12345678
chomp(@_=split'\|',pop);$p{+shift}=\@_
}
[download]

and one more if you're willing to replace chomp with chop.

this fails by giving an empty hash entry.

$VAR1 = {
          '' => [],
          'aaa' => [
                     'bbb',
                     'ccc'
                   ],
          'foo' => [
                     'bar',
                     'baz'
                   ]
        };
[download]

I see more than 41 characters because you say while (<SRC>) { } In my solution, the filehandle is part of the solution character count. If I put my solution in the context of yours it looks like this:

sub parse{
#12345678901234567890123456789012345678901234567890
%p=map{chomp;split/\|/;shift@_,[@_]}@_
}
parse(<SRC>);
[download]

and is 37 characters.

Save a couple of chars by taking advantage of the fact that shift defaults to @_ while in a sub.

%p=map{chomp;split/\|/;shift,[@_]}@_
[download]

Using chop instead of chomp would help, but might not be portable.

---

Caution: Contents may have been coded under pressure.