C is, of course, totally up for writing generic functions already. The patten I like most is a struct of const function pointers, instantiated as a const global

C is, of course, totally up for writing generic functions already. The patten I like most is a struct of const function pointers, instantiated as a const global, then passed by address to whatever wants to act on that table. Say you took a C++ virtual class, split the vtable from the object representation, put the vtable in .rodata, passed its address along with the object. Then write that down explicitly instead of the compiler generating it. Or put the pointer to it in the object if you must. Aside from &mod or similar as an extra parameter, codegen is much the same. If you heed the "const" word above the compiler inlines through that just fine. There's no syntactic support unless you bring your own of course but the semantics are exactly what you'd want them to be. Minimal example of a stack of uint64_t where you want to override the memory allocator (malloc, mmap, sbrk etc) and decided to use a void* to store the struct itself for reasons I don't remember. It's the smallest example I've got lying around. I appreciate that "generic stack" usually means over different types with a fixed memory allocator so imagine there's a size_t (*const element_width)() pointer in there, qsort style, if that's what you want. struct stack_module_ty { void *(*const create)(void); void (*const destroy)(void *); size_t (*const size)(void *); size_t (*const capacity)(void *); void *(*const reserve)(void *, size_t); // This push does not allocate void (*const push)(void *, uint64_t); // pop ~= peek then drop uint64_t (*const peek)(void *); void (*const drop)(void *); }; // functions can call the mod->functions or // be composed out of other ones, e.g. push can be // mod->reserve followed by mod->push static inline uint64_t stack_pop(stack_module mod, void *s) { uint64_t res = stack_peek(mod, s); stack_drop(mod, s); return res; } I like design by contract so the generic functions tend to look more like the following in practice. That has the nice trick of writing down the semantics that the vtable is supposed to be providing which tends to catch errors when implementing a new vtable. static inline uint64_t stack_peek(stack_module mod, void *s) { stack_require(mod); stack_require(s); #if STACK_CONTRACT() size_t size_before = stack_size(mod, s); size_t capacity_before = stack_capacity(mod, s); stack_require(size_before > 0); stack_require(capacity_before >= size_before); #endif uint64_t res = mod->peek(s); #if STACK_CONTRACT() size_t size_after = stack_size(mod, s); size_t capacity_after = stack_capacity(mod, s); stack_require(size_before == size_after); stack_require(capacity_before == capacity_after); #endif return res; }