in reply to Re^2: Local for lexicals in thread Local for lexicals
I think the most productive approach would be to post test code, assuring your intentions are understood, such that other stop posting speculative code...
Anyway I doubt that your desired "my_local" (or better named "lex-local") is what you need, since $x,$y,$z will always also belong to the outer scope, making ugly side-effects probable!
{ #outer scope
$lamb = lambda ( $x, $y, $z ) => sub { $x + $y }
}
the following is simple and very close but lacks the same aliasing like $_[0] does.
$lamb = sub { my ($x,$y,$z) = @_; $x + $y }
so using Data::Alias or Lexical::Alias might be what you need to install for lexicals.
If you don't wanna install XS-Moduls try working with lex-refs
DB<20> $lamb=sub { my($x,$y)=\(@_); $$x += $$y }
DB<21> $a=10; $lamb->($a,5); print $a
15
NOTE: Aliasing can always be achieved with * and pack-vars.
Re^4: Local for lexicals
by JadeNB (Chaplain) on Aug 11, 2009 at 03:28 UTC
|
| [reply] [d/l] [select] |
|
Maybe this is a repetition of a question already asked--possibly even asked and answered--but having re-read the thread, I cannot see it. So here goes:
{ #outer scope
$lamb = lambda ( $x, $y, $z ) => sub { $x + $y }
}
This is, in a sense, the crux of my problem—I don't want the values of $x, $y, and $z to leak from the inside out, or vice versa,
What are you trying to achieve that this doesn't?
my( $x, $y, $z ) = ( 1,2,3 );
my $lamb = do{
my( $x, $y, $z ) = ( $x, $y, $z );
lambda ( $x, $y, $z ) => sub { $x + $y }
}
Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.
"Science is about questioning the status quo. Questioning authority".
In the absence of evidence, opinion is indistinguishable from prejudice.
| [reply] [d/l] [select] |
|
What are you trying to achieve that this doesn't?
my( $x, $y, $z ) = ( 1,2,3 );
my $lamb = do{
my( $x, $y, $z ) = ( $x, $y, $z );
lambda ( $x, $y, $z ) => sub { $x + $y }
}
Unfortunately, I don't know quite what this does, so I can't answer! My question (at least, the part of my question that seems to have attracted the most attention) is how to write lambda in such a way that lambda( $x, $y, $z ) => sub { $x + $y } is the same as sub { $_[0] + $_[1] }. As far as I can tell, the code that you've written would be the same as
my ( $x, $y, $z ) = ( 1, 2, 3 );
lambda ( 1, 2, 3 ) => sub { 1 + 2 }
| [reply] [d/l] [select] |
|
or if there were a lex_local that could just be dropped in for lexicals as local can for globals.
First of all local is the wrong approach, because local just manipulates already declared pack-vars, so under strict you would be forced to predeclare your variables with "our" (or "my") in the outer scope. (look at first our in the following code) (see update)
I would love to have a lexical local in P5 BUT not with the extra magic of declaring missing variables your assuming.
What you really want is aliasing like $_[ ] variables do.
I know about *, although it doesn't seem to do much for lexicals, but what do you mean by pack-vars?
Aliasing with package-variables
use strict;
use warnings;
$\="\n";
my $lamb = sub {
our ($d,$e); # local doesn't declare!!!
local (*d,*e)=\(@_);
$d += $e ;
};
our $d="D";
our $u=10;
$lamb->($u,5);
print $u; #> 15
print $d; #> D
However, I don't know how to improve.
from your /msg:
What can I do to improve? I try to phrase my questions as (1) an informal description of what I want; (2) imaginary code that'll do what I want; (3) descriptions of what I've tried, and what I don't want to do (ideally, with explanations).
some ideas:
- Post working code which exactly does what you want, but in a "unpretty" way.
e.g. with
- $_[0] or
- lex-refs $$x or
- aliased pack-vars *x ...
- Express what you want to avoid in the working example (uglyness, doubelsigils, pack-vars,...)
- Post a test program which proofs every functionality you want to have covered,
like
e.g. with Test:More like in this post
- Write a codegenerator using eval which covers all edge cases
e.g.
- with or without use strict;,
- with or without use warnings;,
- variables known/unknown in outer scope,
- outerscope vars are lex or pack
- Make clear which moduls are acceptable to be used...
- None
- Just CORE
- CPAN w/o XS
- CPAN
- any
UPDATE:
as JavaFan pointed out here you are not forced to use our with full-qualified varnames, so this works
my $lamb = sub {
# our ($d,$e);
local (*::d,*::e)=\(@_);
$::d += $::e ;
};
but I don't know if this meets your criteria of being more elegant than using $_[0] += $_[1] and furthermore it's only a pack-var thing, in P5 lex-vars have no namespaces... | [reply] [d/l] [select] |
|
under strict you would be forced to predeclare your variables with "our" (or "my")
Not really. 'strict' just forces you to be explicite. Introducing a variable with our or my is one way. Using a fully qualified name is another. And for variables living in main, $::var is enough for satisfy strict.
| [reply] [d/l] |
|
I know about *, although it doesn't seem to do much for lexicals, but what do you mean by pack-vars?
Well, of course * doesn't do anything for lexicals, as * is a typeglob. Lexicals don't live in typeglobs. A "pack-var" is just short for "package variable". You know that Perl has two kinds of variables, right? Lexical variables, and package variables (the latter is often confusingly called "global" variables, but that just shows ignorance. A lexical declared on an outer scope is "global" as well - "global" has to do with the broadness of the scope of the variable, not with its flavour).
I'm still not sure what exactly you want with your "lambda" variables. On the one hand, you seem to use them as named parameters, but that gives them a well defined scope - they are scoped to the subs, and just act as aliases for $_[0], $_[1], etc. OTOH, you seem to be want to set them from way out of their scope (your "localized lexicals" request). That has little to do with lambda functions I've encountered in functional languages (where there's no such thing as assignment or state change).
| [reply] [d/l] [select] |
|
|