Comment by qznc | Hacker News Reader

Comment by qznc | Hacker News Reader

What if you could do "fully functional" programming within a language that also allows OO, procedural, and generic programming?

My exhibit would be D. Here is the 'identity' declaration:

    T identity(T)(const T me) pure nothrow @safe @nogc;

It cannot have side effect (do IO,start a thread,etc) because "pure". It cannot throw any exceptions because "nothrow". It cannot do any pointer-magic shenanigans because "@safe". It cannot modify the argument because "const". It even guarantees that no memory will be allocated through the garbage collector because "@nogc".

(Yes, pure by default etc would be better, but such a change would break too much code at this point. Yes, Haskell looks cleaner, but this article is not about beauty.)

How does "pure" work? How does the D compiler know the functions it calls do not have side effects?

More importantly, however, D's type system is not as expressive as Haskell's.

Pure functions can only call pure functions.

Details: http://dlang.org/function.html#pure-functions

And Haskell's type system is not as expressive as D's. E.g. records.

I'm not very good at D, but if you are referring to row polymorphic records, Haskell can do that too (e.g. https://github.com/nikita-volkov/record-preprocessor/blob/ma...)

> And Haskell's type system is not as expressive as D's. E.g. records.

Please, don't go there. D lacks add types and anything that isn't a first order type. Its type derivation also isn't even remotely as powerful.

But what a type! I would be much more inclined to annotate effectful code instead.

Well, it can be done simpler. The D compiler can infer those annotations for template functions such as this. So with an implementation you can write:

T identity(T)(T me) { return me; }

Reply on news.ycombinator.com