Write You a Haskell Stephen Diehl

Types
e word “type” is quite often overload in the common programming lexicon. Other languages often
refer to runtime tags present in the dynamics of the languages as “types”. Some examples:
# Python
>>> type(1)
# Javascript
> typeof(1)
’number’
# Ruby
irb(main):001:0> 1.class
=> Fixnum
# Julia
julia> typeof(1)
Int64
# Clojure
user=> (type 1)
java.lang.Long
While this is a perfectly acceptable alternative definition, we are not going to go that route and instead
restrict ourselves purely to the discussion of static types, in other words types which are known before
runtime. Under this set of definitions many so-called dynamically typed languages often only have a
single static type. For instance in Python all static types are subsumed by the PyObject and it is only
at runtime that the tag PyTypeObject *ob_type is discriminated on to give rise to the Python notion
of “types”. Again, this is not the kind of type we will discuss. e trade-offs that these languages make
is that they often have trivial static semantics while the dynamics for the language are often exceedingly
complicated. Languages like Haskell and OCaml are the opposite point in this design space.
Types will usually be written as τ and can consist of many different constructions to the point where the
type language may become as rich as the value level language. For now let’s only consider three simple
types, two ground types (Nat and Bool) and an arrow type.
τ ::= Bool
Nat
τ → τ
e arrow type will be the type of function expressions, the left argument being the input type and the
output type on the right. e arrow type will by convention associate to the right.
τ 1 → τ 2 → τ 3 → τ 4 = τ 1 → (τ 2 → (τ 3 → τ 4 ))
56