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 }
}
[download]

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 }
}
[download]

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 }
}
[download]

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 }
[download]

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
[download]

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:

1. 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 ...
2. Express what you want to avoid in the working example (uglyness, doubelsigils, pack-vars,...)

3. Post a test program which proofs every functionality you want to have covered, like
   • aliasing,
   • locality..
e.g. with Test:More like in this post
4. 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
5. 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 ;
};
[download]

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.

I know about *, although it doesn't seem to do much for lexicals, but what do you mean by pack-vars?

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).