gabriella439/record-concatenation

This project is a small, hands-on companion tool for a blog post about type inference, a topic from programming language theory concerned with how a programming language can automatically figure out the type of a value, such as whether something is a number, a string, or a record, without the programmer stating it explicitly. Specifically, this project focuses on type inference for record concatenation, which means combining two records, similar to combining two small structured objects that each hold named fields, and correctly working out what type the combined result should have. Rather than just reading about the idea, this repository lets a curious reader try the algorithm themselves. It opens an interactive prompt, called a REPL, where you type in a small expression and it immediately shows you the type that its algorithm infers for that expression. The expression language it accepts is written in a Nix-like syntax, and only supports the specific set of expressions covered in the companion blog post. The README shows several example interactions. You can type simple values like numbers, strings, and booleans and see their types. You can write addition, let expressions for defining local variables, and functions, all in that Nix-like syntax. Most centrally, you can build records with named fields, look up a field's value, combine one record's fields into another using a with operation, and remove a field using a without operation, and each time the tool prints out the inferred type of the result. To run it, you can either use the Nix package manager to run it directly from GitHub with one command, or use a standard Haskell toolchain and run it with cabal. This is written in Haskell, the language commonly used for this kind of type-system and compiler research. It is a teaching tool built for a specific technical audience already interested in how type systems work, not a general purpose library.