One is able to chain calls in C via:

    x()->g()->f();

At least one person at Bell Labs historically used that scheme for some graphics program.

All it requires is that the function returns a pointer to a struct which itself contains function pointers.

C also allows the dot form if you really want it:

    x().g().f()

Simply by returning structs, and for all compilers that I know if, such end up using a hidden pointers to structs.

Now to make it a bit more usable, one needs a bit of planning so that either of these can be done:

    x(&x_out).g(&g_out, x_out).f(&f_out, g_out);

    x(&x_out)->g(&g_out, x_out)->f(&f_out, g_out);

(I'd suggest the latter is now the more readable of the two).

Where there is a VFT in each of the xxx_out structures, and the calls simply returns the VFT, while the whole abstraction is stored/returned via the out arguments.

Gotta escape those asterisks so you don't output italics.

f(*g(*x)) is just as good as f(g(x*)*)

Hmm, function names go before parentheses, that looks like a good reason for dereferencing to be prefix too, otherwise they end up a long way apart.

But in the back of mind I'm thinking "semantics cause pointless fussy arguments, all code is ugly, let's stop programming in text somehow".