-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1
I'm almost sure this had been covered before, but I failed to find a
reference in either the archives or in synopses, so here goes again:
sub f ($x) {
sub g ($y) { $x + $y }; g($x);
}
f(10); # 20?
Currently in Pugs, &g is built at BEGIN time when &f had not finished
building up its lexical environment, and as such fails to see the
runtime $x. The desugared form is:
our &g;
BEGIN { &g := sub ($y) { $x + $y } }
However, the following form does work in the Parrot, JavaScript and
Haskell runcore:
sub f ($x) {
my sub g ($y) { $x + $y }; g($x);
}
the reason it works is that &g's body is replaced every time upon &f's
entry. This is probably the expected behaviour.
What would happen for the "our sub g" form, where it becomes possible to
call &g directly without entering &f? This shows Pugs's current behaviour:
sub f ($x) {
our sub g ($y) { $x + $y }; g($x);
}
f(10); # 20 for sure
our &g; # gets visibility to &g
g(100); # 110 this time?
So my questions are:
* Is the treatment above sane?
* Does it make sense to change the undecorated "sub g"'s behaviour to
match "our sub g"?
* If we insert a call to g() above without calling f() first, should it
assume an uninitialized $x, or throw an exception (Pugs currently does
the latter)?
I'd be happy to patch S06 when we get a consensus/ruling this time. :-)
Thanks,
Audrey
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.2 (FreeBSD)
iD8DBQFDyz9WtLPdNzw1AaARApSXAKCrjk4dxDPhj7or2qxJBlULVBXgEQCfZxLO
kza0/2Xv3iAGXNaaw73phyw=
=rAZq
-----END PGP SIGNATURE-----
