News for hackers. Stuff that matters.
Re:Why asynchronous Rust doesn't work by danieldk on Saturday November 13, 2021 @05:18AM (#29208800)
Maybe it’s only my take, but from what I understand, the author wants to easily create closures with mutable references and call them from anywhere, asynchronously?

I think you are misunderstanding the author's point. I think that they'd probably agree that the (lack of) ergonomics of closures are a necessary result of the safeguards that Rust provides.

They point is more that, given that closures have somewhat frustrating ergonomics, it was probably a bad choice to base Rust's primary concurrency system on closures.

Disclaimer: this is not my opinion, just paraphrasing what I believe the author's point is. I found the post a bit strange, it seems to end rather abruptly. It doesn't seem to address the main question it seems to raise: what does this mean for async Rust and why is this bad?

Re:Why asynchronous Rust doesn't work by pornel on Saturday November 13, 2021 @08:57AM (#29209724)
Rust has stopped depending on closures for async when it moved from experimental futures library to built-in async/await. Rust now easily supports mutable and temporary references in async blocks and across await points.

Rust still doesn't support use-after-free, so you can't reference a temporary object and use it in another thread that will outlive it :)

In TFA the second do_work_and_then() example doesn't compile, because it has a UAF vulnerability that borrow checker has detected and prevented.

Re:Why asynchronous Rust doesn't work by ipodopt on Saturday November 13, 2021 @12:42PM (#29211596)
You can't do that using anything here?

https://doc.rust-lang.org/std/mem/index.html

Genuine question, I don't mess around with memory typically.

Re:Why asynchronous Rust doesn't work by pornel on Sunday November 14, 2021 @03:47PM (#29220500)
mem::forget() is not crashy like free(). It merely prevents destructors from being run (e.g. you could do the same by storing the value in a global variable). It's a safe method, subject to usual safety checks.

You can use an `unsafe {}` block to call literally libc::free(), or dereference a random raw C pointer, or do something else crashy. However, when talking about Rust's safety rules it's usually assumed we're not talking about code bypassing these rules on purpose.

Re:Why asynchronous Rust doesn't work by eximius on Saturday November 13, 2021 @01:58PM (#29212280)
forget takes owned values. So you wouldn't have a handle to them to use after.