mypyc VS beartype

That would be interesting! You might already be aware. But there's mypyc[0], which is an AOT compiler for Python code with type hints (that, IIRC, mypy uses to compile itself into a native extension).

Wanted to give you a head-start on the lit-review for your students I guess :)

[0] https://github.com/mypyc/mypyc

https://github.com/mypyc/mypyc

> Mypyc compiles Python modules to C extensions. It uses standard Python type hints to generate fast code. Mypyc uses mypy to perform type checking and type inference.

> Mypyc can compile anything from one module to an entire codebase. The mypy project has been using mypyc to compile mypy since 2019, giving it a 4x performance boost over regular Python.

I have not experience a 4x boost, rather between 1.5x and 2x. I guess it depends on the code.

Funny how emergence works with tools. Give a language too few tools but viral circumstances - the ecosystem diverges (Lisps, Javascript). Give it too long an iteration time but killer guarantees, you end up with committees. Python not falling into either of these traps should be understood as nothing short of magic in emergence.

I only recently discovered that python's reference typechecker, mypy, has a small side project for typed python to emit C [1], written entirely in python. Nowadays with python's rich specializer ecosystem (LLVM, CUDA, and just generally vectorized math), the value of writing a small program in anything else diminishes quickly.

Imagine reading the C++wg release notes in the same mood that you would the python release notes.

[1] https://github.com/mypyc/mypyc

> Note that the mypyc issue tracker lives in this repository! Please don't file mypyc issues in the mypy issue tracker.

See https://github.com/mypyc/mypyc/blob/master/show_me_the_code....

And mypyc https://github.com/mypyc/mypyc

More recent approaches include mypyc which is (on the tin) quite close to what you describe, and taichi that lives in between.

Have you encountered mypyc?

https://github.com/mypyc/mypyc

> Mypyc compiles Python modules to C extensions. It uses standard Python type hints to generate fast code. Mypyc uses mypy to perform type checking and type inference.

Regarding the large execution time mentioned in your article, I discovered (mypyc)[https://github.com/mypyc/mypyc] on this subreddit in a post from the black formatter team https://www.reddit.com/r/Python/comments/v2009i/im_that_person_who_got_black_compiled_with_mypyc/?utm_medium=android_app&utm_source=share

https://github.com/beartype/beartype

I wish more people started using Beartype, it makes Python bearable

I saw this on /r/Python the other day...

As other folks have commented, type hints are now a big deal. For static typing the best checker is pyright. For runtime checking there is typeguard and beartype. These can be integrated with array libraries through jaxtyping. (Which also works for PyTorch/numpy/etc., despite the name.)

Maybe you're looking for https://github.com/beartype/beartype for runtime type enforcement; it's only at function calls, though, but probably a decent solution for codebases that are not completely typed for MyPy or pyright.

It is though, if you add a type checker to your pipeline and use it without any escape hatches such as `Any` or `type: ignore`, you are essentially making the promise that your code is statically typed. But I say it is a matter of perspective because in my opinion runtime type checking should be avoided if we can get away with statically typed code, but there are type checkers that perform runtime type checking via annotations such as [Beartype](https://github.com/beartype/beartype) (with some trickery like assuming homogenous data structures as to not have to check every element of every structure). Anyway the definition of "type safe" is not 100% even in compiled languages.

There is the beartype project.

Personally I find working around mypy's quirks to be more effort than it's worth, so to offer another option: typeguard or beartype can be used to perform run-time type checking.