For the quick rundown:
Sub routines can be referenced, and then later dereferenced for access. Useful if you need to create an option handler or something:

$opt = "opt" . $ARGV[0];

$subhash = {
    opt1 => sub { print "This is option one"; },
    opt2 => sub { print "This is options two"; }
};

# indicate a function when dereferencing with &
&{$subhash->{$opt}};
[download]

#!/usr/bin/perl
use strict;
use warnings;

sub countdown_iterator {
    my $start = shift;
    return sub { $start-- };
}
my $countdown = countdown_iterator( 10 );
while ( my $time = $countdown->() ) {
    print "T - $time\n";
}
print "Blast off\n";
[download]

I knew less about them than you, but here are some interesting documents:

http://perlmonks.org/index.pl?node=Anonymous+Subroutine&go_button=Search
http://www.wdvl.com/Authoring/Languages/Perl/ProPerl/properl1-2.html
http://www.sanger.ac.uk/Users/jgrg/CCP11_Perl_Course/PerlObjects/slide_03.html
http://www.itworld.com/nl/perl/08302001/
http://www.stonehenge.com/merlyn/UnixReview/col08.html

I hope this helps.

Update Steve_p - turned URLs into real links

If you put [ ] around those URLs they will be usuable as links. (The perlmonks one would preferably be [href://?node=Anonymous+Subroutine&go_button=Search], which should form a link using whichever of (www.)?perlmonks.(org|com|net) the reader is using so that their logon cookie is properly used.)

Well I'm not certain what exactly you're looking for. They are closely related to references so something like this:

my $bar = sub { # do something here };
$bar->(); # executes the stuff in the anonymous sub above
[download]

sub foo {
     # do something here
}

my $bar = \&foo;
$bar->(); #executes the stuff in foo()
[download]

I like to use a dispatch table in web apps that uses either anonymous subs or sub references. Like so:

my %actions = (
     foo => \&do_foo, # some long operation
     bar => sub { # some short one line thing },
     default => sub { # do something by default },
);

my $request = $cgi->param('request');
if( exists($actions{ $request } )) {
     $actions{ $request }->();
}
else {
     $actions{ default }->();
}
[download]

Hope that gives you an idea of what's going on.

Let me try to give you a different perspective on anonymous subs than you've gotten so far. (Not that what's been written is bad, wrong, or inaccurate; it's all very good stuff. But it's not the whole story.)

Perl allows you to treat functions as first-class data objects -- you can pass them to other functions, return them, store (references to) them, and generate them on the fly. This is difficult to handle with the usual symbol table mechanism (named functions that you call just like builtins), so Perl lets you store (refs to) functions in scalars. This is where you get anonymous functions: functions that aren't in the symbol table.

Here's an example: suppose you're turning Usenet-style text (*bold*, _italics_,, etc) into HTML-style markup. One way to do it would be to write a bunch of conversion functions:

sub translate_bold { ... }
sub translate_italics { ... }
...
[download]

sub build_trans
{
  my ($usenet, $tag) = @_;

  return sub {
    my ($text) = @_;
    # do translation here, using $usenet and $tag
  }
}
[download]

while (my $pat = &read_trans_pattern($cfg)) {
  $trans_funcs{$pat->{'usenet'}} = 
    &build_trans_func($pat->{'usenet'}, $pat->{'tag'});
}
[download]

This may seem unnecessarily complex, but what it does is keep the complexity in a small part of your code -- the translation-function builder -- rather than spread it out over dozens of functions.

But the most usefult thing of anonymous sub is closure:

sub foo {
  my ( $arg ) = @_ ;
  
  my $bar = sub {
    print "ARG[$arg]\n" ;
    return "RE[$arg]" ;
  } ;
  
  return $bar ;
}

  my $bar1 = foo(123) ;
  my $bar2 = foo(456) ;
  
  my $foo1 = &$bar1() ;
  my $foo2 = &$bar2() ;
  
  print "foo1: $foo1\n" ;
  print "foo2: $foo2\n" ;
[download]

ARG[123]
ARG[456]
foo1: RE[123]
foo2: RE[456]
[download]

  my $e = 10 ;
  my $sub = eval(" sub { return 2**$e } ") ;
[download]

  sub foo { print "foo\n" ;}
  # now redefining it:
  *foo = sub { print "bar\n" ;}
[download]

           use File::Find;
           find(\&wanted, @directories_to_search);
           sub wanted { ... }
[download]

(There's a strong argument that this File::Find interface was a bad idea, and it has a number of competitors these days like File::Find::Rule, but still if you're working on existing code, you're likely to see File::Find used.)

Maybe you should try and give us a better idea of what you don't get about anonymous subs...