Lambda returning tuple question, multi-expression

[Thomas Passin]

On 3/10/2023 11:15 PM, aapost wrote:
> On 3/10/23 22:16, Thomas Passin wrote:
[...]
> The additional note in the above is, when taking the def route above, 
> the thing you would have to consider is what scope is the dictionary pids?
> 
> Do you need to submit it to the lambda and subsequently the function 
> such as
> lambda pids=pids: (
>      update_pids("messages", pids),
>      update_pids("syslog", pids),
> 
> So that update_pids can access it? Or in your design do you have a 
> separate management of it that def update_pids already has access to? 
> (either is valid depending on design intent).

It's easy enough to try out.  I'm not going to simulate the dictionary, 
because it's basically just another argument, and I assume that your 
example code uses it because it needs to be in that form.  For the scope 
question, see below after the basic example.

 >>> def printme(x): print(x)  # Let's not quibble about inline defs!

 >>> printme('xxx')
xxx
 >>> cmd = lambda x: (
...     printme('this'),
...     printme('is'),
...     printme('a test')
...     )

(Yes, I know it's not recommended to assign a lambda to a variable name, 
but I'm doing it here just to demonstrate that the lambda works as desired).

 >>> cmd(2)
this
is
a test
(None, None, None)

So it executes the intended steps and returns a tuple of three None 
values, as expected.  When used as the target of the "command" arg in 
the Tk control constructor, I presume the tuple would be ignored just as 
a return of None would be.  But that would need to be tested.

If returning a tuple instead of None were to cause a problem, you could 
do this:

cmd = lambda x: (
     printme('this'),
     printme('is'),
     printme('a test')
    ) and None

 >>> cmd(2)
this
is
a test

But now you are introducing a construct whose purpose is not totally 
obvious, does not cause any intended effect, and in fact is only 
required by the nature of the code receiving the callback, which you 
cannot know by reading this code.  So if this construct turns out to be 
needed, we're forced to take a step away from having the code be as 
direct and understandable as possible.  It's still better in that way 
than the earlier illustrations (which BTW would also have required the 
"and None" construct).

To test out the scope question:

 >>> def printme(x): print(y)  # Print some other variable, not "x"
 >>> y = 'I am y'  # Will "y" get passed through into the lambda?

 >>> cmd = lambda x: (
...    printme('this'),
...    printme('is'),
...    printme('a test')
... ) and None

 >>> cmd(2)
I am y
I am y
I am y

But maybe the original value of "y" gets baked in at compile time. Let's 
see:

 >>> y = 'I am a post-compile assignment'
 >>> cmd(2)
I am a post-compile assignment
I am a post-compile assignment
I am a post-compile assignment

Good, the current value of "y" gets used.