On Saturday, 28 April 2012 at 23:29:35 UTC, bearophile wrote:
Peter Alexander:

f(x) ---> x.f() is not progress in language design.

I used to think the same. But Haskell offers "." and $ to chain functions and remove parentheses, F# has the |> pipe operator. In D UCFS is almost equally useful to turn nesting of function calls in a more readable chain. In functional-style code this makes a lot of difference, turning:

foo(bar(copy(baz(a), spam(b))))

Into:

baz(a).copy(b.spam()).bar().foo()

When I see 3+ nested parentheses I find it hard to read the expression. While a chain is easy to read.

What D does and what Haskell does are very different things. D has (at least) two types of functions: free functions and member functions. UFCS makes free functions look like member functions. In Haskell, $ just gives you a way of re-ordering precedence -- it doesn't hide anything.

This matters because UFCS in D is deceitful. It makes you think the free function is a member function when it is not.

struct Foo { void bar() {} }
void baz(Foo f) {}

Foo f;
f.bar(); // ok
f.baz(); // ok, looks like baz is a member function
auto pbar = &Foo.bar; // ok
auto pbaz = &Foo.baz; // error!

IMO, D would be better with Haskell's function calling syntax (of course, this would require many, many other syntactical changes).


But in D the main purpose of "pure" is not as optimization tool, but more as a tool to enforce a better coding style, that makes code understanding (and testing simpler), and helps avoid some bugs, coming from using variables from outer scopes.

True, but I'm quite happy to write pure functions without the static checking. I do not believe that the safety provided by the static checks outweighs the development cost of ensuring you have the correct qualifiers everywhere.

Reply via email to