Brilliant, Closure on Closures did it for me. The summing up in particular...

a closure is a subroutine which wraps around lexical variables that it references from the surrounding lexical scope which subsequently means that the lexical variables that are referenced are not garbage collected when their immediate scope is exited

This story has a sad end, however. To test my knowledge new-found knowledge, I wrote the following.

sub make_two_counters {
    my $count = 0;
    return sub{ $count++ }, sub{ $count+=10 }
}

my ($counter_plus_one, $counter_plus_ten) = make_two_counters();
print $counter_plus_one->() . "\n";
print $counter_plus_one->() . "\n";
print $counter_plus_ten->() . "\n";
print $counter_plus_one->() . "\n";
print $counter_plus_one->() . "\n";

__OUTPUT__
0
1
12
12
13
[download]

I was expecting this to print 0,1,11,12,13 - on the grounds that my two anonymous subs would be saving the same reference to the lexical ($count). But it seems to have merged two of my adds in together!! Help.

BTW: Thanks for all the replies ++

---
my name's not Keith, and I'm not reasonable.

reasonablekeith,
Here is a clue - what happens when you forget about closures and run the following code?

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

my $cnt = 0;
print $cnt++, "\n";
print $cnt++, "\n";
print $cnt += 10, "\n";
print $cnt++, "\n";
print $cnt++, "\n";
[download]

The ++ operator (see perlop) first retrieves the current value and then increments the value when used as post-increment.
• Start at 0
• Return 0, make $cnt 1
• Return 1, make $cnt 2
• Return 2 + 10, make $cnt 12
• Return 12, make $cnt 13
• Return 13, make $cnt 14

Cheers - L~R

I was expecting this to print 0,1,11,12,13 - on the grounds that my two anonymous subs would be saving the same reference to the lexical ($count). But it seems to have merged two of my adds in together!! Help.

Your closures are correct. However, you're confused about something else. $count++ will return the value of $count, then add 1 to it. $count+=10 will add 10 to count, then return the value of $count.

Try the following:

my $count = 0;
sub make_two_counters {
    return sub{ $count++ }, sub{ $count+=10 }
}

my ($counter_plus_one, $counter_plus_ten) = make_two_counters();
print $counter_plus_one->() . " ($count)\n";
print $counter_plus_one->() . " ($count)\n";
print $counter_plus_ten->() . " ($count)\n";
print $counter_plus_one->() . " ($count)\n";
print $counter_plus_one->() . " ($count)\n";

__OUTPUT__

0 (1)
1 (2)
12 (12)
12 (13)
13 (14)
[download]

Does that help?

---

My criteria for good software:

1. Does it work?
2. Can someone else come in, make a change, and be reasonably certain no bugs were introduced?

They are sharing the same lexical. What confuses you is the fact that you are doing post-increment. The result of $count++ is the old value of $count. Change that line to ++$count, and try again.

    return sub {$count++}
[download]

The my $var statement is also like a dynamic variable constructor. Every time you get to a my declaration, a brand new variable is created. Since you construct the closure inside this sub:

sub count_maker {
    my $count = shift;
[download]

There are several things different about your other example. First, the non-anonymous form of sub name { ... } works a little differently. It generates a new sub at compile time, not at runtime when the statement is reached. That's why you can call a named sub that is defined lower down in the file. Also, you have two different $count variables in different scopes. The counter sub is always pointing to the one defined inside the do {} block, not the one in the calling scope. Also, the $count variable that is actually referenced in the sub is never redeclared (the do {} block is never entered more than once).

Here's another example that might be enlightening:

{
  my $count1; ## only one copy of $count1 ever created, so
              ## it's shared by all closures created below

  sub count_maker {
    my $count2 = shift; ## $count2 is a different var each time
                        ## each time we enter count_maker

    return sub { ($count2++, $count1++) }
  }
}

my $c1 = count_maker(1);
my $c2 = count_maker(5);

print join " ", $c1->(), $/;
print join " ", $c2->(), $/;
print join " ", $c2->(), $/;
print join " ", $c1->(), $/;
print join " ", $c1->(), $/;

__OUTPUT__
1 0 
5 1 
6 2 
2 3 
3 4
[download]

Actually, the purists will say that it is a closure. A closure (technically) does not have to be a lambda / anonymous sub / dynamically generated sub.

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

package Class::GetSet;

sub new { my $class = shift; return bless({@_}, $class) }
sub __set { $_[0]->{ $_[1] } = $_[2] }
sub __get { return $_[0]->{ $_[1] } }

use vars qw($AUTOLOAD);

sub AUTOLOAD
{
   no strict 'refs';
   if ($AUTOLOAD =~ /^.*::(\w+)$/o && exists $_[0]->__has->{$1}->{'rea
+d'} )  {
                my $attr = $1;
                *{$AUTOLOAD} = sub { my $s = shift; return ($s->__get(
+$attr, @_)) };
                goto &$AUTOLOAD;
        } elsif ($AUTOLOAD =~ /^.*::set_(\w+)$/o && exists $_[0]->__ha
+s->{$1}->{'write'} ) {
                my $attr = $1;
                *{$AUTOLOAD} = sub { my $s = shift; return ($s->__set(
+$attr, @_)) };
                goto &$AUTOLOAD;
        }
        # subs like DESTROY
        return if $AUTOLOAD =~ /^.*::[A-Z]+$/;
        die "Unimplemented $AUTOLOAD";
}


                                                                      
+                                                                     
+                           
package Dummy;
                                                                      
+                                                                     
+                           
use base qw(Class::GetSet);
sub __has { return { foo => { read => 1, write => 1 }, bar => { read =
+> 1 } } }
                                                                      
+                                                                     
+                           
package main;
                                                                      
+                                                                     
+                           
my $d = Dummy->new( foo => 1, bar => 2);
print "foo = '". $d->foo ."'\n";
$d->set_foo( 'xxx' );
print "foo = '". $d->foo ."'\n";
                                                                      
+                                                                     
+                           
print "bar = '". $d->bar ."'\n";
$d->set_boo( 'xxx' );
[download]

This code is a little unusual. The do {} is a runtime construct to allow you to put statements where an expression is expected. It has scope, but is not actually block (iirc) in that you can't use next to exit out of it.

D:\dev>perl -e"do { next };"
Can't "next" outside a loop block at -e line 1.

D:\dev>perl -e"{ next };"
[download]

The named sub there is a closure, but only in a trivial sense, and you'll probably more likely see people talk about "static" vars in this situation. For instance I would expect to see that code written something like:

BEGIN {
    my $count=0; # static
    sub counter {$count++}
}

for (0..9) {
    print counter();
}
[download]

Without the do on there the block is really a block (albeit a magic one), and its clear the $count=0 is only going to be executed once, and its going to occur before counter() is ever used, that is immediately after the block is compiled (because of the BEGIN).

If you want to make a counter factory then you get into more interesting forms of closures:

sub make_counter {
  my $start=shift||0;
  return sub {$start++};
}
[download]

The named sub there is a closure, but only in a trivial sense

Thanks demerphq, I understand this now. I can see that the power of closure comes when you're using them dynamically, hence why all the examples show anonymous sub references. However, using these simple examples has really helped my understanding, so ++ all round.

Rob

---
my name's not Keith, and I'm not reasonable.

In your second example, my $count is in the lexical context of the do{} loop. You don't have strict turned on, so you can access counter(), but the my $count there overrides your declaration of $count in the for{} loop.

Closures are subtle, but in the context of what you're trying to do, you should be returning a coderef for it to work. Once you get that, read some of the closure articles again.

# getRowsLazy :: DB_Handle -> (String -> String -> ()) -> (SQLQuery ->
+ {':parm1' => value, ...} -> [[DBType, ..., DBType]])
# Closure on $dbh, lazy version and partial application on the first t
+wo params
# 
# ex: my $dbh = ...DBI connect...
      my $getRows = F::getRowsLazy($dbh, sub { myErrFun($[0], $[1], $M
+Y_FUN_NAME, $MY_TRACE_LEVEL) } );
#     ...
#     my $iter = $getRows->("select * from device_param where ID=:id",
+ {':id' => 123456});
#     while (my $row = $iter->()) {
#       print $row->[0] . ", " . $row->[1] . "\n";
#     }
#
sub F::getRowsLazy {
  my ($dbh, $errFun);
  return sub {
    my ($sql,$p) = @_;
    my $sth = $dbh->prepare($sql) || $errFun->("Error in DBI::prepare"
+, $dbh->errstr() );
    
    while (my ($k,$v) = each(%$p)) {$sth->bind_param($k, $v);}
    
    $sth->execute() || $errFun->("Error in DBI::execute", $dbh->errstr
+() );
    
    my $yield = sub {
      my $row = $sth->fetchrow_arrayref;
      if ($row) {return $row;}
      $sth->finish();
      return undef;
    };
    
    return $yield;         # the call to $yield->() returns a referenc
+e; doesn't work with array, but I don't know way
  }
};
[download]