Haskell

Here is the truth about Haskell: it is the language where the type checker is not a nag – it is a collaborator that writes half the program with you. Once you accept that purity and laziness are features, a lot of software architecture lessons fall out for free.

What it is, in plain words

Haskell is a purely functional, statically typed, lazily evaluated language, born from academic language research in the late 1980s and still evolving (GHC is the main compiler; Haskell 2010 is the standard most people mean, with GHC extensions widely used). Its pillars:

Purity – a function of type Int -> Int cannot launch missiles. Effects are tracked in types (IO, STM, …).
Laziness – values are computed when needed, which makes infinite structures and cheap pipelines natural.
Type inference – you can omit most type signatures; the compiler still knows.
Type classes – ad-hoc polymorphism (Eq, Functor, Monad) without inheritance.
Algebraic data types and pattern matching – the backbone of readable logic.

Why it matters

Even if you never ship Haskell, a month with it permanently changes how you write Python, Rust, JavaScript and Lisp. Ideas that felt academic – pure functions, Maybe/Optional, parser combinators, software transactional memory – showed up in industry through Haskell’s influence. PureScript is its cousin on JavaScript; Rust’s traits owe a debt; Elm took a simpler slice to the browser.

An everyday analogy: a proof assistant for everyday code

Writing Haskell feels less like giving orders and more like constructing a proof that your program makes sense. The compiler is the examiner. Failures are usually type errors that point at the real mistake – not a crash at 3 a.m. in production.

flowchart LR
  S[source] --> G[GHC]
  G --> T[type check]
  T --> C[core → STG → LLVM/Cmm]
  C --> B[binary]
  T -. error .-> S

A hands-on example

sudo xbps-install -S ghc cabal-install   # or use ghcup
ghci                                     # the REPL

-- sum of squares of evens, the Haskell way
sumOfEvenSquares :: Int -> Int
sumOfEvenSquares n =
  sum [x * x | x <- [1..n], even x]

-- Algebraic data type + pattern match
data Shape = Circle Double | Rect Double Double
  deriving (Show, Eq)

area :: Shape -> Double
area (Circle r) = pi * r * r
area (Rect w h) = w * h

-- Maybe instead of null
safeDiv :: Double -> Double -> Maybe Double
safeDiv _ 0 = Nothing
safeDiv x y = Just (x / y)

-- fmap / Functor – apply a function under the Maybe
result :: Maybe Double
result = (*2) <$> safeDiv 10 4          -- Just 5.0

-- Do-notation for IO (effects are explicit)
main :: IO ()
main = do
  putStrLn $ show $ sumOfEvenSquares 10
  print $ area (Rect 3 4)
  print result

cabal init -n && cabal run

A taste of the ecosystem: Cabal / Stack for projects, Hackage for packages, hls (Haskell Language Server) for editor support. Popular libraries: aeson (JSON), servant or yesod (web), containers and unordered-containers, lens (optional, powerful).

A tiny project shape

mkdir hello-hs && cd hello-hs
cabal init -n --is-executable
# edit app/Main.hs, then:
cabal build
cabal run
cabal test

GHC2021 (a bundle of widely used extensions) is a sensible default for new code. Add dependencies in the .cabal file and let Cabal fetch them. For reproducible builds across machines, commit cabal.project.freeze or use Stack’s resolver pins.

Common misconceptions

“You must understand monads before writing anything.” You can write useful programs with IO and Maybe long before the abstraction clicks. Use do notation; learn the theory when you’re curious.
“Lazy means slow.” Lazy means when needed. Space leaks are the real footgun; bang patterns and strict data types fix them when profiling says so.
“Haskell is only academic.” It runs trading systems, card compilers, pandoc, PostgREST and plenty of production backends.
“No loops means no iteration.” Recursion, map, fold, scan, and forM_ cover the ground.
“Dynamic languages are freer.” Freedom to crash is not freedom. Haskell’s freedom is refactoring with a compiler as safety net.

Connections

Functional Programming, Lambda Calculus.
PureScript – Haskell-like on JS.
Haskell Kata – practice.
Rust, Common Lisp, PicoLisp – other points on the FP spectrum.