15

When starting a new Haskell project which needs language features that are offered by both new and older extensions, which should I use? The new one or the old one? For example:

I incline towards the newer ones as they feel cleaner and they add more features to the language in a unified manner. However, the older ones are supported by more compilers, they're used in existing libraries and perhaps also better known among programmers.

Update: As mentioned in answers/comments, the "supersede" relationships above are not completely precise. However, I'm interested in (often occurring) cases when a task can be accomplished equally well by several extensions.

Petr
  • 62,528
  • 13
  • 153
  • 317
  • Correct me if I'm wrong but TypeFamilies does not fully supersede FunctionalDependencies (FD allows overlapping instances, hence recursion) – max taldykin Nov 16 '12 at 19:36
  • @maxtaldykin You're right, but in most cases I encountered TypeFamilies could replace FD. – Petr Nov 16 '12 at 20:07
  • 1
    @maxtaldykin Type families can have overlapping instances and recursion. It's true that they do not supersede functional dependencies; however the reason is quite subtle. The very end of [this paper](http://www.monoidal.net/papers/qhaskell.pdf) discusses it a bit, but almost as an off-the-cuff remark, and I don't recall seeing any other real examples that try to make a small (understandable =) piece of code that can't be interencoded. – Daniel Wagner Nov 16 '12 at 20:25
  • 1
    I worry that this question isn't really objectively answerable... – Daniel Wagner Nov 16 '12 at 20:30
  • BTW, as far as I know, TypeFamilies subsume GADTs. However the encoding can sometimes be non-straightforward. – opqdonut Nov 16 '12 at 20:56
  • 1
    @DanielWagner, TF have a bit limited support of overlapping, e.g. it's not possible to have both `instance F a` and `instance F (a->b)` – max taldykin Nov 16 '12 at 20:58
  • 1
    I worry that this question was answered in the last paragraph of this question – luqui Nov 16 '12 at 23:56

2 Answers2

13

"supersede" is very ambiguous here.

For language features that have semantics that overlap with other features, we can recognize a few cases:

  • some features generalize existing ones
  • some offer alternative approaches

In the case of more general features, there are risks and benefits. The generality can impact many other parts of the language, or be restricted. In the latter, choose the general case.

If it is a choice between alternative approaches, with no strict ordering, such as FDs or ATs, then it is harder to give general advice.

So, in summary, "no" , there's no obvious reason to use "new" things over "old" things, when it comes to language features. They don't sort that way.

Don Stewart
  • 137,316
  • 36
  • 365
  • 468
  • I'm concerned about cases where the task can be accomplished by several extensions and no extension offers a significant benefit over the others. (I'll add it to the question too.) – Petr Nov 20 '12 at 12:19
5

In short, yes, and for the reasons you state: cleaner and clearer.

Occasionally I've come across places where there's a class better expressed as a multi-parameter type class with functional dependency because you can get more parametricity more simply that way, but usually an associated type family is a clearer and more flexible way of epressing it. Type families are much more intuitive to a functional programmer than functional dependencies.

GADTs have much cleaner, clearer syntax than existential quantification, with fewer conceptual hurdles, and it's easy to get the behaviour you want.

I'd recommend using the new stuff if you can, and the old ways if necessary. These lovely newer extensions could do with a higher profile.

AndrewC
  • 32,300
  • 7
  • 79
  • 115