Walter:

> Saying Scala supports functional is also a stretch, because it supports only 
> one 
> of the three defining characteristics of functional programming. It doesn't 
> even 
> support the other two in a half-assed manner, it doesn't support them at all.
> 
> I didn't invent my own definition of functional programming. I am using the 
> standard definition that anyone can look up. I don't see that as being 
> unreasonable, binary, or misusing the term.

This is an interesting discussion topic. Scala is widely regarded as a rather 
functional language (more than C#, less than F# and OCaML and Haskell). Why is 
Scala perceived as quite functional?

1) It has pattern matching, lazy stream lists similar to Haskell lists, its 
standard library is rather functional oriented, its has better type inference, 
is has a very powerful type system that allows to express lot of static 
invariants, and generally Scala encourages to use immutability over mutability, 
there are immutable collections too in its standard library, and they are 
preferred. All this makes Scala rather handy for functional programming despite 
it lacks "true" immutability and true purity.

2) It's a matter of syntax too. Scala has optional parenthesys, and other 
sylistic features that are pleasant for functional programming. While if you 
try to use a functional-style programming in D you often produce unreadable 
lines of code. I have shown this several times in the D newsgroup but nearly 
nobody seemed to care.

3) It's a bit a matter of perception too. People think of it as partially 
functional because lot of people do it, and it is advertised for this. Around 
it there are functional programmers too, even academic ones.

Regarding D immutability and purity, often you can't put a map() in a pure 
function, and many Phobos functions don't work with const/immutable data. This 
makes D almost a joke for functional programming. This side of D will improve, 
but Scala is there already.


import std.algorithm: map, filter;
int foo(immutable int x) pure nothrow {
    return 1;
}
void main() pure {
    immutable data = [1, 2, 3];
    auto m1 = map!((x){ return 1; })(data);     // OK
    auto m2 = map!((int x){ return 1; })(data); // OK
    auto m3 = map!q{ 1 }(data); // error, map is not pure
    auto m4 = map!foo(data);    // error, map is not pure
    //------------
    auto f1 = filter!((x){ return 1; })(data);     // OK
    auto f2 = filter!((int x){ return 1; })(data); // OK
    auto f3 = filter!q{ 1 }(data); // error, filter is not pure
    auto f4 = filter!foo(data);    // error, filter is not pure
}

Bye,
bearophile

Reply via email to