HN Explorer

Ask HN: What resources do you recommend for learning Haskell?

109 points by hackerthemonkey ↗ HN
What resources do you recommend for learning Haskell?

I am working my way through “Learn You a Haskell for the greater good”

I also have a side project to learn things by doing, but was wondering what the most recommended learning sources were which people found very useful.

66 comments

[ 3.1 ms ] story [ 121 ms ] thread
lambdaba
Not meaning to hijack the thread, but I would be interested in opinions on the "best" type system implementation that has enough of a library ecosystem to be suitable for web/app development.

To be clear it's also for learning, but I'm wondering what else is there outside of the Haskell/PureScript etc. world.

yoyohello13
I really liked https://haskellbook.com/. It’s long, but has exercises after each chapter which I found very helpful.

The first chapter is about Lambda Calculus which is kind of a Haskell meme at this point, but learning it actually did help me a lot to grok how Haskell programs are meant to fit together.

Other than that, just doing some basic side projects and leaning about how to use Cabal effectively should get you there.

fn-mote
I love Haskell Programming from First Principles. It has details for everything. It has plenty of exercises you help you make friends with all of the "esoterica". Once I worked with the rules (e.g. how to make an instance of Applicative), they were a lot more concrete for me.

In Haskell, when you don't understand some detail it really comes back to get you. I read LYaH and I felt like I understood the big picture, but I didn't understand that it was critical to understand the types of _everything_ in an expression that I wrote. (My own failing.)

In summary: I highly recommend. https://HaskellBook.com

My background when I read it: 10+ years programming, 5+ years functional programming, 2 attempts reading LYaH (1 successfully). I still loved it. It would have saved me a lot of grief to start with the HB instead of LYaH.

hiAndrewQuinn
+1 for HPFFP. The 1200 page behemoth that finally made everything, and I mean everything, click.
bramhaag
Haskell Programming from First Principles[1] is extremely comprehensive, covering everything from lambda calculus to IO.

For further self-learning, it might be interesting to learn about the underlying mathematical concepts, such as category theory. A deep dive into the workings of a Hindley–Milner type system might also help demystify some of Haskell's typing magic.

[1] https://haskellbook.com/

matt-noonan
A common failure mode is for people to think Haskell is some special snowflake that requires reading 50 books and papers to understand. It doesn’t. Learning by doing is definitely the way to go. LYAH is fine but not great at practical problems. Real World Haskell is somewhat out of date but better at the actual “how do I make a program that does real things?” question. Best bet is to hack until you get stuck or your solution seems too ugly, then ask for leads on Reddit or the FP discord.
graemep
Graham Hutton's lectures (on Youtube) seem pretty good. He also has written a book. Both seem pretty good but not got very far yet myself.
tombert
Working through Learn You A Haskell is a good start.

After that, I honestly think you'll get the best bang-for-buck by reading library-specific tutorials. If you play with enough of the libraries the rest of the language more or less falls into place.

Conduit is a pretty ok streaming library, and has good documentation: https://github.com/snoyberg/conduit#readme

Lens gives you a lot of useful features that more or less correspond to stuff like Getters and Setters in something like Java, and the tutorials for it get into some helpful details about writing Haskell code: https://hackage.haskell.org/package/lens

Otherwise it's basically a lot of "just build shit, and don't be afraid to feel confused" and it'll fall into place.

codethief
I recently started reading Bartosz Milewski's Category Theory for Programmers[0] and while it's less about Haskell per se and more about the ideas behind it, I found it did a much better job at explaining Haskell to me than any other introduction I read before. At least I'm able to appreciate Typing the Technical Interview[1] now. :-)

[0]: https://github.com/hmemcpy/milewski-ctfp-pdf

[1]: https://aphyr.com/posts/342-typing-the-technical-interview

goostavos
This is a good source if you feel like waiting until chapter 14 for "so, anyways, that's how addition works." I know Haskell pretty well and I've bounced off Milewski's stuff multiple times.

Haskell != Category Theory. You don't have to know what an Endofunctor is in order to write useful programs. Haskell is just another programming language. It's totally possible to do cool stuff in it without knowing any of the theories that back a lot of the "why" behind its common abstractions.

Pick up any book and just start building toy programs! Don't over think it. Start very small. Make a CLI tool. Scrape some data off the internet. Even simple haskell programs will cause you to bump into all kinds of concepts at the time you need to learn them.

Just working through a book can make Haskell seem painfully esoteric. Monad transformers broke my brain when I tried to learn them simply because I reached the monad transformer chapter. However, I finally "got" them once I was actually building something, because their existence is something you naturally start to bump into the more you program. There's a friction that comes from no having them, but noticing that "friction" and letting it guide you can only happen over time as you use the language.

wrsh07
If you're familiar with functional programming, I really like the learnxinyminutes reference for Haskell: https://learnxinyminutes.com/docs/haskell/

I'm not sure why, but the Haskell one clicks for me more than some of their other guides.

This isn't a great way to learn Haskell, but it's enough to start writing working code (and writing working code is a good way to learn!!)

wrsh07
Ooh, one nice book is the Okasaki purely functional data structures. The inline code is not Haskell, but iirc the appendix has Haskell implementations
nvarsj
Haven’t touched Haskell in years, but I found the best guide was Brent Yorgey’s old UPenn CIS194 online class. It contains easy to digest text lectures with follow up classwork.

I successfully taught dozens of people who had no former functional background. Just did a weekly meeting covering the lecture and prior week’s homework.

https://www.cis.upenn.edu/~cis1940/spring13/lectures.html

nextos
It's also my favorite beginners resource. And free.

Straightforward and short. Takes you to the interesting bits very quickly.

rnallandigal
"What I wish I knew when learning Haskell" by Stephen Diehl[0][1]. It has commentary on a great deal of topics in Haskell and is very approachable. Also, learning to use Hoogle[2] will serve you well.

[0] https://smunix.github.io/dev.stephendiehl.com/hask/index.htm...

[1] https://github.com/sdiehl/wiwinwlh

[2] https://hoogle.haskell.org/

lemonwaterlime
This, and get comfortable letting the compiler (ghc) and the type system find errors for you. Change a piece of code and let the compiler tell you everywhere that is now broken. Fix it all. Continue coding.
anfelor
Perhaps contrary to most people in this thread, I think you should avoid learning lenses or category theory too early. These are great tools, but they take months or even years to master and are not required to write useful code in the language.

I find Haskell very useful for my projects, but to achieve this I restrict myself to the basic subset of the language (Haskell 2010, no fancy extensions such as type families or GADTs) and use few libraries aside from the core libraries. New features and libraries always carry a high learning curve in Haskell and less popular libraries can be buggy. Instead, you will often be more productive just writing the required functionality from scratch (and it will teach you more too!).

At Jane Street, I saw my coworkers learn functional programming in just one week. (some still struggled with monads in the second week -- if that is you, I can recommend Phil's paper: https://homepages.inf.ed.ac.uk/wadler/papers/marktoberdorf/b...). If you are learning Haskell in your free time and with no one experienced to help, it will obviously take you longer. If you have questions, feel free to post on the Haskell IRC or Reddit. Just don't worry that you need to read another tutorial before getting started :)

TwentyPosts
...what are lenses? Never heard of those.
turboponyy
As with anything Haskell, one could simply reply with "here's the formal definition."

But in easily digestible terms, it's a way to narrow your view over a collection to a subset that satisfies some property, and perhaps perform some operations on that subset.

This video presentation (with a very humorous audience dynamic, might I add) serves as a great introduction by example: https://youtube.com/watch?v=QZy4Yml3LTY

Zambyte
I'm going to watch the video, but I'm having trouble understanding how lenses are different from filter, and perhaps map. Is it just a combination of filter and map?
matt-noonan
No, it's quite different. A super rough but somewhat accurate starting point is to think of a lens as being like the `.foo.bar.baz` in `myobject.foo.bar.baz`: a way to describe some "location" inside of a data structure, in a way that allows for getting and setting. But lenses are also data, so they can be stored in variables, manipulated, and so on. It's a very useful concept, and very much not required or helpful when learning Haskell. It's also not a core Haskell concept in any sense, just something that has been built on top of Haskell as a library.
lgas
Also helpful to note that the "location" can be virtual. For example you could have a lens into the hours field a string that contains an ISO-8601 formatted date, so you could do something like

    let s = "20240722T193456.789-0800"
    putStrLn $ 19840206T193456.789-0800  -- prints "20240722T203456.789-0800"
and they can be composed, so if you have some other lens that gets from your outer structure to an ISO-8601 formatted date string field, let's call that lens `fieldLens` then `fieldLens . hours` will get from your outer structure to the hours field of that date field.
tmountain
I like this advice, but I would suggest adopting a prelude that has better defaults than what the language ships with.
edude03
Is there one you'd recommend?
doctorpangloss 

    type JokeM a = IO a

    askQuestion :: JokeM String
    askQuestion = do
      putStr "How do you know someone works at Jane Street? "
      hFlush stdout
      getLine

    tellPunchline :: String -> JokeM ()
    tellPunchline _ = putStrLn "They tell you!"

    janeStreetJoke :: JokeM ()
    janeStreetJoke = askQuestion >>= tellPunchline

    main :: IO ()
    main = forever janeStreetJoke
I don't know this feels kind of verbose to me.
rank0
What is the appeal of haskell? Genuinely curious
exe34
pure functional. no mutations. (state and i/o handled with inscrutable magic).

basically every code base out there could use more functional effort - simple data structures and simple functions that operate on these to return a brand new structure.

shae
Easy to fix work code in the middle of the night when pagerduty hits
mrkeen
Before Haskell I felt like I was cargo-culting advice - "use private fields with getters & setters", "everything should have an interface", "avoid static methods", "avoid 'new' and use factories instead". I figured eventually one of these days these things would click.

With Haskell came new principles which had immediately obvious value - "is your function well-defined over all possible inputs?" and "does it always produce the same output given the same input?".

I later 'got' that first set of principles, but I mostly disagree with them.

My day job has always involved looking at exceptions and logs, figuring out "how something went wrong", and then trying to fix it. Guess which set of principles helps me make software that typically "just works".

kryptiskt
It takes an idea[0] and runs with it as far as it goes. The best part is that when they got to obstacles like handling of IO, they didn't take the easy route and compromise the vision in favor of a pragmatic solution. Instead they went into unexplored territory and came back with monads, which proved an extremely fertile ground for more than IO.

Obviously, Haskell being an academic language helps here, since novel ideas lead to papers and boring old ideas don't.

[0]: That is statically typed lazy functional programming.

brudgers
Time. Learn a little Haskell this month. Learn a little Haskell in December. Some more over the next few years. In between you will be learning more about programming in general and many other things including how you learn.

There’s no midterm in eight weeks; no final grade after that, and nobody who matters cares how good or bad you are at Haskell. Like most things, it’s not worth having an opinion about.

Give yourself permission to write Haskell poorly because that makes it more likely you will write Haskell. Give yourself permission to not learn Haskell because maybe you like the idea of writing Haskell more than the work of learning Haskell…

…yep, time and permission are the best resources for learning Haskell (or anything else as an adult). It really doesn’t matter what book you pick. Either you enjoy committing or you don’t. Either the work feels satisfying while doing the work or doesn’t.

When the work is truly satisfying, it doesn’t need to be optimized against imagined external opinions. You just do it because it is what you do.

Or not. Good luck.

francogt
Haskell Programming from First Principles is probably the best and most exhaustive resource on learning Haskell.

I now refer people to “Effective Haskell” by Rebecca Skinner[0]. It’s well written, modern (published in 2023) and goes into everything you need to know to use haskell in common, real world tasks.

[0] https://pragprog.com/titles/rshaskell/effective-haskell/

[deleted]
(comment deleted)
mhitza
I think Learn you a Haskell is a good introduction, but you will learn more by doing.

I don't know what state of the art is nowadays for learning Haskell, I started my journey more than 10 years ago, but for help I recommend https://discourse.haskell.org/ whenever you feel stuck, have questions; instead of SO/subreddit.

edit: while Copilot, or equivalent, will hallucinate APIs that don't exist, I recommend having such a thing enabled as it will help you with syntax / standard library functions early on.

Also take a good look at the base, containers, directory, filepath, etc packages documentation. These come as part of the standard installation (with something like ghcup), and represent the "standard library" you have access to (on paper that would be only limited to base). For a full list of installed packages you can always run `ghc-pkg list` and start browsing the generated documentation on hackage.haskell.org