slides

Liquid Types [1] achieve the same in existing programming languages: no bounds checks at runtime, and reject programs without an in-bounds proof. For a demo, see "Scrap your Bounds Checks with Liquid Haskell", giving a 6x speed up in high-performance parsing of UDP packets. [1]: https://news.ycombinator.com/item?id=37349276 "A Gentle Introduction to Liquid Types" [2]: https://github.com/Gabriella439/slides/blob/main/liquidhaske... "Scrap your Bounds Checks with Liquid Haskell"

> static analysis isn't going to deal with every scenario like access based on inputs. Not true. With proper abstraction, static analysis proves the absence of bugs under all relevant inputs, which gives stronger guarantees than testing at development time (which only checks for a number of inputs), and is more performant than runtime checks (without runtime overhead). An example is the use of a static type system, which eliminates a whole class of bugs under all possible values of the same type (those due to type mismatch: passing a string into a function expecting an integer), which is stronger than a test suite testing certain inputs, and does not have runtime overhead (unlike runtime checks). Going further than usual type systems, people study refining types by possible values (such as positive integers as a refinement of all integers

> this seems like a lot to go through to solve something that isn't much of an issue in the first place...but with more explicit iteration and runtime checks they are almost never a problem I see anymore. If you can afford runtime checks (if they are not much of an issue in the first place), Haskell, C++, Rust, and Julia can have runtime checks. If you want to opt-out of runtime checks, Haskell, C++, Rust, and Julia can opt-out easily, but unsafely. So, to be fair to Haskell or any of them, this is not a complication specific only to Haskell. But Haskell enables you to do more. With around 30 lines of Liquid Haskell (those lines between {-@ and @-}), you can upgrade simple runtime checks to compile time verification, see the full example [1]. You get great efficiency, safely, without unnecessary runtime checks, which is impossible in C++,

> C++ doesn't have this problem at all, bounds checks are in the std library in debug mode only. Rust and Julia make it very easy to take the bounds checks out. Haskell can do that too, with unsafeTake and unsafeDrop [1], you can opt-out of runtime bounds checks as easily as C++, Rust, and Julia. But opting-out of machine-checked guarantees is unsafe, and Haskell can do better. What's more is that Liquid Haskell can move such runtime bounds checks to compile time, made ergonomic with SMT solvers. This way, you get machine-checked guarantees (so programmers can write correct programs faster) with no runtime overhead (the programs also run faster). > Also if you are accessing a data structure out of bounds, that's a show stopping bug that shouldn't ever happen. That should be something that is prevented ahead of time, not recovered from. Ye

Liquid Types enabled a 6x speed up in high-performance parsing of UDP packets, according to "Scrap your Bounds Checks with Liquid Haskell" of Gabriella Gonzalez [1]. With Liquid Haskell, the bound checks are moved from runtime to compile time, semi-automatically handled by SMT-solvers. Static types help programmers to write correct programs faster, and the programs also run faster. As an aside, speeding up programs with static analysis (constrained dynamism) are also present in Mojo (a variant of Python) or Swift [2]. [1]: https://github.com/Gabriella439/slides/blob/main/liquidhaske... "Scrap your Bounds Checks with Liquid Haskell" [2]: https://github.com/modularml/mojo/discussions/466 "Mojo and Dynamism"

Cf. parallel automaton traversal, there's a talk on doing that in Haskell at https://www.youtube.com/watch?v=b4bb8EP_pIE&feature=youtu.be... slides: https://github.com/Gabriel439/slides/blob/master/zurihac/sli... based on a very readable paper https://www.microsoft.com/en-us/research/wp-content/uploads/...

I see, lots of work to be done. My question was mostly about the derivation idea (much like a lambda) that would be confusing for people not used to this style. Also, this popped on twitter https://github.com/Gabriel439/slides/blob/master/nix-interna...

See also an interesting typed regex implementation by Gabriel Gonzalez: https://github.com/Gabriel439/slides/blob/master/regex/regex...