Re: Recursion, Yo

On 10/04/2024 09:52, Lawrence D'Oliveiro wrote:

On Wed, 10 Apr 2024 09:11:49 +0200, David Brown wrote:
 

It is not much used in practice, AFAIK.  For some cases the code
generation for nested functions was fine and straight-forward.  In other
cases, however, it required a trampoline generated on the stack, and
that became a real pain once non-executable stacks came into fashion.

 That would be true of those other languages that require the feature, too.
 

There may be other differences in the languages that reduce that effect - or it could be a problem there too.  I don't know the details. (Perhaps those on an Ada newsgroup would know better.)
The problem with trampolines comes about when you want to take the address of the nested function and use that outside of the surrounding function, while you also have variables captured by reference.

Nested functions were never as interesting for C++ as you already have
better mechanisms for controlling scope and data access - classes and
their methods, including nested classes.

 Python does both. Just because you have classes doesn’t mean functions
can’t be first-class objects, too.

True.  But Python is a very different language from C++.  In Python, not only are functions objects in themselves, but so are classes (the definition of the classes, rather than just instances).  Python is a lot more "meta" than C++.
Basically, anything you could do with a nested function in gcc C you can do in C++:
int sum_square(int x, int y) {
int square(z) {
return z * z;
}
return square(x) + square(y);
}
int sum_square(int x, int y) {
auto square = [](int z) {
return z * z;
}
return square(x) + square(y);
}