The Haskell Type System

Analogy categoryAnalogies

What Makes Haskell's Type System Different

Haskell is statically and strongly typed: every expression has a type that GHC determines at compile time, before the program ever runs, and that type never changes or gets silently coerced. Unlike Python or JavaScript, where a variable can hold an Int one moment and a String the next, a Haskell value's type is fixed, and mixing an Int with a Double in an arithmetic expression is a compile error rather than an automatic conversion. This means an entire class of bugs -- calling a function with the wrong kind of argument, or accidentally treating a string as a number -- is caught before the code is ever executed, not discovered in production.

🏏

Cricket analogy: Just as a scorecard has fixed columns -- runs are always numeric, the batter's name is always text -- and you can't scribble a player's name into the runs column, Haskell rejects at compile time any attempt to use an Int where a String is expected.

Type Signatures and Reading `::`

A type signature declares a value's type using ::, read as 'has type', so add :: Int -> Int -> Int says add is a function from an Int and another Int to an Int. Because Haskell functions are curried by default, that arrow-separated signature actually describes a function that takes one Int and returns a new function of type Int -> Int, which then takes the second Int and produces the final Int -- add 3 4 is really (add 3) 4. Reading signatures right-to-left as 'takes this, then this, then returns that' becomes second nature, and GHCi's :t command lets you check the inferred signature of any expression interactively.

🏏

Cricket analogy: A bowling figures line like '10-2-45-3' reads left to right as overs, maidens, runs, wickets, each slot with a fixed meaning in sequence, the same way add :: Int -> Int -> Int reads left to right as 'takes an Int, then another Int, then returns an Int'.

haskell

-- Type signatures use `::`, read as "has type"
add :: Int -> Int -> Int
add x y = x + y

-- Currying: add is really a function returning a function
addFive :: Int -> Int
addFive = add 5          -- partially applied

greet :: String -> String
greet name = "Hello, " ++ name

-- In GHCi, :t shows the type of any expression
-- ghci> :t add
-- add :: Int -> Int -> Int
-- ghci> :t add 5
-- add 5 :: Int -> Int
-- ghci> :t greet "World"
-- greet "World" :: String

main :: IO ()
main = do
  print (add 3 4)          -- 7
  putStrLn (greet "Haskell") -- Hello, Haskell

Type Inference via Hindley-Milner

You rarely have to write type signatures in Haskell because GHC infers them automatically using a variant of the Hindley-Milner algorithm (implemented as Algorithm W), which walks the expression, assigns fresh type variables to unknowns, and unifies them based on how each value is used. If you write double x = x + x with no signature, GHC infers the most general (principal) type Num a => a -> a, meaning it works for any numeric type, not just Int. Despite this, idiomatic Haskell style still writes explicit top-level signatures on every function, because they serve as machine-checked documentation and make compiler error messages point at the actual mistake rather than an inferred type three functions away.

🏏

Cricket analogy: A talent scout who watches a young bowler's action and deduces they're best suited to fast bowling, without the player ever declaring it, mirrors GHC inferring double's type from how + is used inside it, rather than requiring an explicit declaration up front.

Kinds: Types of Types

Just as values are classified by types, types themselves are classified by kinds, and the simplest kind, written * (or Type in modern GHC), classifies ordinary types that have values, like Int or Bool. A type constructor that needs an argument before it becomes a concrete type, like Maybe, has kind * -> *: Maybe alone is not a type you can have a value of, but Maybe Int is, because applying Maybe to one argument of kind * produces something of kind *. GHCi's :kind command (or :k for short) reveals this, and a kind mismatch -- like writing Maybe Maybe instead of Maybe (Maybe Int) -- is caught by the compiler the same way an ordinary type error is, just one level up the abstraction ladder.

🏏

Cricket analogy: A tournament format itself (like 'T20 knockout') isn't a match until you plug in two specific teams, the same way Maybe isn't a concrete type until you apply it to an argument like Int, making Maybe kind * -> * rather than kind *.

Use GHCi's :kind (or :k) to inspect kinds interactively: :k Int reports Int :: *, while :k Maybe reports Maybe :: * -> * and :k Either reports Either :: * -> * -> *, showing it needs two type arguments before it becomes a concrete type like Either String Int.

Numeric literals like 5 are polymorphic (Num a => a) until context pins down a concrete type, and if nothing else constrains it, GHC's defaulting rules silently pick Integer (or Double if fractional operations are involved) -- this can produce a working-but-not-obviously-correct type for an expression typed in isolation at the GHCi prompt, so don't assume :t 5 reflects what type 5 will have once it's actually used inside a larger program.

Haskell is statically and strongly typed: every expression's type is fixed at compile time, with no implicit coercion between types.
Type signatures use :: and read left to right; because functions are curried, Int -> Int -> Int really means a chain of one-argument functions.
GHC infers types automatically via Hindley-Milner (Algorithm W), computing the most general 'principal type' when no signature is given.
Idiomatic style still writes explicit top-level signatures for documentation and clearer compiler error messages, even though inference makes them optional.
Kinds classify types the way types classify values: * is the kind of concrete types, * -> * is the kind of type constructors like Maybe.
:t in GHCi shows a value's inferred type; :k shows a type's kind.
Unconstrained numeric literals default to Integer or Double under GHC's defaulting rules, which can surprise you when checking types in isolation.