Bend, don't Break. Modern Techniques for Flexibility in Strongly Typed Functional Programming

Strong static guarantees of runtime behaviour, and fighting the compiler until it and you come to a shared mutual understanding. If these two things usually go hand in hand for you, then this talk is for you!

This talk is at its core, a compendium of the techniques that functional programmers employ to keep programming pleasant without losing any of the safety and robustness. It’s not really about advanced type systems (we will never mention dependent types, promise), but it is about bending the type system to your will, and that, predictably, requires gaining some understanding of a few slightly advanced type systems topics. While we will provide a brief overview of everything, familiarity with Haskell, PureScript, OCaml, Rust, Lean, or some other statically typed programming language is recommended.

Some things we will look at and how to apply them to real world code -
- Establishing invariants, convincing the compiler to relax the inbuilt checks because you took care of them already
- Producing, consuming, and traversing dynamic values of unknown structure, sealing structures so the compiler knows safety is preserved
- Building extensible data structures and extensible algorithms. Performing type safe dynamic dispatch and dependency injection

1. Flexibility and type safety are not a trade-off. You will learn how to get both in modern functional languages.

2. Advanced types are a tool to improve your development experience, not to engage in type astronomy. You will learn how advanced types make it easier to read and write code.

3. Learn how to guide the compiler effectively so that it shifts your relationship with the compiler from a battle into a cooperative partnership.