Don't Panic: Haskell Fundamentals

Haskell is a programming language that asks code to describe values and relationships, then asks the compiler to make an unreasonably thorough fuss when those descriptions do not fit. Instead of updating variables through a sequence of statements, you build expressions. An expression has a value and a type. This is less mystical than it first appears, which is fortunate because mystical build errors are still build errors.

The important bit is purity. A pure function gets arguments and returns a result without changing hidden state. Give it the same inputs and it gives the same result. That makes a calculation easier to inspect, test, combine, and move around. It does not mean programs cannot read files, talk to a network, or print a greeting. Those jobs live in IO, a type that describes an action the runtime performs. The action is visible in the type, which keeps the unpredictable world from disguising itself as an ordinary string.

The other load-bearing idea is types. A type tells the compiler which values an expression accepts and returns. Haskell often infers this information, but a written signature makes an interface easier to read. Data constructors then make possible states visible. A value can be Success or Failure; pattern matching makes the program handle the shape it received. The compiler cannot decide whether a business rule is sensible, but it can be remarkably persistent about a rule expressed clearly.

Then there is lazy evaluation. Haskell computes an expression when its value is needed, so a program can ask for five elements from an unbounded list without attempting to requisition the whole universe. The catch is that unevaluated work can retain data. Correct output is not a guarantee of modest memory use, so profiling remains part of adult supervision.

Start with the Cheatsheet when a term such as currying, a type class, or a thunk needs a compact definition. Use the Practice Reference to model a small result type and keep its classification pure. The Exercise checks that the model works in GHCi. After that, the Reference tab leads from the language report to GHCi, Cabal, and profiling. The path is expressions and types first, then functions and patterns, then data types and effects. Haskell is mostly a way to make the program say what it means. The rest is the compiler asking whether it meant it consistently.