I’ve been writing Haskell on and off since about 2001, including three years as a full-time job. This is what I’ve learnt…

1. Haskell is the promise that you can write it as cleanly as your understanding of it. Have faith.
2. Always be looking for patterns. Abstract them always and only when it simplifies.
3. Persevere in getting an abstraction just right. When you find it, everything will magically fall into place.
4. The implementation is the design.
5. Hide whatever the caller shouldn’t care about. In particular, you can remove type parameters with appropriate quantification.
6. There’s a reason fst3, snd3, thd3 are not in base. Triple or bigger: create a data type with fields instead.
7. Never make an instance unless it morally follows the class’s rules.
8. Instances of simpler classes are more valuable than of more complex generalisations.
9. Monoid: not a flashy class, but still definitely worthwhile.
10. Applicative: hugely underappreciated, and good for types that have “static information”. Lets you do deep magic with traverse and sequenceA.
11. Monad: potential instances are usually easy to spot.
12. The fewer type parameters in a class, the better. Can you turn any into associated types? Can you split the class into two classes? Can you hive off some of the parameters into a superclass?
13. Don’t worry about strictness until it’s time to optimise.
14. Intuition about optimisation tends to be bad. Before profiling, limit yourself to reasoning about complexity classes.
15. An orphan instance is a very minor wart.
16. Types themselves are weightless (i.e., erased). For example, * dropped from kind to type (with TypeInType) carries no information.
17. You probably won’t need IORef.
18. Template Haskell comes with a high cost in intelligibility. Sometimes it’s worth it.

— Ashley Yakeley