You might be interested to learn that, way back in prehistoric times, a language called ALGOL 68 used a syntax close to what you propose.
Recognising that function identifiers are bound to values just like other identifiers are, you could in that language declare a function (constant) using the syntax 

> _function-type_ _name_ = (_parameter-list_) _result-type_ : _body_ ;

Concretely your example would read

 PROC (INT)INT add one = (INT n) INT: n+1;

Recognising the redundancy in that the initial type can be read off from the RHS of the declaration, and being a function type always starts with `PROC`, this could (and usually would) be contracted to

 PROC add one = (INT n) INT: n+1;

but note that the `=` still comes _before_ the parameter list. Also note that if you wanted a function _variable_ (to which another value of the same function type could later be assigned), the `=` should be replaced by `:=`, giving either one of

 PROC (INT)INT func var := (INT n) INT: n+1;
 PROC func var := (INT n) INT: n+1;

However in this case both forms are in fact abbreviations; since the identifier `func var` designates a reference to a locally generated function, the fully expanded form would be

 REF PROC (INT)INT func var = LOC PROC (INT)INT := (INT n) INT: n+1;

This particular syntactic form is easy to get used to, but it clearly did not have a large following in other programming languages. Even functional programming languages like Haskell prefer the style `f n = n+1` with `=` _following_ the parameter list. I guess the reason is mainly psychological; after all even mathematicians don't often prefer, as I do, _f_ = _n_ ⟼ _n_ + 1 over _f_(_n_) = _n_ + 1.

By the way, the above discussion does highlight one important difference between variables and functions: function definitions usually bind a name to one specific function value, that cannot be later changed, whereas variable definitions usually introduce an identifier with an _initial_ value, but one that can change later. (It is not an absolute rule; function variables and non-function constants do occur in most languages.) Moreover, in compiled languages the value bound in a function definition is usually a compile-time constant, so that calls to the function can be compiled using a fixed address in the code. In C/C++ this is even a requirement; the equivalent of the ALGOL 68

 PROC (REAL) REAL f = IF mood=sunny THEN sin ELSE cos FI;

cannot be written in C++ without introducing a function pointer. This kind of specific limitations justify using a different syntax for function definitions. But they depend on the language semantics, and the justification does not apply to all languages.