Gradualizer

I'm hoping that https://github.com/josefs/Gradualizer and its Elixir counterpart get us closer to what "I" want. I find dialyzer often inscrutable compared to something like OCaml's or Haskell's type errors. I do still use it and typespecs, because it's better than no checking.

There's an effort currently being led by Facebook to create a gradual type system for Erlang call Gradualizer, which should also make its way over to Elixir. https://github.com/josefs/Gradualizer https://github.com/OvermindDL1/gradualixir

I'm going to shill Gradualizer[1] in here as well. 1. I think you have to see typing as helpful information. Like: -spec add(integer(), integer()) -> integer(). add(A, B) -> A + B. Technically, nothing prevents add from accepting number() or float(). It's too much specification. 2. I was surprised how much there actually is but also disappointed that a lot of errors were in until OTP 23. Gradualizer also overrides some definitions [2] 3. Haven't encountered a problem with this yet with gradualizer, would need to test. [1] https://github.com/josefs/Gradualizer [2] https://github.com/josefs/Gradualizer/blob/master/priv/prelu...

I replied to your post on twitter but I highly recommend Gradualizer[1]. Discovered it last year and started using it. The refinement portion handles unions and guards very well. It's not perfect but I'm integrating it in our codebase with some interesting successes. I'm hoping more people use it on their codebase and can find any bugs they have with it so it can be improved further. [1] https://github.com/josefs/Gradualizer

We're working on a gradual type system for Erlang which also works quite okay for Elixir: https://github.com/josefs/Gradualizer/.

That critique is a bit unspecific but I tend to agree. I have heard good a stuff about "gradulizer" though. It uses a gradual type system instead of dialyzers success typing. https://github.com/josefs/Gradualizer

https://github.com/josefs/Gradualizer already introduced above by Zalastax is one project which shows how to do it. It implements the gradual typing model, which merges static typing a'la ML/Haskell, with dynamic typing of Erlang. Other real-world examples of gradually typed languages are Facebook's Hack and TypeScript. Erlang already has a dual nature: - the sequential part, which strives to be a pure and mostly side-effect free functional language - the concurrent part, i.e. send, receive, process preemption, message delivery semantics, etc, which is inherently stateful due to interactions between stateful processes Gradual typing fits this model well, because it provides soundness to the sequential part of the language, while leaves the message passing parts which _no one knows how to_ type dynamically typed. BTW, I've spent a while to

We're adressing the lack of static typing with the Gradualizer project. It's not ready for prime time yet but I find it very promising. https://github.com/josefs/Gradualizer