If Perl were a functional programming language, I would expect this:

my @twice= map $doubler->($_), @list;
my @thrice= map $tripler->($_), @list;
[download]

my @twice= map 2*$_, @list;
my @thrice= map 3*$_, @list;
[download]

Perl just has a preference for non-functional techniques. map is one example. If you happen to have a closure, then map requires you to write more code. If Perl were a functional programming language, then you'd probably have to create a closure if you had a code block that you wanted to use with map.

Yes, you can build closures which hold other closures. Every once in a while I run into some bizarre situation where that is really, really useful.

Closures of closures can also be wickedly hard to debug.

As Tom Christiansen says, You can solve any programming problem with an extra level of indirection, except the problem of too many levels of indirection.

A closure is a level of indirection. "I will take some action" but the action to take is defined elsewhere. When you start to layer levels of indirection, it becomes critical to know what each layer is supposed to do, and that each layer does its job absolutely correctly. This is true no matter what the layers of indirection are.

However with closures it is easy to produce an astonishing number of layers of indirection in very little code. When you write a recursive function that generates closures out of closures, it basically has to work perfectly or it will do something totally bizarre...

Caveat hacker. :-)