Lexical subs have been on the wish list for some time though, but it never has had a high priority. I don't see much use of lexical functions; you can't easily pass them around, you would need a reference to them before you can, and then one could start off with a coderef in the first place.

Abigail

use Sub::Lexical;

my sub foo {
    print "I'm in a lexically scoped sub, hurrah!\n";
}

foo();
[download]

local $Sub::Lexical::LEXICALS{foo};
$Sub::Lexical::LEXICALS{foo} = sub  {
    print "I'm in a lexically scoped sub, hurrah!\n";
};

$Sub::Lexical::LEXICALS{foo}->();
[download]

_________
broquaint

Hi broquaint, I've just downloaded the code from Sub::Lexical and done some tests of my own, and it seems to me that your subs now have local scope:

#!/usr/bin/perl -w
use strict;
use lib '.';
use Sub::Lexical;

my sub testsub {
    print "testsub 1 called\n";
}

my sub outersub {
    print "outersub called\n";
    testsub();
}

for (1) {
    my sub testsub {
        print "testsub 2 called\n";
    }
    testsub();
    outersub();
}
[download]

This outputs:

testsub 2 called
outersub called
testsub 2 called
[download]

While it probably SHOULD give:

testsub 2 called
outersub called
testsub 1 called
[download]

Because the first testsub() declaration is in lexical scope for outersub()

This could be considered a feature, if you just rename your module to Sub::Local... :-)

-- 
Joost       downtime n. The period during which a system
            is error-free and immune from user input.
[download]

Ack, you're completely right. In my haste to get a working solution I somehow overlooked the fact that local() != my(), I think the happy part of my brain was muffling the common sense part with a chloroform soaked cloth ;-) So I shall be going back to munging the variable names and also including a hopefully unique enough id within the name. Thanks for the input Joost!
HTH

_________
broquaint

The namespace issue has nothing to do with the coderefs; the problem is that lexical variables (and by abstraction lexical subs too) are not in any namespace at all! Lexial variables exist in their lexical scope, and lexical scope doesn't give a d*mn about packages.

Anyway I don't really see that this is much of a problem - the only use for lexical subs I can see is for 'temporary' subs - you would put those somewhere where they go out of scope quickly - or 'private' subroutines, which you would put in a module anyway (and lexical scope is at most file scope)

-- 
Joost       downtime n. The period during which a system
            is error-free and immune from user input.
[download]

The namespace issue has nothing to do with the coderefs

It does because the 'lexical subs' are stored in coderefs which are just scalars and you can't have 2 scalars of the same name in the same lexical scope e.g

my $foo = "I'm a string";
# this will replace previous $foo
my $foo = sub { "I'm a coderef" };
[download]

the problem is that lexical variables (and by abstraction lexical subs too) are not in any namespace at all!

Yes they are and it is the current lexical scope's namespace (which is anonymous and inaccessible through straight perl).

_________
broquaint

You're right. I guess I'm a little more tired than I thought :-)

Anyway, I guess you're sort of stuck then. The only thing I can think of, is to use something a little more descriptive than $__name__ - how about $__lex_sub__name ?

I think it would be quite reasonable to disallow the use of scalars called $__lex_sub__* in combination with your module.

-- 
Joost       downtime n. The period during which a system
            is error-free and immune from user input.
[download]