????

Unfortunately, you will need to cover more ground with this proposal than what you have presented. It sounds simple but what you are suggesting is very complicated. Of course, to the OOP minds out there, they think their suggestion is a be-all-to-end-all, when in reality there are many ways to solve a problem.

I understand what you are trying to do. I am not suggesting it is wrong but C is not an OOP language. I dont see why we should PRETEND that it has OOP-class features when its all you advocating is smoke and mirrors.

Sure, C can do "OOP" but I must remind all that these techniques have been in C for years, before the OOP name was popularised and evolved into the form it is now. You are just forcing C programmers to program in such a way OOPLOVERS like when it is not required - and that is the modern OOP than has been forced on everything since the early-to-mid 90's.

You are just HIDING whats really going on

This proposal you are suggesting -- I am going to call this Typescript-C.

The problem is that this namespace/class overlay makes much ASSUMPTIONS what the programmer wants. Lets dig into this further. Here is how (I believe) you see it implemented :-

  // In my TypeScript-C.
  namespace Foo {

    class Bar {

      int baz;

      void init() {
        this->baz = 10;
      }

      void free() {
        // whatever
      }

      int process(int withval) {
        return withval + this->baz;
      }
    }
  }

  // calling example :-
  Foo.Bar sample;
  sample->init();
  printf("%d\n", sample->process(100));
  sample->free();

This would translate to :-

  // Translated C...
  typedef struct Foo_Bar {
    int baz;
  }

  void Foo_Bar_init(Foo_Bar *self) {
    self->baz = 10;
  }

  void Foo_Bar_free(Foo_Bar *self) {
    // whatever
  }

  int Foo_bar_process(Foo_Bar \*self, int withval) {
    return withval + self->baz;
  }

  // calling example :-
  Foo_Bar sample;
  Foo_Bar_init(&sample);
  printf("%d\n", Foo_Bar_process(&sample, 100));
  Foo_Bar_free();

My argument is, for starters, how is writing all this namespace and class wrapper actually better than the final code? Anyone that starts using C with namespaces and classes are going to assume we have inheritence, overrides, etc. Why?

If anyone is THAT bad they cannot write proper C code, then I suggest they move to C++, Java, C#, Dlang.. or whatever.

Its just adding extra fluff -- and C guys like to SEE what is going on. (Thats why it takes ages to truly grasp C++ internals)