There are two basic ways to implement closures: A custom calling convention: Callers are aware they're calling a closure and so pass the closure context to the callee, perhaps as a hidden argument. Closures are nearly always implemented this way, including in C++. For C, as a lingua franca platforms would need to define this calling convention / ABI so that different implementers could all each others closures just as they can call each others functions. Since this doesn't exist, closures in language implementations using this approach are incompatible with C interop (ex. can't turn a C++ closure into a function pointer). Build a trampoline by allocating a little bit of executable memory, essentially like using a small JIT compiler. Callers do not need to be aware they're calling a closure, and a plain C calling convention is sufficient. GNU C closures are implemented this way, as are CPython's ctypes callbacks. However, frequently allocating executable memory requires significant trade-offs in performance or security. It may not even be possible on some platforms. This is also an implicit allocation — which is not in the spirit of C — and someone has to manage its lifetime. (GNU C manages it by using an automatic allocation.) Unless you're willing to make the trade-offs in the second approach — which is available to you if you use GCC — neither fits C well. More on reddit.com

Blocks are a non-standard extension added by Apple Inc. to Clang's implementations of the C, C++, and Objective-C programming languages that uses a lambda expression-like syntax to create closures within these languages. More on stackoverflow.com

These nested functions aren’t standard C and they won’t work on Clang or MSVC. More on reddit.com

A lambda simplifies code for a two part situation: You have some generalized code that basically says "When we're ready to act, please tell me what C++ code to run" and You want to run the C++ function code once and only once. You don't want to type out lots of boilerplate function definition stuff. What made lambdas click for me is when I realized they're just predicates or struct functors in simpler form. Imagine that the compiler basically expands lambdas into the old fashioned struct functors. That's it. Lambdas will make this cplusplus.com example cleaner: https://cplusplus.com/reference/forward_list/forward_list/remove_if/ . I'm cleaning up the code a bit and reposting it below. The example is about using a linked list with items, and then removing items of a given criteria. Because you don't have access to the nodes, and iterators aren't really a clean way to do this, we end up needing to pass in logic. A function predicate and a functor, not exciting yet... #include #include // A function bool single_digit(const int& value) { return (value < 10); } // A functor struct oddFunctor { bool operator() (const int& value) { return (value % 2) == 1; } }; int main() { std::forward_list mylist = { 7, 80, 7, 15, 85, 52, 6 }; mylist.remove_if(single_digit); // mylist now only contains 80 15 85 52 mylist.remove_if(oddFunctor()); // mylist now only contains 80 52 return 0; } Now let's say we want to make it even more flexible. Instead of just checking if a number is odd, we want to remove all numbers divisible by something the user specifies. Redoing that with lambdas, and adding another example. This is exciting #include #include // A messier functor struct DivisibleByFunctor { public: DivisibleByFunctor(const int divisibleValue) { this->divisibleValue = divisibleValue; } bool operator() (const int& value) { return (value % divisibleValue) == 0; } private: unsigned int divisibleValue{}; }; int main() { std::forward_list mylist = { 7, 80, 7, 15, 85, 52, 6 }; std::forward_list secondlist = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13 }; std::forward_list thirdlist = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13 }; // Lambda! The function is gone! All logic here is in one line. myList will contain 80 15 85 52 mylist.remove_if([](const int& value) {return (value < 10); }); // Lambda! The struct is gone! All logic here is in one line. myList will contain 80 52 mylist.remove_if([](const int& value) {return (value % 2) == 1; }); int divisibleValue; std::cout << "Values divisible by this should be removed: "; std::cin >> divisibleValue; // Ugly functor way. Boo! Requires a messy struct up above secondlist.remove_if(DivisibleByFunctor(divisibleValue)); // Lambda with capture of a local variable! No struct needed! All logic in one line! thirdlist.remove_if([divisibleValue](const int& value) { return (value % divisibleValue) == 0; }); return 0; } More on reddit.com