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
Is there a fundamental reason for it?
Or is it purely a matter of history and tradition?
(Also, what is the reason Python, which is designed for readability first, went down the path of one-pass C-style parsing instead of context-free parsing like ML family?)
This seems to be a very interesting topic for me and I'd love to hear all the arguments and counterarguments.

Here is a more detailed perspective on this topic