31 |

32 | Hindley Milner Type Inference

33 | 34 |

35 | 36 |

The Hindley Milner Type Inference or Algorithm W is a type-inference algorithm that infers types in a programming language.

37 | 38 |

This repository contains a working implementation written in OCaml to demonstrate type-inference on a small functional language.

39 | 40 |

41 | Demo

42 | 43 |

44 | 45 |

46 | λ-calculus

47 | 48 |

The language that this implementation works on is a small subset called the lambda calculus. In essence, the lambda calculus allows one to express any computation purely in terms of anonymous functions and application of these functions.

49 | 50 |

> (fun x -> x * x)          (* function declaration *)
 51 | > (fun x -> x * x) 10       (* function application *)

52 | 53 |

In pure lambda calculus, numerals and booleans are also expressed in terms of functions but to make it easy, the language supports integer and boolean literals, alongwith binary operations such as addition, multiplication, boolean and etc.

54 | 55 |

56 | Types

57 | 58 |

Before we jump on to the type-inference algorithm, we need to define the types in our language. There are three primitive types that our language supports -

59 | 60 |

62 | int: An integer type for integer literals. Binary operations such as + and *, work only on integers and return an integer type.
64 | bool: Our language has boolean literals true and false, both of which have a bool type. To operate on bools && and || are provided. Lastly, two additional operators > and < work on any type, but return a bool type.
66 | T -> U: The function type where the T is the type of the input and U is the return type of the function. So for example, a square function above has a type int -> int.

68 | 69 |

70 | REPL

71 | 72 |

The project ships with an interactive Read-Eval-Print-Loop (REPL) that you can use to play with the algorithm. To build the REPL, you need OCaml installed.

73 | 74 |

If you prefer Docker, there's an image that you can use to try out the REPL. Simply run

75 | 76 |

$ docker run -w /home/opam/type-inference -it prakhar1989/type-infer /bin/bash

77 | 78 |

Compile the REPL with make and if all goes well, you should be good to go.

79 | 80 |

$ ./repl
 81 | 
 82 | Welcome to the REPL.
 83 | Type in expressions and let Hindley-Milner Type Inference run its magic.
 84 | 
 85 | Out of ideas? Try out a simple lambda expression: (fun x -> x + 10)
 86 | 
 87 | > 10 + 20 > 40
 88 | bool
 89 | > (fun x -> (x && true) || false)
 90 | (bool -> bool)
 91 | > (fun x -> x + 10) 20
 92 | int
 93 | > (fun f -> f 3)
 94 | ((int -> 'a) -> 'a)
 95 | >  (fun f -> (fun g -> (fun x -> f (g x))))
 96 | (('a -> 'b) -> (('c -> 'a) -> ('c -> 'b)))
 97 |

98 | 99 |

100 | Tests

101 | 102 |

To run the tests, you need Alcotest package installed. Install it by running opam install alcotest.

103 | 104 |

$ make test
105 |

106 | 107 |

108 | Thanks

109 | 110 |

Huge thanks to these lecture notes for providing an understandable breakdown of the algorithm.

111 |

Type-inference