This question has been going through my mind quite a lot lately and since I haven't found a convincing answer to it I would like to know if other users
of this site have thought about it as well.
In the recent years, even though OOP is still the most popular programming paradigm, functional programming is getting a lot of attention. I have only
used OOP languages for my work (C++ and Java) but I am trying to learn some
FP in my free time because I find it very interesting.
So, I started learning Haskell three years ago and Scala last summer. I plan to
learn some SML and Caml as well, and to brush up my (little) knowledge of Scheme. Well, a lot of plans (too ambitious?) but I hope I will find the time
to learn at least the basics of FP during the next few years.
What is important for me is how functional programming works and how / whether
I can use it for some real projects. I have already developed small tools in Haskell.
In spite of my strong interest for FP, I find it difficult to understand why
functional programming constructs are being added to languages like C#, Java, C++, and so on. As a developer interested in FP, I find it more natural to
use, say, Scala or Haskell, instead of waiting for the next FP feature
to be added to my favourite non-FP language.
In other words, why would I want to have only some FP in my originally
non-FP language instead of looking for a language that has a better support
for FP?
For example, why should I be interested to have lambdas in Java if I can switch
to Scala where I have much more FP concepts and access all the Java libraries
anyway?
Similarly: why do some FP in C# instead of using F# (to my knowledge,
C# and F# can work together)?
Java was designed to be OO. Fine. I can do OOP in Java (and I would like to keep using Java in that way). Scala was designed to support OOP + FP. Fine: I can use a mix of OOP and FP in Scala. Haskell was designed for FP: I can do FP in Haskell. If I need to tune the performance
of a particular module, I can interface Haskell with some external routines
in C.
But why would I want to do OOP with just some basic FP in Java?
So, my main point is: why are non-functional programming languages being extended with some functional concept?
Shouldn't it be more comfortable (interesting, exciting, productive) to
program in a language that has been designed from the very beginning to
be functional or multi-paradigm? Don't different programming paradigms
integrate better in a language that was designed for it than in a language
in which one paradigm was only added later?
The first explanation I could think of is that, since FP is a new concept
(it isn't new at all, but it is new for many developers), it needs to be
introduced gradually. However, I remember my switch from imperative to OOP:
when I started to program in C++ (coming from Pascal and C) I really had to
rethink the way in which I was coding, and to do it pretty fast.
It was not gradual. So, this does not seem to be a good explanation to me.
Also, I asked myself if my impression is just plainly wrong due to lack
of knowledge. E.g., do C# and C++11 support FP as extensively as, say,
Scala or Caml do? In this case, my question would be simply non-existent.
Or can it be that many non-FP programmers are not really interested in
using functional programming, but they find it practically convenient to
adopt certain FP-idioms in their non-FP language?
IMPORTANT NOTE
Just in case (because I have seen several language wars on this site):
I mentioned the languages I know better, this question is in no way
meant to start comparisons between different programming
languages to decide which is better / worse.
Also, I am not interested in a comparison of OOP versus FP (pros and cons).
The point I am interested in is to understand why FP is being introduced
one bit at a time into existing languages that were not designed for it
even though there exist languages that were / are specifically designed
to support FP.
