Add a namespacing macro and you have a whole generics system, unlike that in TFA.

So, it might add more value to have the C std add an `#include "file.c" name1=val1 name2=val2` preprocessor syntax where name1, name2 would be on a "stack" and be popped after processing the file. This would let you do types/functions/whatever "generic modules" with manual instantiation which kind of fits with C (manual management of memory, bounds checking, etc.) but preprocessor-assisted "macro scoping" for nested generics. Perhaps an idea to play with in your slimcc fork?

  #include <stdlib.h>
  #include <stdio.h>
  
  #define vec(T) struct vec##T { T* val; int size; int cap; }
  
  #define vec_push(self, x) {                                                 \
      if((self).size == (self).cap) {                                         \
          (self).cap = (self).cap == 0 ? 1 : 2 * (self).cap;                  \
          (self).val = realloc((self).val, sizeof(*(self).val) * (self).cap); \
      }                                                                       \
      (self).val[(self).size++] = x;                                          \
  }
  
  #define vec_for(self, at, ...)             \
      for(int i = 0; i < (self).size; i++) { \
          auto at = &(self).val[i];          \
          __VA_ARGS__                        \
      }
  
  struct test
  {
      vec(double) v;
  };
  
  void test_fun(vec(double)* self)
  {
      vec_push(*self, 4.0);
      vec_push(*self, 5.0);
  }
  
  int main()
  {
      vec(int) a = {};
      vec_push(a, 1);
      vec_push(a, 2);
      vec_push(a, 3);
      vec_for(a, at, {
          printf("%d\n", *at);
      });
  
      struct test test = {};
      vec_push(test.v, 1.0);
      vec_push(test.v, 2.0);
      vec_push(test.v, 3.0);
      test_fun(&test.v);
      vec_for(test.v, at, {
          printf("%f\n", *at);
      });
  }

  Never mix unsigned and signed operands. Prefer signed. If you need to convert an operand, see (2).

https://www.youtube.com/watch?v=wvtFGa6XJDU

"struct Goose { float weight; }" and "struct Beaver { float weight; }" would remain incompatible, as would "struct { float weight; }" and "struct { float weight; }" (since they're declared without tags.)