Primitive Types: Int, Integer, Double, Char, Bool
Every value in Haskell has a type, and types are checked statically at compile time, before the program ever runs. Primitive types include Int (fixed-precision, machine-word-sized integers), Integer (arbitrary-precision integers with no overflow), Double (double-precision floating point), Char (a single Unicode character in single quotes like 'a'), and Bool (True or False). A String is not a distinct primitive but a type synonym for [Char], a list of characters, which is why string operations like length and ++ work identically on strings and on lists of any other element type.
Cricket analogy: Just as a scorecard distinguishes a 'runs' column (a number) from a 'batsman name' column (text), Haskell's static types distinguish Int from String, catching a mismatch -- like trying to add a name to a run count -- before the scorecard is even printed.
-- Primitive value examples, checkable in GHCi with :type
anInt :: Int
anInt = 42
aBigNum :: Integer
aBigNum = 123456789012345678901234567890
aDouble :: Double
aDouble = 3.14159
aChar :: Char
aChar = 'H'
aString :: String -- String is a type synonym for [Char]
aString = "Haskell"
isReady :: Bool
isReady = True
In GHCi, :type expr (or :t expr) prints the inferred type of any expression without evaluating it -- :t 'a' : "bc" reports [Char], a quick way to build intuition for how types compose.
Immutable Bindings
Values in Haskell are bound with =, not assigned with := or = as in imperative languages -- x = 5 declares that the name x *refers to* the value 5 everywhere it is in scope, and that binding can never be changed afterward within the same scope. This is what it means for Haskell values to be immutable: there is no way to write x = x + 1 and have it mean 'increment x', because that would require x to already be defined in terms of itself in an infinite, non-terminating way. Instead, you introduce a *new* binding with a new name, such as let y = x + 1, leaving the original x untouched.
Cricket analogy: A player's career batting average recorded for a specific match -- '46.5 as of the 3rd Test' -- is a permanent historical fact that never changes retroactively, just as x = 5 in Haskell can never be reassigned; a new figure requires a new record, like avgAfter4thTest.
x = x + 1 at the top level in Haskell is not an error, but it is not an increment either -- it defines x self-referentially, which produces an infinite loop (<<loop>>) the moment its value is demanded, because laziness can't rescue a definition that depends on its own fully-evaluated value.
Type Inference and Explicit Signatures
Type inference means you rarely have to write type annotations explicitly -- GHC's type checker, based on the Hindley-Milner algorithm, can look at double x = x + x and deduce that it works for any numeric type, inferring the general type double :: Num a => a -> a. Good Haskell style still writes explicit top-level type signatures for every function, not because the compiler needs them, but because they serve as precise, compiler-checked documentation: if the implementation of double ever drifts out of sync with its declared signature, GHC reports a type error immediately rather than letting the mismatch surface as a confusing bug later.
Cricket analogy: A team writing down the planned batting order on the team sheet before the toss, even though the umpires don't strictly require it, is like writing an explicit type signature -- it's compiler-checked documentation that catches a mismatch (like a wrong batsman walking out) immediately.
-- GHC infers this type even with no signature written:
double x = x + x
-- Inferred: double :: Num a => a -> a
-- Idiomatic style always writes the signature explicitly:
double :: Num a => a -> a
double x = x + x
- Every Haskell value has a type, checked statically at compile time.
- Core primitive types include Int, Integer, Double, Char, and Bool.
- String is a type synonym for [Char], so list functions work on strings for free.
- Values are bound with
=, and bindings are immutable -- a name can't be reassigned in the same scope. x = x + 1does not incrementx; it creates a self-referential, non-terminating definition.- GHC infers types automatically via Hindley-Milner, but idiomatic style still writes explicit signatures.
- Explicit type signatures act as compiler-checked documentation that catches drift between intent and implementation.
Practice what you learned
1. What is `String` in Haskell actually a synonym for?
2. What happens when you write `x = x + 1` at the top level in Haskell?
3. Which type would you choose for arbitrary-precision integer arithmetic with no overflow?
4. What algorithm underlies GHC's type inference?
5. Why do idiomatic Haskell programs write explicit type signatures even though GHC can infer them?
Was this page helpful?
You May Also Like
What Is Haskell?
An introduction to Haskell as a purely functional, statically typed, lazily evaluated language, and why those properties matter in practice.
Functions in Haskell
How to define, call, curry, and locally scope functions in Haskell, including lambdas and where/let bindings.
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.
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 programs.
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