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?
The answer is that C was initially created as an assembly like language and it was much more difficult to add such a keyword later. In fact, there have been many arguments about which way is better, but in the end, when we develop, we just get used to the syntax of a language and try to write our code in the most readable way, and both ways can be valid, which is why both are still used and both can be found in the biggest codebase in the world,
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,