Minor point: you can simplify your feature statement by just saying

use 5.10;
[download]

err, major point... you should pay attention to what ambrus says below.

That (use 5.10) will give an error, because it means to require perl version 5.100.000. Instead, say use 5.010; or use 5.010_000; or use 5.10.0; or use v5.10; or use v5.10.0;.

(I've fallen to this trap yesterday when trying 5.10 out, but the error message is nice enough:

Perl v5.100.0 required (did you mean v5.10.0?)--this is only v5.10.0, 
+stopped at -e line 1.
BEGIN failed--compilation aborted at -e line 1.
[download]

Update: I analyzed it a bit - and I see it now - if $cash_in_store was not declared state then it would not be shared between $drower->[0], $drower->[1], $drower->[2] and $drower->[3]. But of course as a closured variable it still would work for individual drawers.

It's the exact difference between the following two code snippets:

  BEGIN {
    my $var = 10;
    sub next {
      return ++$var;
    }
  }
[download]

And the following:

  sub next {
    state $var = 10;
    return ++$var;
  }
[download]

Now let's have a show of hands, how many people prefer the First Way To Do It? ... hmm, I see no hands? I thought as much :)

Tip o' the hat to Roy Johnson for pointing out that it was a BEGIN block I wanted, not an lexical scope with a label BEGIN:. And you do need a BEGIN block, not a bare block, otherwise you can run into grief with uninitialised values (which is kind of the whole point).

• another intruder with the mooring in the heart of the Perl

Actually you should compare using a bare block (no BEGIN) which is the standard (older) way to have "state" variables.

I like 'state' but the old way is still useful if you need a pair of cooperating subs (or more):

% steph@ape (/home/stephan) %
% cat state_old.px
#!/usr/bin/perl+

{
  my $var = 10; 
  sub next1 { ++$var; }
  sub next1_odd {
      if ($var % 2 == 0) {
          ++$var;
      }
      else {
          ++$var; 
          ++$var;
      }
  }
}

$\ = qq{\n};
print next1() for 1..5;
print next1_odd();

% steph@ape(/home/stephan) %
% perl+ -w state_old.px
11
12
13
14
15
17
[download]

cheers --stephan

It looks like it acts more like a static variable in a C routine. There is no closure in Limbic~Region's code yet the variable looks like it is expected to retain its value between calls.

90% of every Perl application is already written. ⇒

dragonchild

Well, I've already posted my new code: JAPH to commemorate the release of Perl 5.10.0.

Later, I guess I'll use the new features in a better way too. I just don't like the wierd symmetric way the ~~ operator works, and how they ruined my signature japh with a default warning that should be optional.

So what does your new code look like?

I personally believe that I should first warn any newbie possibly reading this post in the future that its content is deliberately humorous in a sarcastic way. So please don't even think of picking up the code shown here and use it in anything serious...

I... huh... personally believe that with 5.10's new features we can eventually implement in Perl the FOR-CASE paradigm:

#!/usr/bin/perl

use strict;
use warnings;
use 5.010;

for my $count (0..4) {
    given ($count) {
        when (0) { say "Whoa, it's $count" }
        when (1) { say "Then it becomes $count" }
        when (2) { say "Then, $count" }
        when (3) { say "Only to further increase to $count" }
        when (4) { say "And eventualy stop at $count" }
    }
}
[download]

But we care about efficiency all the time, don't we? Furthermore, this may begin to give a wrong output the day a number which is equal to 0 will also be equal to 1, for example.

Last, prior to 5.10, one of the standard answers for those in search of a switch statement was to use a dispatch table instead, so for backwards compatibility reasons, let's see how it may look like:

Or at most, using closures:

Anyway, with 5.10 it's much slicker!