Scalar::Util
    and
Recent perl distributions without support for Scalar::Util::weaken() ?.

You'll also find a discussion in the section on references in "Learning Perl" (O'Reilly).

Unlike some other languages, Perl performs automatic garbage collection. Say you've defined a variable my $str = 'Hello world' then that needs to be stored in memory somewhere. When the variable goes out of scope, and Perl knows that it's not going to be used again, Perl's garbage collector can free the area of memory it was being stored in (so that the memory can be used for storing something else).

In some cases you end up with circular references:

my $a = [];
my $b = [ $a ];
push @$a, $b;
# Now $b contains a reference to $a and 
# $a contains a reference to $b.
[download]

OK, that's a contrived example, but circular references do come up in real code all the time:

sub marry
{
  my ($husband, $wife) = @_;
  $husband->set_spouse($wife);
  $wife->set_spouse($husband);
  $wife->parent[0]->pay_for_party;
}
[download]

Now perhaps the $wife object contains a reference to $husband and vice versa.

In cases like this, Perl's garbage collector perhaps considers freeing the memory used by $wife but sees that $wife is still being referred to by $husband, so it can't free that memory until $husband is destroyed. But when it considers freeing the memory used by $husband it sees that $husband is being referred to be $wife, so it can't free anything there either.

Technically the way Perl does this is by maintaining a "reference count" for each thing that's in memory - in other words, a count of how many variables and references are pointing at it.

This catch-22 situation prevents either of the objects being freed from memory until the program exits. In short-running programs, this is often not a problem. But for long-running processes, it results in a memory leak - the program's memory consumption grows and grows over time.

weaken (found in the Scalar::Util package, which has been bundled with Perl seince 5.7.3) breaks the catch-22. It allows you to mark a reference as "weak" in which case it won't count towards the reference count.

As somebody else pointed out, in the original code (but not your cut-down example), $wrapper forms a closure over itself, which is a type of circular reference. This will result in memory leaking each time once is called. (Though judging by the function name, it is presumably only called once?) Thus weaken is used to break the circularity (as far as the garbage collector is concerned), and prevent a memory leak.

I don't see any difference with or without weaken $wrapper;,what's it there for?

Where exactly?

How are you checking to see a difference?

$ perl -MDevel::Peek -MScalar::Util=weaken -le " sub fudge { my $f = s
+ub { print 1; }; Dump($f); weaken $f; Dump($f); $f; } $f = fudge(); $
+f->(); Dump($f);"
SV = IV(0x3f8d18) at 0x3f8d1c
  REFCNT = 1
  FLAGS = (PADMY,ROK)
  RV = 0x3f8cfc
  SV = PVCV(0x9a263c) at 0x3f8cfc
    REFCNT = 2
    FLAGS = (PADSTALE,PADMY,ANON,WEAKOUTSIDE,CVGV_RC)
    COMP_STASH = 0x3f8b5c       "main"
    START = 0x9d9178 ===> 0
    ROOT = 0x9d913c
    GVGV::GV = 0x99a9f4 "main" :: "__ANON__"
    FILE = "-e"
    DEPTH = 0
    FLAGS = 0x490
    OUTSIDE_SEQ = 272
    PADLIST = 0x99aa24
    PADNAME = 0x99aae4(0x9a7d1c) PAD = 0x3f8d0c(0x9a7b44)
    OUTSIDE = 0x99aa74 (fudge)
SV = IV(0x3f8d18) at 0x3f8d1c
  REFCNT = 1
  FLAGS = (PADMY,ROK,WEAKREF)
  RV = 0x3f8cfc
  SV = PVCV(0x9a263c) at 0x3f8cfc
    REFCNT = 1
    FLAGS = (PADSTALE,PADMY,RMG,ANON,WEAKOUTSIDE,CVGV_RC)
    MAGIC = 0x3fff2c
      MG_VIRTUAL = &PL_vtbl_backref
      MG_TYPE = PERL_MAGIC_backref(<)
      MG_OBJ = 0x3f8d1c
    COMP_STASH = 0x3f8b5c       "main"
    START = 0x9d9178 ===> 0
    ROOT = 0x9d913c
    GVGV::GV = 0x99a9f4 "main" :: "__ANON__"
    FILE = "-e"
    DEPTH = 0
    FLAGS = 0x490
    OUTSIDE_SEQ = 272
    PADLIST = 0x99aa24
    PADNAME = 0x99aae4(0x9a7d1c) PAD = 0x3f8d0c(0x9a7b44)
    OUTSIDE = 0x99aa74 (fudge)
1
SV = IV(0x9c2e40) at 0x9c2e44
  REFCNT = 1
  FLAGS = (ROK)
  RV = 0x3f8cfc
  SV = PVCV(0x9a263c) at 0x3f8cfc
    REFCNT = 2
    FLAGS = (PADSTALE,PADMY,RMG,ANON,WEAKOUTSIDE,CVGV_RC)
    MAGIC = 0x3fff2c
      MG_VIRTUAL = &PL_vtbl_backref
      MG_TYPE = PERL_MAGIC_backref(<)
    COMP_STASH = 0x3f8b5c       "main"
    START = 0x9d9178 ===> 0
    ROOT = 0x9d913c
    GVGV::GV = 0x99a9f4 "main" :: "__ANON__"
    FILE = "-e"
    DEPTH = 0
    FLAGS = 0x490
    OUTSIDE_SEQ = 272
    PADLIST = 0x99aa24
    PADNAME = 0x99aae4(0x9a7d1c) PAD = 0x3f8d0c(0x9a7b44)
    OUTSIDE = 0x99aa74 (fudge)
[download]

As you notice, REFCNT doesn't change :)

Yeah, that is not a use case for weaken, you use weaken when you have circular references, say

my $foo = { kid  => { } };
$foo->{kid}{parent} = $foo;
weaken $foo->{kid}{parent};
[download]

The actual code is the sub once of Mojo::EventEmitter

https://github.com/kraih/mojo/blob/master/lib/Mojo/EventEmitter.pm

The author must have done this for some reason...

The author must have done this for some reason...

Because in the real code, unlike your simplification of it, the weakened sub reference forms a closure over itself:

  $wrapper = sub {
    $self->unsubscribe($name => $wrapper);
    $cb->(@_);
  };
[download]

Ie. It contains a circular reference which would leak memory without the weakening.

For example, with the weaken commented, this leaks like a sieve:

#! perl -slw
use strict;
use Scalar::Util qw[ weaken ];

sub once {
    my $wrapper;
    $wrapper = sub {
        return $wrapper->();
    };
#    weaken $wrapper;
    return $wrapper;
}

once for 1 .. 1e9;
[download]

---

With the rise and rise of 'Social' network sites: 'Computers are making people easier to use everyday'

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

The start of some sanity?

The actual code is the sub once of Mojo::EventEmitter

The author must have done this for some reason...

Yeah, well Mr. Sherlock, that code is different than what you posted. The reason is always the same, circular references prevent release of memory

{
   my $foo = {}; # ref count 1
   $foo->{foo} = $foo; # ref count 2
} ### $foo goes out of scope here, memory should be released to perl
# here, $foo is not addressable (you can't refer to it by $foo),
# but its memory is not released until exit
# because there is still a reference to $foo 
# it refers to it self, its self-referential,  a circular reference
# for memory held by $foo to be released after $foo goes out of scope
# $foo->{foo} has to be weakened, the reference count decreased
[download]

The actual code, which you should have copy/pasted to get a reasonable answer, since editing code you don't understand changes its meaning

sub once {
  my ($self, $name, $cb) = @_;

  weaken $self;
  my $wrapper;
  $wrapper = sub {
# a special kind of circular reference
# CLOSURE, $wrapper keeps $self alive after return $wrapper (REFCNT+1)
# $wrapper refers to itself, CIRCULAR REFERENCE
    $self->unsubscribe($name => $wrapper);
    $cb->(@_);
  };
  $self->on($name => $wrapper); # potential CIRCULAR REFERENCE (on pro
+bably also stores $wrapper, but it probably also uses weaken )
  weaken $wrapper;

  return $wrapper;
}
[download]

How do I post a question effectively? says, when reducing code size, reduce to the essence, don't change the essence :)