• Add Nim implementation.

Steps to try it

Assuming Linux, assuming you are in the repo root folder.

• curl https://nim-lang.org/choosenim/init.sh -sSf | sh
• Add Nim to PATH, using ~/.bashrc, instructions provided by install process.
• nimble install nimpy
• nim c -d:danger --out:list_nim.so list_nim.nim
• python main.py

I've done a lot with numba and found it to be a tremendous advantage. I suggest you try to tweak your numba example a bit more. I'd do it myself but I have very little free time right now. I could look into it later if you really give up.

If there's really something that makes your example code impractical, then I must say that based on my experience, this isn't a representative example and misrepresents numba's value.

Finally, I'd suggest submitting the problem to the numba team; I would expect them to either fix it or give a solid reason why they don't view it as a problem for the vast majority of use cases.

This is a more idiomatic implementation of cy_list, which avoids several performance pitfalls. On my machine, this results in about a 2x improvement in performance. This PR is incompatible with #2; maybe they should be separate tests.

I've managed to make a numba implementation.

Before the benchmark, it appends and pops a dummy numba list. Then your functions work as expected. Got idea from the documentation https://numba.pydata.org/numba-doc/dev/reference/pysupported.html#typed-list

I've also added two an after warm up benchmark for Numba and Julia, as you need to call the functions first for the JIT to compile the functions. This can take half a second or so.

I ran your benchmarks on my laptop (bar Rust as it was blowing up my RAM XD)

For 10e3 I got:

10000.000000171856
Numba needed time: 0.5606226921081543
10000.000000171856
Numba needed time (after compile): 0.04860401153564453
9999.999999992067
Numba multi-threading needed time: 0.5958309173583984
9999.999999992067
Numba multi-threading needed time (after compile): 0.028712034225463867
9999.99999999983
Rust multithreading before needed time: 0.06744837760925293
10000.000000171856
Julia needed time: 0.7957050800323486
10000.000000171856
Julia needed time (after warm up): 0.05081033706665039
10000.000000000002
Julia multi-threading needed time: 0.5844004154205322
10000.000000000002
Julia multi-threading needed time (after warm up): 0.024353504180908203
9999.99999999983
Rust multithreading after needed time: 0.058985233306884766
10000.000000171856
Python needed time: 0.13445138931274414
10000.000000171856
C++ Cython-pure no annotations needed time: 0.027180910110473633
10000.000000171856
C Cython-pure no annotations needed time: 0.02731800079345703
10000.000000171856
C++ Cython-pure pure-annotations needed time: 0.03733682632446289
10000.000000171856
C Cython-pure pure-annotations needed time: 0.033501625061035156
10000.000000171856
C Cython needed time: 0.03557443618774414
10000.000000171856
C++ Cython-pure needed time: 0.03178834915161133
10000.000000171856
C Cython-pure needed time: 0.03287529945373535

For 10e4 I got

1000000.0007792843
Numba needed time: 5.641289472579956
1000000.0007792843
Numba needed time (after compile): 4.76781153678894
999999.9997857037
Numba multi-threading needed time: 3.4215545654296875
999999.9997857037
Numba multi-threading needed time (after compile): 2.8651604652404785
1.0000000007792843e6
Julia needed time: 3.0554113388061523
1.0000000007792843e6
Julia needed time (after warm up): 1.569504737854004
1.0e6
Julia multi-threading needed time: 1.6075024604797363
1.0e6
Julia multi-threading needed time (after warm up): 1.503305196762085
1000000.0007792843
Python needed time: 15.476759195327759
1000000.0007792843
C++ Cython-pure no annotations needed time: 3.638566017150879
1000000.0007792843
C Cython-pure no annotations needed time: 3.711937189102173
1000000.0007792843
C++ Cython-pure pure-annotations needed time: 4.374421834945679
1000000.0007792843
C Cython-pure pure-annotations needed time: 4.278993129730225
1000000.0007792843
C Cython needed time: 4.220995903015137
1000000.0007792843
C++ Cython-pure needed time: 3.951723098754883
1000000.0007792843
C Cython-pure needed time: 4.254110097885132

So from this, I got:

1. Julia
2. Numba
3. Cython (heard this implementation isn't optimized) (Rust kills my computer)

This adds a closer-to-real life version of the rust version. By passing a numpy array instead of a PyList we avoid 3 copies of the python list. Looking at the generate C code for some of the other versions, they don't have to copy the python list, they are just passing references around.

I couldn't get the julia stuff to work locally for me, so I haven't been able to compare this against the other methods.

Last thing I'd add is that its probably not apples to apples since numpy requires the full allocation up front. Although I think it would improve the benchmark to have all the other implementations work off pre-allocated memory instead, since that's how this would be done IRL.