Some Notes About How I Write Haskell

https://blog.infinitenegativeutility.com/2017/12/some-notes-about-how-i-write-haskell

by chopin • 8 years ago

191 43 8 years ago

blog.infinitenegativeutility.com

Bootvis• 8 years ago

Title would be more clear if it didn’t start with the title of the blog.

From the earliest days, amateurs instruct computers, while professionals write executable stories. I loved reading the projection of this quip into Haskell.

samwestdev• 8 years ago

What is that supposed to mean?

mlevental2• 8 years ago

it's pretentious nonsense about how programming should be declarative rather than imperative and the implication that Haskell (the one true God) is. this point of view of course forgets that Turing tape machines came first and lambda calculus second and that most theory is still done using TMs rather than categories.

krnsn• 8 years ago

"Programs are meant to be read by humans and only incidentally for computers to execute."

- Donald Knuth

z5h• 8 years ago

"amateurs instruct computers, while professionals write executable stories" Did you just make this up? I think this is an important idea.

TuringTest2• 8 years ago

Programming has much more in common with literature than what engineers typically realize. (Not to mention its relation with philosophy, with classes being a pure Aristotelian system of universals).

Even for programs that are meant to be written and compiled once and never maintained, the programmer needs to build in their mind the whole story of the required computation, and put it in words for the compiler to transform it to low-level instructions. The clearer the programming language, the easier will be to reason about that story.

nocobot• 8 years ago

I found the paragraph about iterating with list comprehensions very illuminating. As someone who is just starting to learn Haskell, deciding when not to use map / filter is something where my intuitions regularly seem to be off.

tom_mellior• 8 years ago

I like the fact (that I didn't know before) that you can use refutable patterns in the way shown here, as filters in a list comprehension. That feels almost like logic programming.

mrkgnao• 8 years ago

This is a nifty thing made possible by the MonadFail class, which defines how a monad treats or recovers from a failed pattern-match.

    When a value is bound in do-notation, the pattern on the
    left hand side of <- might not match. In this case, this 
    class provides a function to recover.

https://hackage.haskell.org/package/base-4.10.1.0/docs/Contr...

suj1th3• 8 years ago

As somebody who works with Scala, List comprehensions (and associated filters) were indeed a surprise to me as well when I started hacking in Haskell. Their resemblance to logic programming makes it so much more elegant, and so much easier to reason about.

KirinDave3• 8 years ago

This is a good and well-written article, but it's worth noting that I think many of the ideas here cut slightly against the grain of current Haskell best practices. Which is not to say any specific part is right, but for example the entire discussion on QuickCheck is hard to really make sense of and arbitrary is a famously good use of type classes.

Probably the most countercultural paragraph is the paragraph on recommending you make a fresh type rather than reuse an existing type. I think that you lose so many useful operations eschewing maybe for your uniquely named Maybe [1] that a type alias is probably a much better call there, and also captures what you meant more generically. Further, stuff like Maybe over a more specific instance works much better with valuable tools like Compose.

Similarly, the redundant constraint on Empty is the sort of thing that will only trip you up in the real world.

All in all, great article tho.

[1]: People underestimate the compiler cost of deriving instances. It adds up very fast if you derive lots of functors and foldables in your quest for unique names everywhere.

davidmr• 8 years ago

Thanks for your commentary too. I’m starting to learn Haskell, and the nature of the language seems to lead to less “best practices” articles out there.

Seeing knowledgeable people comment on things written by other knowledgeable people seems to be the best way to learn how Haskell is done in the wild (i.e. anything outside the text I’m learning Haskell from at the moment)!

KirinDave3• 8 years ago

Full disclosure, I _like_ ConstraintKinds and constraint oriented programming in many cases, and you can find evidence of that in my comment history.

moomin• 8 years ago

There's quite a few people who don't like arbitrary, though, aren't there? Hedgehog is growing in popularity as an alternative to the quickcheck approach.

KirinDave3• 8 years ago

I know there is a contingent of people who feel this way, but to be honest I've never heard a compelling argument out of them other than the vague complaints about type classes.

You can certainly do things the way Hedgehog does and it's great. I think many of the nice parts of Hedgehog are not incompatible with quickcheck.

harpocrates• 8 years ago

People underestimate the compiler cost of deriving instances. It adds up very fast if you derive lots of functors and foldables in your quest for unique names everywhere.

Do you pay this price when you derive via a `newtype`? Or does GHC figure out that the instance it would write out would be identical (modulo coercions)?

acomar• 8 years ago

It can generate the instance for you for particular typeclasses with an extension. See DeriveGeneric and DeriveAnyClass. The penalty applies when you're unwilling to use these extensions or when you create a type with the `data` keyword.

alien_at_work• 8 years ago

the entire discussion on QuickCheck is hard to really make sense of and arbitrary is a famously good use of type classes

I found it understandable but for me the issue was: all the problems that author pointed out are true but you're not forced to make an instance of Arbitrary. I rarely do in my tests. But some times it really does make sense and in those cases it's nice to have.

rs86• 8 years ago

This is very weird Haskell. The fizz buzz example concatenating strings where an alternative would fit and the pointful point free example for instance.

chopin• 8 years ago

I liked the fizzbuzz example very much because it was so unorthodox.

Some Notes About How I Write Haskell

Related Stories