Values and Types in Haskell

Analogy categoryAnalogies

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.

haskell

-- 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.

haskell

-- 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 + 1 does not increment x; 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.