Haskell Study Notes

Algebraic Data Types

How Haskell builds custom types from sum types and product types using data declarations, pattern matching, records, and recursion.

Applicatives Explained

Learn how the Applicative type class extends Functor with pure and <*>, letting you combine several independent effectful values -- Maybe validations, list com…

Building a CLI Tool in Haskell

A practical walkthrough of structuring a command-line tool in Haskell, covering argument parsing, IO, and packaging with Cabal or Stack.

Cabal and Package Management

Learn how Cabal defines, builds, and resolves dependencies for Haskell projects, and how it works alongside Stack and Hackage.

Concurrency in Haskell

Learn how Haskell's lightweight threads, MVar, STM, and the async library make concurrent and parallel programming safer and more composable.

Error Handling in Haskell

Learn how Haskell represents failure explicitly using Maybe, Either, and exceptions, and when to reach for each approach.

Functions in Haskell

How to define, call, curry, and locally scope functions in Haskell, including lambdas and where/let bindings.

Functors Explained

Understand Haskell's Functor type class -- how fmap maps a function over a structure like Maybe, a list, or Either while preserving its shape, and the laws tha…

Guards and Case Expressions

Learn how boolean guards and case expressions give Haskell readable, structured alternatives to nested if-then-else chains for multi-way branching.

Haskell Best Practices

Practical conventions and idioms for writing clean, maintainable, idiomatic Haskell code, from naming and type signatures to error handling and module design.

Haskell Interview Questions

Common Haskell interview topics and questions, from type-class fundamentals to monads and lazy evaluation, with explanations you can use to prepare.

Haskell Quick Reference

A condensed reference covering core Haskell syntax, common types, standard library functions, and idioms for quick lookup while coding.

Haskell vs Imperative Languages

A comparison of Haskell's pure functional, lazy, declarative model against the mutable-state, sequential style of imperative languages like C, Java, and Python.

Higher-Order Functions in Haskell

Learn how Haskell treats functions as first-class values, and how map, filter, foldr, currying, and composition let you build programs out of small, reusable p…

Installing GHC and Stack

How to set up a working Haskell toolchain -- GHC, Cabal, Stack, and HLS -- using GHCup, and the daily commands you'll use to build and run projects.

Lazy Evaluation in Haskell

How Haskell's non-strict evaluation model defers computation until results are needed, enabling infinite structures but requiring care around space leaks.

Lists and List Comprehensions

Learn how Haskell's linked-list data type works and how list comprehensions let you build, filter, and transform lists with concise, declarative syntax.

Maybe and Either

How Haskell uses the Maybe and Either types to represent optional values and recoverable errors explicitly, without null or exceptions.

Monads Explained

Learn how the Monad type class extends Applicative with >>= (bind), letting a computation's result decide what runs next, and how do-notation, Maybe, list, and…

Pattern Matching in Haskell

Learn how Haskell lets you destructure values directly in function definitions and case expressions to write clear, exhaustive branching logic.

Pure Functions and Immutability

Understand what makes a Haskell function pure, why referential transparency matters, and how immutability changes the way you update data and reason about prog…

Recursion in Haskell

Understand why recursion is the primary looping mechanism in Haskell, how base cases and recursive cases work, and how tail recursion and laziness affect perfo…

Testing Haskell Code

Learn how to write unit tests, property-based tests, and doctest examples for Haskell code using HUnit, Hspec, and QuickCheck.

The Haskell Type System

How Haskell's static, strong type system uses type signatures, inference, and kinds to catch errors before a program ever runs.