In general, there are two types of syntax of defining functions - Something like C, C++, C#, or Java (```int functionName(char arg)```) vs the ML (and others) tradition of defining the return type after the function (and using something like a ```fun``` keyword to define a function - like ```fun functionName(char arg): int```).
One of the advantages (for the parser, at least) for a ```fun``` keyword is that it lets the parser be context-free (it doesn't have to guess if ```int``` defines a variable or if it defines a function).
When C was invented, computers had very little memory and speed (so little, that the reason C requires one to define all the variables in the beginning of the function was because it had to be a one-pass parser). Why didn't they choose the simple way out and use function defining keyword?
What benefits were there to that particular style of defining functions with ```int functionName(char arg)```?
(Note: By no means do I see a problem with the modern C or C++ versions that give such syntactic sugar. I'm asking about the historical reasoning leading to that particular coding style)

Comment: Related: [When did return type notation become the default in C?](http://stackoverflow.com/q/2640319
Was it just because of cultural inertia of the time? Or is there something technical that prevents the parser of being able to be simple like the ML?

My question is a follow up to this one but I guess I'm getting deeper into this rabbit hole: Does C have any advantages, technically speaking, that force it to not use a ```fun``` or similar keyword instead of the C's syntax when defining a function?

Comment: In C,