Interesting trick, but there are usually easier ways to do typechecks during macro expansion in more specific cases

useful in macro expansions / codegen
playground
similar trick ICEd on 1.59: Rust issue

Yeah, I know, I am guilty af 😂

A new blog post from Bob Nystrom talks about sum types and making them look nice in a procedural language, while preserving memory safety.

Though they are not entirely type-safe, I agree with him that it's a good fit for the language that targets simplicity. Maybe Go should have also done something like that, it would definitely look better than simulating variants with interfaces like it's usually done there

Getting closer to ML ready state. Though in any case it won't be possible to iterate/prototype in Rust as fast as you can in Python. Which I guess is one of the reasons why ML is not present enough in Rust yet.

Candle - Torch Replacement in Rust

https://github.com/huggingface/candle

#ML #DL

Out of context but still good.

For the ones not familiar with Rust: `panic` is a way of handling an error by aborting the program.

Name squatting is a huge problem on crates.io Now also malicious intent was detected in some of the crates with popular names like postgress - https://blog.phylum.io/rust-malware-staged-on-crates-io/

Recommendations on whether to commit lockfiles for Rust libraries changed - https://blog.rust-lang.org/2023/08/29/committing-lockfiles.html

Now it's basically "it depends" instead of a strict "no".

So time for a bit of offline socializing. If anybody will be in Moscow on 7th of September - join us at a Rust meetup. I'll give a talk there on Async and Runtimes in Rust.

Actually a cool idea

Porting a function from Go to Rust. Is it like minus 10 lines of code?😁

Finally async fn and return impl Trait are being stabilized!

Now it will be possible to write something like this:

trait Foo {
async fn foo();

fn bar() -> impl Bar;
}

Why Static Typing Came Back

TL;DR

- Static Typing was a pain to use in 1990s and you still got type errors at runtime

- At that time the Web came to the scene and with it the need to ship and iterate faster

- The Internet speed was a lot slower back then, and so the obvious lack of runtime speed of dynamic languages didn't matter

- But everything changed in 2010s. The compilers and type checkers became a lot faster and friendlier. The statically typed languages became less verbose and "ceremonial".

- And now we are in an age of statically typed languages with even more of them in active development.

As far as I remember you could previously install the rust compiler package via apt but obviously it was a fixed version and it caused some pain. Now it's much better

It seems like OCaml will be the next (actually used) language to get a borrow checker - https://blog.janestreet.com/oxidizing-ocaml-ownership/