Good C style is that every function that accepts a callback should also accept an opaque context pointer it then passes through unchanged to the callback. Usually the caller will allocate a structure on the stack or the heap, stash some of its local variables there, then use them in the callback. A nested function does the structure back-and-forth for you in the stack-allocated case. In GCC’s original formulation it also passes the context pointer implicitly<p><pre><code> size_t filter(bool (*predicate)(int), int *p, size_t n) {
for (size_t r = 0, w = 0; r < n; r++) {
if (predicate(p[r])) p[w++] = p[r];
}
return w;
}
size_t lowpass(int limit, int *p, size_t n) {
bool lower(int value) {
return value < limit; // use the parent's local variable
}
return filter(lower, p, n);
}
</code></pre>
but that requires an executable stack and TFA is about avoiding that part.
Say to strictly enforce modularity, e.g helper functions that can only be accessed within its function.<p>Pascal supports it (at least Turbo Pascal, no idea about ISO Pascal).
For a counterpoint, see David R. Hanson's "Is block structure necessary?" (1981) [0] — back in those days, "block structure" meant nested routines with nested scopes — which argues that having instead a proper module system, with explicit control over what's being exported from a module, not only gives a better modularity, decomposition, and encapsulation, but also simplifies both the language's implementation, and the run-time structures it needs (remember displays, and the hardware support for them e.g. x86's ENTER?).<p><pre><code> Block structure is traditionally considered an a priori requirement for algorithmic program-
ming languages. Most new languages since Algol-60 have block structure. Reasons exist,
however, to omit the general form of block structure — nested procedure definitions in which
references to identifiers defined in outer procedures are permitted — from programming
languages, especially those intended for systems programming applications. This paper
reviews the concept of block structure and considers its advantages and disadvantages. It
concludes that, in many cases, a module facility is superior to block structure and should be
considered in lieu of block structure in future languages.
</code></pre>
[0] <a href="https://drh.github.io/documents/blockstructure.pdf" rel="nofollow">https://drh.github.io/documents/blockstructure.pdf</a>
The traditional way of doing this in C is simply static functions. Every .c file has exactly one non-static function and all the other helper functions are static.
When you want to use lambdas, but your language doesn't have lambdas, so you reach for the nearest thing instead.
Lambdas are just anonymous nested functions. But I like named nested functions more because they are more readable and would prefer them in most cases.
Ideally you have both as most languages have.<p>I always wondered why C++ only added lambdas, but observing WG21 for a while, I assume this is just a random walk in language design. (not that it is different in WG14)
> Lambdas are just anonymous nested functions.<p>The important feature of lambdas is that they are expressions, not that they lack a name. The advantage of function expressions is you can write the body of the function exactly at the place where it is used. With GCC nested functions you either have to write the body of the function before its first use or else write the declaration of the function twice.<p>This matters for long chains of continuation passing:<p><pre><code> foo(arg1, arg2, [](){
// do some work
bar(arg3, arg4, [](){
// do some more work
baz(arg5, arg6, [](){
});
});
});
</code></pre>
Compare to the following, where the control flow is all out of order:<p><pre><code> void cb(void){
// Do some work
void cb2(void){
// do some more work
void cb3(void){
}
baz(arg5, arg6, cb3);
}
bar(arg3, arg4, cb2);
}
foo(arg1, arg2, cb);</code></pre>
I agree with your point.<p>But I usually prefer the later anyway, because the code usually is not as nested anyway and having a name is often helpful, and also because I find the nested code with lambdas also not too readable. Other languages have better syntax for chaining functions in this way, i.e. with lambdas I would like to write like this:<p><pre><code> foo(arg1, arg2, _)
.(int(int x)) { ... }
.(int(int y)) { ... };
</code></pre>
(edit: or something, I think I got it a bit wrong, but you get the idea)<p>But I agree, sometimes lambdas are better so it would be good to have both.<p>(There is the classical hack to define lambdas using statement expressions and nested functions.)
I can write numbers like three by just writing 3 in my code. When I want a named number I use a syntax like x = 3. Why should functions be any different? A language doesn't need different ways to name things for each type of thing. Integers, strings, functions etc: they can all use the same mechanism for naming.
C++ bundles together a way to write functions inline in an expression (what I’d call “lambdas” in general) and a way to create closures with strictly nested lifetimes, but there’s no law of nature tying the two together. Even in C++ the essentially separate declaration “auto f = [&](... blah ...) { ... 50 lines of code ... };” is pretty common. (And of course GCC’s nested functions predate C++11 by twenty years.)
RAII style cleanup e.g. no gotos
For the non-capturing case: mainly to improve readability by allowing utility functions to be defined close to where they are used and with short names.<p>For the capturing case: to access context that is not available through global variables or function arguments, i.e., the same reason why closures are useful in other languages.<p>Here's an example, where I have a list of points that I want to sort based on distance to a chosen target point. I can use qsort() which takes an arbitrary comparison function, but has no way to provide context to that function beyond the input arguments:<p><pre><code> #include <stdio.h>
#include <stdlib.h>
int main() {
struct Point {
int x, y;
} points[3] = {
{ 3, 1 },
{ 2, 2 },
{ 5, 7 } };
struct Point target = { 4, 5 };
long dsq(const struct Point *p) {
long dx = p->x - target.x, dy = p->y - target.y;
return dx*dx + dy*dy;
}
int compare(const void *p, const void *q) {
long a = dsq(p), b = dsq(q);
return (a > b) - (a < b);
}
qsort(points, 3, sizeof(struct Point), compare);
for (int i = 0; i < 3; ++i) {
printf("%d,%d\n", points[i].x, points[i].y);
}
}
</code></pre>
Note here that dsq() is a local function that accesses the `target` variable in the local function scope.<p>The usual workaround in standard C is to pass the necessary context as a function argument. That's why qsort_r() exists, which takes a context argument to be passed to compare(), but that's a non-standard GNU extension.<p>This practice of passing context pointers around is ubiquitous in C code, and it works, but it can get messy especially if you need access to multiple variables or variables from more than one nested scope. There is also a type safety issue: these context pointers are necessarily passed as void* which means they have to be cast back to the real type before use, which is where bugs can be introduced if the caller and receiver disagree on the actual type.
This is a good example. Without trampolines, this could look like this (Godbolt: <a href="https://godbolt.org/z/nK5fqMxjs" rel="nofollow">https://godbolt.org/z/nK5fqMxjs</a>).<p><pre><code> int main() {
struct Point {
int x, y;
} points[3] = {
{ 3, 1 },
{ 2, 2 },
{ 5, 7 }
};
struct Point target = { 4, 5 };
long dsq(const struct Point *p) {
long dx = p->x - target.x, dy = p->y - target.y;
return dx*dx + dy*dy;
}
typedef typeof(dsq) dsq_f;
int compare(const void *p, const void *q, void *data) {
wide(dsq_f) *dsq = data;
long a = CALL(*dsq, (p)), b = CALL(*dsq, (q));
return (a > b) - (a < b);
}
qsort_r(points, 3, sizeof(struct Point), compare, &CLOSURE(dsq_f, dsq));
for (int i = 0; i < 3; ++i)
printf("%d,%d\n", points[i].x, points[i].y);
}
</code></pre>
There are slightly different ways how to define the helper macros, I am still experimenting a bit. Here you could avoid the typedef if defined differently. But ideally, there would be native language support that avoids these macros.
Well, if you're already using qsort_r, what's the point of using nested functions, if you can have a context pointer with the target?<p>And if you're not using qsort_r, but reaching for _Thread_local, the target can be _Thread_local instead of dsq.
Fair. If you only have one object to access such as the target pointer, then it probably makes not much difference with void-pointer based APIs such as qsort_r (for new APIs it would add type safety). Where it removes more boilerplate code is when you have several such objects and would have to create an extra data structure to access them.
Or without qsort_r, you could use a thread local variable:<p><pre><code> typedef typeof(dsq) dsq_f;
_Thread_local static wide(dsq_f) wdsq;
wdsq = CLOSURE(dsq_f, dsq);
</code></pre>
<a href="https://godbolt.org/z/3e157c6b1" rel="nofollow">https://godbolt.org/z/3e157c6b1</a>
Just a little cleaner than placing it in the global or file namespaces.
So that you can name a section of code without polluting the namespace.