my $foo;

sub leaky {
    my $closure = sub { $foo++ };
}
[download]

Does that complain under strict? I tried the following:

use strict;

my $foo = 0;
sub leaky
{
   my $closure = sub { $foo++ };
   return $closure;
}

my $x = leaky();
my $y = leaky();
print $y->(), $/ while $x->() < 10;
----
1
3
5
7
9
[download]

The output seemed to be correct ...

------
We are the carpenters and bricklayers of the Information Age.

Don't go borrowing trouble. For programmers, this means Worry only about what you need to implement.

The output is correct, but it eats up memory. If you keep looping on that sub, your machine will go into swap.

It does not leaks memory for me. Why should it?

I tried

my $foo;

sub leaky {
    my $closure = sub { $foo++ };
}
for (;;) {leaky}
[download]

for quite a long time and saw usage of constant memory.

Courage, the Cowardly Dog

Sorry, my mistake. They have to be nested anonymous subs, like this:

my $foo = 'asdf' x 1000;

for (1..900000) {
    my $outer_sub = sub {
        my $inner_sub = sub { $foo };
    }
}
[download]

Makeshifts last the longest.

$mw->Button(-text => "text", -command => sub { print "demo closure" })
+;
[download]

That's not a closure -- it's merely an anonymous sub reference.

This would be a closure being passed to a Tk function:

  sub make_counter { my $count = shift; sub { ++$count } }
  $mw->Button(-text => "count", -command => &make_counter(0)});
[download]

That in and of itself shouldn't produce leaks -- the closure will be deconstructed along with the Button deconstruction. I would imagine you need be wary of reference cycles, however, like this (functionally meaningless):

  sub make_ref_reporter { my $thing = shift; sub { ref $thing } }
  $mw->Button(-text => "refthing", -command => &make_ref_reporter($mw)
+);
[download]

Matt

Leak that perrin mentioned before was fixed in the latest development version of Perl, by patch id 18302.
This means 5.8.0 is not enough to avoid that leak, need more recent perl.

Courage, the Cowardly Dog