Your example is redundant, cause the obvious rule is that any assignment in a new scope equals a declaration.

That's ludicrous. It would prevent this common construct:

my $x;
if (f()) {
   ...
   $x = ...;
} else {
   ...
   $x = ...;
}
[download]

And this one:

my $found;
for (...) {
   if (...) {
      $found = ...
   }
}
[download]

And this one:

my @a;
while (...)
   ...
   push @a, ...;
}
[download]

I don't think any program I've ever written would work!

> That's ludicrous.

That's why I elaborated two models.

Cheers Rolf
_{(addicted to the Perl Programming Language :)
Wikisyntax for the Monastery}

So? The first part is still wrong.

short version:*

• basically only file and function scope are automatic.
• all deeper nested scopes need to be explicit. Implicit effects there - if allowed - belong to the surrounding file/function scope.
• nested subs are tricky

1. Any assignment to an undeclared new variable implies a "implicit" my when in

• file-scope (outside any sub)

  $x = 1 ==> my $x =1

• function-scope

  sub foo { $x = 1; ... } ==> sub foo { my $x =1; ... }

• loop-header but NOT body

  for $x (@a) {...} ==> for my $x (@a) {...}

• some commands like open *

  open $fh, ... ==> open my $fh, ...

3. No hoisting, a variable accessed before an implicit my still belongs to the upper scope and needs to be declared there

4. loop-bodies and naked blocks (technically the same) follow the old rules

• to restrict the scope of a var you'll still need an explicit my
• an implicit my (i.e. assignment to a new var) belongs to the outer scope, starting with the block

  { $x=42 }; print $x; => 42

5. ( ??? ) nested/anonymous subs are tricky, when it comes to closed over vars

• if they follow rule 1, than we need a declaration alike Py's nonlocal ... maybe its or over to mark vars avoiding implicit my
• if they are exempt from rule 1 and rather act like 4, we get a break in symmetry
• another solution would be a new keyword fun to create a sub with auto-mine while keeping sub explicit.

• see point 5

8. special global vars are exempt from implicit my.

9. Last but not least automine activates strict

So ...

• Did I forget a case?
• Do you need examples?
• Please inform yourself about closures before judging.

°) actually not in the case of map and grep but for all of List::Util , try return to see the difference

*) updated

While the former thought experiment was closer to Python's behavior - all vars belong (mostly) to function scope - there is another possible approach.

1. any assignment to a new variable leads to an implicit my but only if their was no previous explicit declaration in a surrounding scope. This will replace former rules 1,4 and 5 all others still apply

Hence we get the following 4 cases for explicit declarations with my or our

automine	effect	comment
{ $x = 1; { $x = 2; } } [download]	{ my $x = 1; { my $x = 2; } } [download]	not strict w/o automine
{ $x = 1; { my $x = 2; } } [download]	{ my $x = 1; { my $x = 2; } } [download]	not strict w/o automine
{ my $x = 1; { $x = 2; } } [download]	{ my $x = 1; { $x = 2; } } [download]	backwards compatible
{ my $x = 1; { my $x = 2; } } [download]	{ my $x = 1; { my $x = 2; } } [download]	backwards compatible

Surprises and pitfalls:

automine	effect	comment
sub foo { if (1) { $x = 2; } print $x; } [download]	sub foo { if (1) { my $x = 2; } print $x; # undeclared } [download]	Doesn't compile Surprising for Pythonistas
sub add { $x = 0; for (1..9) { $x = $x + $_; } print $x; } [download]	sub add { my $x = 0; for (1..9) { my $x = $x + $_; } print $x; # prints 0 } [download]	Unexpected result! Needs an explicit my $x = 0 at init to avoid implicit my

This is a very Perlish approach and avoids many edge cases.

Of course this laziness comes with a price, introducing a new explicit declaration on file scope has an effect at the distance and could silently break subroutines

use automine
# our $var;

... 

sub foo {
    $var = shift; # not 'my $var' if explicit 'our $var' exists 
    ...
}
[download]

That's why this theoretical pragma must be optional. (Of course scoping the our inside a tight block would also prevent this.)

Cheers Rolf
_{(addicted to the Perl Programming Language :)
Wikisyntax for the Monastery}