[mojifwisi]

> C-style also has a problem in that there is no way to define arbitrary blocks

I might have misunderstood what you mean by "arbitrary blocks", but you can definitely do this in C:

  int main()
  {
    {
      /* arbitrary block */
      return 0;
    }
  }

[Jtsummers]

They seem to mean a computational block (or a closure/lambda) that can be passed on to other functions. Try to do this in C (it's invalid as presented, but this is the concept):

  int main() {
    int* collection = ...
    int* filtered = filter(collection, int func(int item) { return item > 10; });
    ...
  }

You have to actually define a function at the top level in order to pass that in and there is no notion of closures so you can't do the more useful thing that you might have in even C++ these days:

  int main() {
    int* collection = ...
    int limit = ...
    auto filter = [&limit](auto item) { return item > limit; };
    int* filtered = filter(collection, filter); // assuming `filter` is defined
    ...
  }

You can come close, but you create a lot of extra bookkeeping in your C program to pull it off, and the functions are still only defined at the top-level.

[hoosieree]

GCC has an extension for nested functions: https://gcc.gnu.org/onlinedocs/gcc/Nested-Functions.html#Nes...

Not as nice as anonymous blocks but helps put the function closer to where it's used, which is nice.

[Jtsummers]

Yeah, but the two dominant open source C compilers have chosen different approaches. This makes nested functions (gcc) and blocks (clang) both unusable if you want portable code even between the pair of them (and not generally).