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'.
-- 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 -> Intreally 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 likeMaybe. :tin GHCi shows a value's inferred type;:kshows a type's kind.- Unconstrained numeric literals default to
IntegerorDoubleunder GHC's defaulting rules, which can surprise you when checking types in isolation.
Practice what you learned
1. What does it mean for Haskell to be a statically typed language?
2. Given `add :: Int -> Int -> Int`, what is the type of `add 5`?
3. What type does GHC infer for `double x = x + x` with no explicit signature?
4. What is the kind of `Maybe`?
5. Why do idiomatic Haskell programs still write explicit top-level type signatures even though GHC can infer them?
Was this page helpful?
You May Also Like
Type Classes Explained
How Haskell's type classes define shared interfaces like Eq, Ord, and Show, and how instances and constraints let ad-hoc polymorphism work safely.
Algebraic Data Types
How Haskell builds custom types from sum types and product types using data declarations, pattern matching, records, and recursion.
Type Inference in Haskell
How GHC deduces the most general type of an expression without explicit annotations, using unification, and where the Monomorphism Restriction and ambiguous types require help.
Maybe and Either
How Haskell uses the Maybe and Either types to represent optional values and recoverable errors explicitly, without null or exceptions.
Related Reading
Related Study Notes in Programming
Browse all study notesApache Spark Study Notes
Programming · 30 topics
ProgrammingApache Flink Study Notes
Programming · 30 topics
ProgrammingHadoop Study Notes
Programming · 30 topics
ProgrammingSnowflake Study Notes
Programming · 30 topics
ProgrammingApache Airflow Study Notes
Programming · 30 topics
Programmingdbt (Data Build Tool) Study Notes
Programming · 30 topics