Invoking return through a function?

[Alberto Riva]

On 10/29/2017 10:35 AM, Steve D'Aprano wrote:
> On Mon, 30 Oct 2017 01:18 am, Alberto Riva wrote:
> 
>> Hello,
>>
>> I'm wondering if there is a way of writing a function that causes a
>> return from the function that called it. To explain with an example,
>> let's say that I want to exit my function if a dict does not contain a
>> given key. I could write:
>>
>> def testFun():
>>     ...
>>     if key not in dict:
>>       return
>>     ...
>>
>> But if this is a test I need to do a lot of times, I'd like to replace
>> it with something shorter and more explicit:
>>
>> def testFun():
>>     ...
>>     checkKey(dict, key)
>>     ...
> 
> You mean *less* explicit. "checkKey" gives absolutely no hint that it causes
> the current function to return.

That's just because I used a name that was too generic in my example. I 
can call it "returnIfKeyMissing", and then it would be clear.

>> and I'd like checkKey to cause a return *from testFun*. In a language
>> like Lisp this would be accomplished by defining checkKey as a macro
>> that expands into the code shown in my first example, so that the return
>> would be inside testFun and not insted checkKey. Is there a way of doing
>> something like this in Python?
> 
> Fortunately not.
> 
> 
>> Another way of phrasing my question is: is there a way to cause a return
>> from a function that is higher up in the call stack, rather than the
>> currently active one, without using try/except?
> 
> No.
> 
> You really should re-think your strategy. Your suggestion, if possible, would
> lead to difficult to maintain code where you couldn't easily tell where the
> exit points of a function where. 

But again, it's just a naming problem. Something like returnIfKeyMissing 
would make it easy to tell where the exit points are. And as Bartc 
pointed out, we already have this situation with exceptions, so it would 
be nothing new. Indeed, what I'm asking for could be accomplished by 
wrapping the body of each function in a try/catch block for an ad-hoc 
exception type. But again, since the language doesn't have macros, this 
would have to be done manually in each function. I was just asking for a 
more convenient way to do it, being a lazy programmer :)

> Imagine reading code like:
> 
> def foo(x):
>      a = sin(x)
>      b = cos(x)
>      print(a, b)
>      return a + b
> 
> There's one return, right? No. If Python could do what you are asking for,
> *every function call* could be a hidden, secret return. What a nightmare that
> would be.
> 
> It is bad enough that any function could raise an exception, but at least
> exceptions halt the normal execution of code (unless explicitly caught). They
> don't silently continue normal execution.

See above :)

Thanks,

Alberto


-- 
                 E-mail address:
((lambda (s a b c) (map 'string #'code-char (mapcar (lambda (v)
(setq s (+ a (mod (+ s v (- a)) b)))) (map 'list (lambda (v)
(- (char-code v) c)) " 1`-THUZ&+Wh1")))) 97 46 73 32)