Introduction to Dependent Types

Thomas Dietert

September 26th, 2019
Haskell Hackers Meetup

whoami

Bay area newbie
Haskell Enthusiast
Software Engineer
Avid Reader
Aspiring polymath
Tennis Player
Rock Climber

Hiring Haskell Engineers
Compilers + Custom Hardware + ML
Email r at groq dot com if interested

The λ-calculus

Calculus - a particular method or system of calculation or reasoning
"Invented" by Alonso Church in the 1930s
expresses computation based on function abstraction and application using variable binding and substitution

The λ-calculus

Syntax

\begin{aligned} v & \Coloneqq \lambda x \rightarrow e \\ e & \Coloneqq v \mid e \ e \mid x \end{aligned}

Free Variables

Variables in an expression that are not bound by any lambda abstraction

\begin{aligned} \text{FV}(x) & = x \\ \text{FV}(e \ e') & = \text{FV}(e) \cup \text{FV}(e') \\ \text{FV}(\lambda x \rightarrow e) & = \text{FV}(e) \setminus \lbrace x \rbrace \end{aligned}

Bound Variables

Variables in the body of an expression that are bound (captured) by a variable binding in an outer lambda abstraction

\begin{aligned} \text{BV}(x) & = \emptyset \\ \text{BV}(e \ e') & = \text{BV}(e) \cup \text{BV}(e') \\ \text{BV}(\lambda x \rightarrow e) & = \lbrace x \rbrace \cup \text{BV}(e) \end{aligned}

α-equivalence

Terms are structurally equivalent, but not nominally equivalent
α-conversion replaces all bound variables with fresh variable names

\( \lambda x \rightarrow \lambda y \rightarrow x \quad =_{\alpha} \quad \lambda a \rightarrow \lambda b \rightarrow a \)

\( \lambda x \rightarrow \lambda y \rightarrow x \quad \not =_{\alpha} \quad \lambda a \rightarrow \lambda b \rightarrow b \)

Dynamic Semantics

(evaluation)

* call by value

(Capture Avoiding) Substitution

Happens during \(\beta\)-reduction
Allows for argument substitution without altering the semantics of the expression
Uses \(\alpha\)-conversion to avoid free and bound variable naming conflicts

Static Semantics

(type-checking)

???

The Simply Typed

λ-calculus

(STLC)

Extension of the untyped λ-calculus
Expressions can have their type annotated
λ terms must have their types checked
More static guarantees but still strongly normalizing

STLC Abstract Syntax

STLC

Dynamic Semantics

(evaluation)

Type Contexts (\(\Gamma\))

STLC

Static Semantics

(type-checking)

STLC Implementation

(syntax + typechecker)

https://github.com/tdietert/lambda-pi/blob/master/src/BiSTLC.hs

The

Polymorphic λ-calculus

(System-F)

Formalizes the notion of parametric polymorphism
Function types can now be parameterized by type variables
Type inference becomes undecideable
Basis upon which GHC's core IR is founded*

"Types indexed by Types"

\( \tau \Coloneqq \dots \mid \Lambda \alpha \rightarrow \tau \mid \alpha \)

The

Parametric, Polymorphic

λ-calculus

(System-\(F_\omega\))

Like System-F, but with > 1 kind of types
Base types can now be parameterized by other types (called "type operators")
Actual basis upon which GHC's core IR is founded

The

Dependently Typed

λ-calculus

(\( \lambda_{\Pi} \), \( \lambda P \))

Types can depend on values
Some computation happens at compile time
Also formalizes the notion of parametric polymorphism... (types are values)*