First of all, you should not incorrectly compare paradigms, functional vs imperative. Functional can actually be considered as a kind of imperative. (It is not declarative, right? :-)) And the question "why" is not, strictly speaking, correct. Why? Because it was designed this way.
This is because very pure paradigms are very impractical. The programming paradigm with immutable class instances cannot be OOP. Try to develop an OOP application with purely immutable classes (it actually cannot mean that classes are immutable at all, it means that they are immutable from the moment of completion of their construction), or even imaging such development, and you will see.
F# is not really a functional language. This is a multi-paradigm language: object-oriented, functional, imperative, and so on:
http://en.wikipedia.org/wiki/F_Sharp_%28programming_language%29[
^].
[EDIT]
With a multi-paradigm language, you can freely combine certain paradigm. What to use purely functional approach? Nothing prevents your from creation of immutable classes or structures (for example,
System.String is 100% immutable, and you can create your own types like that.)
This way, part of your product can be purely functional. For some other part, you can find only some functional features useful. Some other part can be non-functional or OOP+functional. Language should promote good style, but enforce much less, only what is critically important to enforce, not limiting expressive power of the code.
Speaking of the compiler enforcement (which is still important) vs personal programming discipline: you should understand that even with strongest enforcement, it's always possible to screw up everything.
[END EDIT]
Why? Because it present a good practical feature set. Because it was designed this way.
—SA
Submit an article or tip