9

One of the interesting properties of Haskell's type system (*) is that sometimes you can tell exactly what the function does based only on its type signature (assuming there's no unsafe IO dark magic invloved).

For example, any function with the type signature a -> a must be the identity function, and any function of type (a,b) -> a is equivalent to fst. In some cases you cannot determine the function completely: there is an infinite number of different possible functions of type a -> Int, but all of them are constant - they all ignore the first parameter.

I find this property fascinating, but I suspect it only applies to "trivial" functions such as id and const. Am I correct?

Also, my reasoning here is based only on intuition - for example, in a -> a, we "know nothing" about a (as opposed to constrained functions like Num a => a -> a) so "can't do anything" with it other than to return in unchanged. Is there a formal way to deal with these kind of deductions?

* I know Haskell's type system is based on the Hindley–Milner type system, but I'm not familiar with it enough to assume anything about it

Benesh
  • 3,398
  • 1
  • 18
  • 38
  • I couldn't think of an appropriate title and I'm not content with the current one - suggestions and/or edits are welcome. Thanks! – Benesh May 24 '14 at 15:44
  • 7
    Philip Wadler's paper "Theorems for free!" deals with this topic. I don't understand it well enough to write an answer though. –  May 24 '14 at 15:46
  • @delnan Thanks! Here's a [link](http://ttic.uchicago.edu/~dreyer/course/papers/wadler.pdf) for future readers. It does seem to require a basic background in type theory. – Benesh May 24 '14 at 15:52
  • 1
    It may not be a terribly useful function, but `\x -> undefined` can be given the type signature `a -> a`. – Neil Forrester May 24 '14 at 16:01
  • 1
    @NeilForrester So can `undefined`, and indeed program transformations based on parametricity are unsound in the presence of a function like `seq`. See also *Free Theorems in the Presence of *seq*" [\[PDF\]](https://github.com/aistrate/Articles/raw/master/Haskell/Free%20Theorems%20in%20the%20Presence%20of%20seq%20(Johann%2C%20Voigtlaender).pdf) – Rein Henrichs May 24 '14 at 16:04
  • @NeilForrester - you're right. However its true type AFAIK is `a -> ⊥` – Benesh May 24 '14 at 16:04
  • 1
    @Benesh ⊥ is not a type. ⊥ is an inhabitant of all types. Its true type is `forall a. a -> a`. – Rein Henrichs May 24 '14 at 16:09

1 Answers1

10

The concept you are referring to is known as parametricity. Universal quantification over types gives parametric polymorphism and a "uniformity" property that is intuitively this notion that "we don't know anything about" a in forall a. a -> a and so "can't do anything" with it other than return it unchanged. What the uniformity property says is that a type f :: [a] -> [a] does not depend on the type of a, or, more precisely, depends uniformly on it: that anything one "does" to the [a] must be "doable" for all choices of a. Wadler uses this to show that mapping the values in the list and then permuting the list is equivalent to permuting first and mapping after.

The formal way to deal with these intuitions is given in, e.g., Philip Wadler's Theorems for Free and involves an isomorphism between types and relations (in fact the category PER of partial equivalence relations (p.e.r.'s)) which shows that this uniformity is a universal property in the category.

One interesting result of parametricity is that you can go "both ways": from a type to theorems about that type, and from a type to inhabitants of that type. Wadler's free theorems are an example of the former and Djinn, a theorem prover (inhabitants of a type are "proofs" of the type's "theorem"), is an example of the latter.

Rein Henrichs
  • 15,437
  • 1
  • 45
  • 55