Re^2: 'Dynamic scoping' of capture variables ($1, $2, etc.)

[Emphases added.]
As to your actual question:
However, $1, set to '1' by the last successful match at the lowest-but-one level of recursion, is propagated upward unchanged through several levels of subroutine 'blocks'
I see no evidence for that. After $1 is set to '1', exactly one more recursive call happens, and there it is printed out. Then the recursion ends, and you don't print $1 anymore.

I don't print $1, but it must be '1' at all higher recursion levels because only that value will result in a sum total of 4.

However, I have not had (and will not immediately have) a chance to ponder your link and other responses.

I suppose my chief confusion stems from the fact that $1 starts out undefined, takes on a bunch of other values, then winds up as it started. If it had finished up as '1', my mind would rest a bit easier, but at some point, and only one point mind you, it's leaving some kind of scope and being restored to the value it had upon entry. I could understand all scopes, I could understand none, but I can't (yet) understand just one!

Comment on Re^2: 'Dynamic scoping' of capture variables ($1, $2, etc.)

Replies are listed 'Best First'.
Re^3: 'Dynamic scoping' of capture variables ($1, $2, etc.) by LanX (Saint) on Dec 16, 2012 at 22:48 UTC
You are right be worried, your example code is just a bit to complex to make it evident at first glance. There is no logical reason why nested calls of the same function (i.e. recursions) should act differently to nested calls of different functions. see updated code, especially the second paragraph contrasting the bug. Cheers Rolf UPDATE: to be sure to avoid any side effects from eval within the debugger here a standalone file for testing: `use warnings; use strict; use 5.10.0; my $x; sub delchar { $x =~ s/(\w)// ? $1 . delchar() . $1 : "x" } $x='abc'; say delchar(); # => "cccxccc" sub del1 { $x =~ s/(\w)// ? $1 . del2() . $1 : "x" } sub del2 { $x =~ s/(\w)// ? $1 . del3() . $1 : "x" } sub del3 { $x =~ s/(\w)// ? $1 . del4() . $1 : "x" } sub del4 { $x =~ s/(\w)// ? $1 . del5() . $1 : "x" } $x='abc'; say del1(); # => "abcxcba"` [download] UPDATE: Best practice is to copy captures like $1 ASAP! (not only in recursions) `DB<105> sub delchar { my $m; $m = $1 if $x =~ s/(\w)//; $m ? $m . +delchar() . $m : "-" } => 0 DB<106> $x='abc'; delchar() => "abc-cba" DB<107> sub delchar { local $m; $m = $1 if $x =~ s/(\w)//; $m ? $m + . delchar() . $m : "-" } => 0 DB<108> $x='abc'; delchar() => "abc-cba"` [download]	[reply] [d/l] [select]

Replies are listed 'Best First'.

Re^3: 'Dynamic scoping' of capture variables ($1, $2, etc.)
by LanX (Saint) on Dec 16, 2012 at 22:48 UTC

There is no logical reason why nested calls of the same function (i.e. recursions) should act differently to nested calls of different functions.

see updated code, especially the second paragraph contrasting the bug.

Cheers Rolf

UPDATE:

to be sure to avoid any side effects from eval within the debugger here a standalone file for testing:

use warnings;
use strict;
use 5.10.0;
 
my $x;
 
sub delchar { $x =~ s/(\w)// ?  $1 . delchar() . $1  : "x" }
 
$x='abc';
say delchar();                            #  => "cccxccc"
 
 
  
sub del1 { $x =~ s/(\w)// ? $1 . del2() . $1 : "x"  } 
sub del2 { $x =~ s/(\w)// ? $1 . del3() . $1 : "x"  } 
sub del3 { $x =~ s/(\w)// ? $1 . del4() . $1 : "x"  } 
sub del4 { $x =~ s/(\w)// ? $1 . del5() . $1 : "x"  } 
 
$x='abc';
say del1();                              # => "abcxcba"
[download]

UPDATE:

Best practice is to copy captures like $1 ASAP! (not only in recursions)

  DB<105> sub delchar { my $m; $m = $1 if $x =~ s/(\w)//;  $m ?  $m . 
+delchar() . $m : "-"  }
 => 0
 
  DB<106> $x='abc'; delchar()
 => "abc-cba"
 
  DB<107> sub delchar { local $m; $m = $1 if $x =~ s/(\w)//;  $m ?  $m
+ . delchar() . $m : "-"  }
 => 0
 
  DB<108> $x='abc'; delchar()
 => "abc-cba"
[download]

[reply]
[d/l]
[select]