I think at this point most people involved in Coq development, at least, agree that a majority of the stuff in it should be in a proof assistant (maybe should have been from the beginning). I strongly recommend you try to prove as much as you possibly can; it'll save you later.
Apparently lots of the trouble comes in the form of optimizations to the type checking algorithm.
I think it might make sense in the short term to try to keep the implementation as close to the syntax-directed algorithm described in the appendix of the book. For the short term our programs should be small, and speed should be less of a concern for us.
As a precaution, we should also try to ensure certain aspects of our implementation avoid known trouble areas, for example using implicit substitutions, and building up a tangle of mutually recusive definitions/modules/types (although that can be hard to avoid at times in dependent type systems).
In parallel we could:
Define the declarative semantics (non-syntax-directed) and prove soundness theorems about that
Ensure that the syntax directed semantics match the properties of the declarative semantics
Using something fancy like Iris to design an imperative, optimized version of the type checker
Ensure that the optimized version matches the properties of the declarative semantics as well
Then we could start carefully porting over the optimizations to the Rust implementation.
Had a nice chat with @pythonesque on Twitter:
Apparently lots of the trouble comes in the form of optimizations to the type checking algorithm.
I think it might make sense in the short term to try to keep the implementation as close to the syntax-directed algorithm described in the appendix of the book. For the short term our programs should be small, and speed should be less of a concern for us.
As a precaution, we should also try to ensure certain aspects of our implementation avoid known trouble areas, for example using implicit substitutions, and building up a tangle of mutually recusive definitions/modules/types (although that can be hard to avoid at times in dependent type systems).
In parallel we could:
Then we could start carefully porting over the optimizations to the Rust implementation.
Resources
Papers
Projects