If what's within the angle brackets is neither a filehandle nor a simple scalar variable containing a filehandle name, typeglob, or typeglob reference, it is interpreted as a filename pattern to be globbed, and either a list of filenames or the next filename in the list is returned, depending on context. This distinction is determined on syntactic grounds alone. That means <$x> is always a readline() from an indirect handle, but <$hash{key}> is always a glob(). That's because $x is a simple scalar variable, but $hash{key} is not--it's a hash element.

I think the best you can do is use IO::Handle and then call getline on it instead.

#!/usr/bin/perl
use strict;
use warnings;
use Data::Dumper;
use IO::Handle;

open my $fh, '<', $0
    or die "Can't read myself: $!\n";
my $self = { fhFrom => $fh };
my $fh2 = ${$self}{fhFrom};
my %line_from;
chomp( $line_from{var} = <$fh2> );
chomp( $line_from{expr} = <${$self}{fhFrom}> );
chomp( $line_from{graff} = <$$self{fhFrom}> );
chomp( $line_from{getline} = $self->{fhFrom}->getline );

print Dumper \%line_from;
__END__
$VAR1 = { 
          'var' => '#!/usr/bin/perl'
          'graff' => 'GLOB(0x504290)',
          'getline' => 'use strict;',
          'expr' => 'GLOB(0x504290)',
        };
[download]

I don't know the nuts and bolts of it, but once the "stuff" inside <stuff > gets "too complicated", it treats it like glob.

while (< $$self{fhFrom} >) {
[download]

perl -e 'open(my $fh,".bashrc");$h={ f => $fh };while(<$$h{f}>){print}
+'
[download]

Assigning the hashref value to a temporary scalar variable seems to be the only way to make the diamond operator do what you expect it to do. I think I've seen an explanation for this somewhere...

ANOTHER UPDATE: It seems that it is not the dereference ($$ref{key} or $ref->{key}) that causes the problem -- it's just the presence of anything other than a plain scalar variable:

$ perl -MData::Dumper=Dumper -e 'open(my $fh,".bashrc") or die;
 my %h=(f => $fh);print Dumper(\%h); while(<$h{f}>){print}'

$VAR1 = {
          'f' => \*{'::$fh'}
        };
GLOB(0x800d80)

$ perl -MData::Dumper=Dumper -e 'open(my $fh,".bashrc") or die;
 my @h=($fh);print Dumper(\@h); while(<$h[0]>){print}'

$VAR1 = [
          \*{'::$fh'}
        ];
GLOB(0x800d80)
[download]

I went down exactly the same path resulting in printing globs and other odd stuff before posting. Sorry, I should have mentioned that and saved you some time. AnonyMonk has nailed it with Re: Seeking balance from the <> operator. Assignment to a scalar is what it has to be.

---

Perl is environmentally friendly - it saves trees

The recourse to a temp variable or readline is really unavoidable as explained by this piece of perlop:

If what's within the angle brackets is neither a filehandle nor a simple scalar variable containing a filehandle name, typeglob, or typeglob reference, it is interpreted as a filename pattern to be globbed, and either a list of filenames or the next filename in the list is returned, depending on context. This distinction is determined on syntactic grounds alone. That means <$x> is always a readline() from an indirect handle, but <$hash{key}> is always a glob(). That's because $x is a simple scalar variable, but $hash{key} is not--it's a hash element. Even <$x > (note the extra space) is treated as glob("$x "), not readline($x).