Write You a Haskell Stephen Diehl

Γ, x : τ = (Γ\x) ∪ {x : τ}
Operations over the context are simply the usual Set operations on the underlying map.
extend :: TypeEnv -> (Var, Scheme) -> TypeEnv
extend (TypeEnv env) (x, s) = TypeEnv $ Map.insert x s env
Inference Monad
All our logic for type inference will live inside of the Infer monad. Which is a monad transformer stack
of ExcpetT + State, allowing various error reporting and statefully holding the fresh name supply.
type Infer a = ExceptT TypeError (State Unique) a
Running the logic in the monad results in either a type error or a resulting type scheme.
runInfer :: Infer (Subst, Type) -> Either TypeError Scheme
runInfer m = case evalState (runExceptT m) initUnique of
Left err -> Left err
Right res -> Right $ closeOver res
Substitution
Two operations that will perform quite a bit are querying the free variables of an expression and applying
substitutions over expressions.
fv(x) = x
fv(λx.e) = fv(e) − {x}
fv(e 1 e 2 ) = fv(e 1 ) ∪ fv(e 2 )
Likewise the same pattern applies for type variables at the type level.
ftv(α) = {α}
ftv(τ 1 → τ 2 ) = ftv(τ 1 ) ∪ ftv(τ 2 )
ftv(Int) = ∅
ftv(Bool) = ∅
ftv(∀x.t) = ftv(t) − {x}
Substitutions over expressions apply the substitution to local variables, replacing the named subexpression
if matched. In the case of name capture a fresh variable is introduced.
83