Pattern Matching in Haskell

Pattern matching lets you define a function as a series of equations, each matching a different shape of input, rather than writing nested if statements — describe 0 = "zero" and describe n = "nonzero: " ++ show n dispatch on whether the argument literally equals 0 or falls through to the catch-all variable pattern n. The same mechanism destructures algebraic data types: given data Shape = Circle Double | Rectangle Double Double, a function area (Circle r) = pi * r * r and area (Rectangle w h) = w * h pulls the radius or width/height straight out of the constructor without calling a separate accessor function. GHC checks pattern matches for exhaustiveness and will warn (or error, with -Wall -Werror) if you forget a constructor, catching a class of bugs that's easy to miss with manual if/else chains.

Lists have their own natural patterns built from [] and :, so sumList [] = 0 and sumList (x:xs) = x + sumList xs matches the empty list as the base case and splits any non-empty list into its head x and tail xs for the recursive case. Tuples destructure positionally, so midpoint (x1, y1) (x2, y2) = ((x1+x2)/2, (y1+y2)/2) pulls out coordinates without any explicit fst/snd calls, and nested patterns like (x:_:rest) let you grab the first element, skip the second with the wildcard _, and bind the remainder in a single line. Guards can be combined with patterns for extra precision, as in classify (x:xs) | x > 0 = "starts positive", letting you match structurally and then further refine with a boolean condition.

The case expression brings the same pattern-matching power into any expression position, not just top-level function equations: case shape of Circle r -> ...; Rectangle w h -> ... lets you match locally, inside a let or where, or as an argument to another function. Because Haskell's type system knows every constructor of a data type, GHC's exhaustiveness checker can prove at compile time whether a case covers every possibility — enabling -Wincomplete-patterns to flag a forgotten branch before the program ever runs, unlike dynamically typed languages where a missing else branch might only surface as a runtime crash. This compile-time safety net is one of the biggest practical reasons Haskell developers lean on algebraic data types and pattern matching instead of manual type tags and casts.