← Back to context

Comment by uecker

15 hours ago

This is why I want to have such a feature in C. It would be extremely useful for language interoperability.

But because ISA was mentioned, x86 does indeed even have native support for this: https://devblogs.microsoft.com/oldnewthing/20231211-00/?p=10... These instructions are not too useful though and I do not think anybody uses them.

4 comments

uecker

Reply
klodolph  14 hours ago

This feature would IMO violate the contract that C allows you to specify memory layout of objects, to some level of detail (I am being a little vague about the “level of detail”).

Supporting closures, more or less, requires design decisions that are equivalent to choosing a specific layout for objects in an object-oriented language. C, as it is, makes none of these assumptions and you can translate a lot of different language ABIs into some C code (that may be clumsy). Keeping the abstraction that function pointers = pointers to entry points for functions, well, that’s frustrating for C programmers writing C programs, but extremely useful for interoperability.

  • uecker  12 hours ago

    At the moment we can not call nested functions or other things from other language from C, which is a pretty big hole in our interoperability story. I do not see why we need to make any design decision to specify object layout, we simply need a code pointer and static chain pair, which would then be sufficient to call arbitrary entities from other languages.

    • klodolph  6 hours ago

      > I do not see why we need to make any design decision to specify object layout

      > we simply need a code pointer and static chain pair

      The code pointer and chain pair needs an object layout. You would have to pick a specific layout, and it would not be compatible with other languages that have a different layout.

      Right now I can do this:

          struct a {
      void (*fun)(void *ctx);
      int data1;
      int data2;
    };
    struct b {
      void (*fun)(void *ctx);
      void *ctx;
    };

      And I could call them:

           struct a *aptr;
     a->fun(aptr);

     struct b *bptr;
     b->fun(bptr->ctx);

      There is only one neutral, maximally compatible option here—which is to have the function pointer separate from the arguments you want to pass in, and pass them in explicitly.

      If you add closures to C you are making compatibility worse, not better.

      1 reply →