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
Because there were no compilers for it. Programmers wrote the code on paper and punched it out (card/tape readers). These pieces of paper/cards/tapes served the purpose of both, the source code and the compiled code. The format of the code on paper was determined by how the card/tape punches looked, and the compilers and other programs (like assemblers or linkers) were written in assembly language for specific machines.
In essence,