Nim VS rust

All these organizations[1] using nim in production must disagree with you then.

[1]: https://github.com/nim-lang/Nim/wiki/Organizations-using-Nim

With function overloading and templates

You just use a `hash` function in your library code and user has to implement a version of it that accepts the Foo type.

To resolve the scope problem, Nim uses templates[1] with `dirty` pragma (makes template unhygienic), but there is also a `mixin`[2] statement for later static binding.

0 - https://github.com/nim-lang/Nim/lib/pure/collections/tables....

1 - https://github.com/nim-lang/Nim/blob/78983f1876726a49c69d656...

2 - https://nim-lang.org/docs/manual.html#generics-mixin-stateme...

Check out Nim[0] - it's strongly typed, with good type inference, clean elegant syntax, memory management is automatic (optional gc, default is ARC + small footprint cycle collector), compiles to small single binaries (Hello World is less than 100 kb), has powerful metaprogramming and lsp support.

Nim compiles to C/C++ and then to native code, so performance is on the same level as Rust/C/C++. You can also compile Nim to js/wasm and run the same code in the web.

[0] - https://nim-lang.org

Programming Language: Nim

Take a look at Nim.

You get C performance, with the readability of Python.

https://nim-lang.org/

It’s not exhaustive/definitive yet (should be for the actual release), but this might be helpful:

https://github.com/nim-lang/Nim/blob/devel/changelog.md

22. Nim - $80,000

With some notable exceptions. I'll never love the turbofish [1] for example.

[1] https://github.com/rust-lang/rust/blob/master/tests/ui/parse...

Rust

Loco is a relatively new Rust web framework which first appeared around 2021. It is strongly inspired by Ruby on Rails, and designed to bring developers productivity as various functionality on routing, middlewares, and request handling. They aim to provide a modern and intuitive development experience.

Developer: Learn programming languages like Solidity (Ethereum) or Rust (Polkadot).

Port forwarding is a common technique used to access some service behind jump host from your local machine. It is a daily bread of many administrative tasks. In this post I'll show how to create such connections on demand from within Raku or Rust code (without relying on ssh -L system command).

This is for integer log 10, but could be adapted for number of digits. It needs a wrapper for 64 bit to invoke it multiple times, but most numbers in a JSON are small, so it might even be competitive; it needs only 4 cycles with enough instruction level parallelism.

I gathered this idea from the output of a superoptimizer, it was fun to figure out how it works. For spoilers, see [1].

[1] https://github.com/rust-lang/rust/blob/master/library/core/s...

At least based on the comments on lobste.rs [0] and /r/rust, these seem to be actively worked on and/or will be solved Soon (TM):

1. Checking does not take match and return into account: I think this should be addressed by Polonius? https://rust.godbolt.org/z/8axYEov6E

2. Being async is suffering: I think this is addressed by async closures, due to be stabilized in Rust 2024/Rust 1.85: https://rust.godbolt.org/z/9MWr6Y1Kz

3. FnMut does not allow reborrowing of captures: I think this is also addressed by async closures: https://rust.godbolt.org/z/351Kv3hWM

4. Send checker is not control flow aware: There seems to be (somewhat) active work to address this? No idea if there are major roadblocks, though. https://github.com/rust-lang/rust/pull/128846

[0]: https://lobste.rs/s/4mjnvk/four_limitations_rust_s_borrow_ch...

[1]: https://old.reddit.com/r/rust/comments/1hjo0ds/four_limitati...