From perlop

If what the angle brackets contain is a simple scalar variable (e.g., <$foo>), then that variable contains the name of the filehandle to input from, or its typeglob, or a reference to the same. For example:

      $fh = \*STDIN;
      $line = <$fh>;
[download]

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.

tlm is correct. So you need to do the following:

sub from_handle {
    my $self = shift;
    my %opts = @_;
    my $fh = $opts{-handle};
    while (<$fh>) {
        #... and here we're supposed to read from FH
    }
}
[download]

-derby

What you saw is the stringification, which is not necessarily the same thing. For instance:

my $x = \*FH;
print "plain glob ref: <$x>\n";
# prints: plain glob ref: <GLOB(0x1d6c660)>
open ($x, "<","somefile") or warn "error\n";
print "open FH ref: <$x>\n";
# prints: open FH ref: <GLOB(0x1d6c660)>
[download]

my $x = \*FH;
x $x
# prints: 
#0  GLOB(0x1d6c408)
#   -> *main::FH
open ($x, "<","somefile") or warn "error\n";
print "open FH ref: <$x>\n";
# prints: 
0  GLOB(0x1d6c408)
   -> *main::FH
         FileHandle({*main::FH}) => fileno(6)
[download]

What do you get in your code?

How do you know what $_ really is in your program?

I can see that get printed on milk cartons one day :) (Talk to your children! A message from the government of Canada.)

Anyway, all kidding aside, here's what I'm doing, and now It Just Works, so thank you all for your thoughts and input. The calling sub:

#... blah blah blah
            open(FH, $opts{-file});
            $opts{-handle} = *FH;
            return $parser->from_handle(%opts);
#... la dee da
[download]

And the callee:

#... stick out left leg
    while ( readline($opts{-handle}) ) {
        if ( $_ ) {
            # ... frobnicate
        }
    }
# return right leg
[download]

It may work for you now, but do you know why? You've fixed it, but can you duplicate it in other contexts?

I notice that you no longer take a reference to a glob, but the glob directly. My quick check shows that this works (though the glob reference shows more info in the debugger with the x command).

-QM
--
Quantum Mechanics: The dreams stuff is made of

use IO::File;

$opts{-handle} = IO::File->new($opts{-file}) or die $!;
$parser->from_handle(%opts);

sub from_handle {
    my $self = shift;
    my %opts = @_;
    while (<$opts{-handle}>) {
        #... and here we're supposed to read from FH
    }
}
[download]

Thank you both for your replies. So, I tried IO::File, and now $_ in the while loop contains "IO::File=GLOB(0xa1f08c4)". I hope I'm not being terribly dim here - I really appreciate your help, but this doesn't quite get me there yet. Any other hints?

What tlm neglected to mention was what you should do :)

Because <> can do two different things, readline and glob (and in your case is doing the wrong one), you should explicitly say while(readline($opts{-handle})).

What exactly do you have in the <> brackets? Can you post the code?

Also, now that you're using IO::File you can use its getline method instead of angle brackets to do linewise input. This eliminates the ambiguity with file globbing. See the docs for IO::File parent class, IO::Handle.

the lowliest monk