Example one:

open(FILE, '>', 'temp.txt')
   or die("Can't create output file: $!");

greet(*FILE);

sub greet {
   my ($fh) = @_;
   print $fh "Hello World\n";
}
[download]

Example two:

sub foo { print("Hello World\n"); }

*bar = \&foo;

bar();
[download]

Most scripts don't use typeglobs. They just reap the benefits of very special modules which use them. For example, Exporter and constant might use typeglobs to import the symbols into the caller's namespace.

The top example can be rewritten without typeglobs. It's safer without them.

open(my $file, '>', 'temp.txt')
   or die("Can't create output file: $!");

greet($file);

sub greet {
   my ($fh) = @_;
   print $fh "Hello World\n";
}
[download]

Note how greet didn't change? Where file handles are concerned, typeglobs, ref to typeglobs and IO::Handle objects are almost always interchangable.

Answer to udpated question:

When used as a file handle:

• Pro: Lexicals can't be localized (but they can be block scoped).
• Con: Typeglobs can't be blocked scoped (but they can be localized).
• Pro: open LEXICAL, ... requires 5.6 or greater.
• Con: The name isn't checked at run-time, so typos are harder to find. However, you will get a compile-time warning if the typo isn't repeated or pasted. For example,
  perl -Mstrict -w -e "my $fh = *STDOOUT; print $fh 'moo'"
  

When used as a tied file handle:

• I think you have no choice but to use a typeglob if you want a tied file handle.

When used to alias function:

• There's no other way without using eval EXPR.

When used to alias other things:

• There's no other way.

When used as a tied file handle:

• I think you have no choice but to use a typeglob if you want a tied file handle.

As of 5.8.0, filehandle ties are attached to the IO handle, not the typeglob, so you can tie even globless lexical filehandles:

use Tie::Handle;
use Symbol "geniosym";
my $fh = geniosym;
tie *$fh, "Tie::StdHandle" or die;
print tied(*$fh);
[download]

The * is required only to let tie/tied know you want a filehandle tie, not a scalar tie; no actual typeglobs are used, except temporarily.

To answer the update - the only time I use typeglobs is when I've chosen a bad name for a function, and want to deprecate it. I'll rename the function, and create the aliased function:

    our *old_name = \&new_name;
[download]

    our *some_func = \&Other::Module::some_func;
[download]

In Seven Useful Uses of local, Tachyon demonstrates a pretty neat way of accomplishing just that.

my $filehandle = do { local *FH };
[download]

do just introduces a block which will be evaluated, and will return the value of the last expression that it contains, which in this case is local *FH. The value of local *FH is a glob. But what glob?

local takes the existing FH glob and temporarily replaces it with a new glob. But then it immediately goes out of scope and puts the old glob back, leaving the new glob without a name. But then it returns the new, nameless glob, which is then stored into $filehandle. This is just what we wanted: A glob that has been disconnected from the symbol table.

#!/usr/bin/perl -w

use strict;

local *FILE;

open( FILE, ">log.txt" ) or die "Unable to open log!\n$!\n";

sub print_log {
  my $fh = shift;
  my $message = shift;

  print $fh $message;
}

&print_log( *FILE, "Hello!\n" );

print FILE "All done!\n";

close FILE or die "Unable to properly close log!\n$!\n";
[download]

Maybe Re: Simple Pass By Reference is what you are alluding to?