In which I argue that type information should be erased from programs by the compiler both for final execution and also for reasoning (in a language with dependent types, for example, where we can reason about program execution statically).

GADTs are quite powerful.  Why go all the way to true dependent types?  And should you use the Curry-Howard isomorphism (see Chapter 3 of the podcast) or not?

This episode reviews some of the applications of GADTs we have discussed so far, and discusses an example where we want to write a function that consumes a number of inputs that is controlled by an argument to the function.  

One use case for GADTs (as a special case of dependent types) is to form a typed subset of your host language.  One creates an EDSL called Expr a, where a is a type of the language (say this language is Haskell).  Values of types Expr a are the abstract syntax trees of expressions of type a from your host language.  This is just a special case of embedding a typed language into your host language: in this case the typed language is a subset of your host language.

Using indexed types, we can restrict the form of legal values in some datatype.  A nice example is binary search trees, where we can statically enforce the binary search tree property using an indexed type bst l u, where l is a lower bound and u an upper bound on the data stored in the tree.

Basic idea of using singleton types like Nat n where n is a value from the index domain, to connect program expressions and index expressions.  The data value of type Nat n is a copy of n, but living in the syntactic category of program expressions.  This allows programs to operate on a proxy for n.  Singletons library in Haskell mentioned.

If indices to types come from a different syntactic category than programs, there are a few things you cannot do.  Some initial thoughts on how to work around these.

Indexed datatypes like vectors, where the indices come from a different syntactic category than program expressions.

For programs to make sense as proofs, they need to be terminating (cannot run forever), since otherwise you can write infinite loops that have any type.  Under Curry-Howard this means any formula is provable, which is one way to define inconsistency.  (And logics have to be consistent to be useful.)

If you have dependent types, classical reasoning, and the Curry-Howard isomorphism, you can write programs that look like they are invoking oracles for undecidable problems -- but they are not, and this is confusing.