rustwasm.github.io | Rust and WebAssembly website! 🦀 + 🕸 | Binary Executable Format library

You declare that your function will not return anything by saying

According to async_trait documentation, futures returned by async trait methods must by default be Send:

Async fns get transformed into methods that return Pin> and delegate to a private async freestanding function.

Your async fn produced a non-Send future. So the difference between your original code and the one that uses async_trait was that the original code didn't require a Send future, it was okay with non-Send ones, whereas async_trait by default expects Send futures.

To fix the issue, you need to tell async_trait not to require Send using #[async_trait(?Send)] on the trait and the impl block. In other words, replace #[async_trait] with #[async_trait(?Send)] in both the trait declaration and the implementation, and your code should compile. (Playground.)

Yes, this is possible.

WebAssembly stores objects within linear memory, a contiguous array of bytes that the module can read and write to. The host environment (typically JavaScript within the web browser) can also read and write to linear memory, allowing it to access the objects that the WebAssembly modules stores there.

There are two challenges here:

1. How do you find where your WebAssembly module has stored an object?
2. How is the object encoded?

You need to ensure that you can read and write these objects from both the WebAssembly module and the JavaScript host.

I'd pick a known memory location, and a known serialisation format and use that to read/write from both sides.

Absolutely none for u8 -> u16 which appears to be the gist of your question.

It is important that it is macro-pessimization, and you mentioning it in your question won't stop me from repeating the common answers that such questions get. You want sensible choice? Use usize for container sizes, as simple as that. There's absolutely no reason to ever limit the size artificially because there's nothing saved, if anything, there's a lot of things being lost.

1. Your code is unreadable, you even said so yourself.
2. Your code theoretically may introduce overhead on CPU, for the first time width is read, it is irrelevant, but it may happen, because CPU register size is usize, not u8 or u16, and it may or may not have to bitshift that byte to properly write it into the register, would've been so much easier for it to just read usize which is its natural register size and already properly aligned in memory.
3. "The grid cannot ever be larger than 250 x 250" Oh yeah? What stops me from inputting 251u8? You will have to write code that validates that anyway if you wanted to enforce that.
4. Now, why does it stop me from inputting 257usize, 1456usize... Nusize?
5. Your time is spent on bikeshedding instead of things that matter. I imagine our goal is usually to get things done in least amount of time possible, not maximum.

General advice: do not optimize container wrappers, optimize the data inside them, that's the sensible choice in any project no matter the scale.

Besides, what kind of "optimization" is it to limit the maximum size of a Grid? You may not want a Grid bigger than 250x250, but someone else might, and now your code is unusable for no real reason. Someone else might be you, going back to your project 5 months down the line, and cursing your past self while you have to refactor the entire thing just to copy paste it into another project where you want 2500 x 2500 grid for something completely unrelated.

Lets briefly focus on Grid versus Vec for a bit. How many Grids do you plan to have? I imagine only one, or at most, a dozen. But how many Cell's will there be? Thousands.

Think of what purpose there is of saving few bytes on Grid, versus few bytes on Cell, the generalization can almost universally boil down to O(1) vs O(n) of bytes saved when it comes to data structures like this.

When it comes to heavy data processing, you may end up having hundreds of Vec holding potentially hundreds of millions of elements. You should focus on the millions here. That's one of the many reason why Rust Vec itself is just, arbitrarily, 3 usizes. And I'm not aware of any projects that were worried about the fact that Vec stores its length and capacity as usize.

Above all else, remember: Premature pessimization is root of all evil.

This might be not the most helpful answer, but the answer is you currently can't - there is an open issue on wasm-bindgen repo tracking future support for debugging but it's not yet supported: https://github.com/rustwasm/wasm-bindgen/issues/2389

Note that even when it will be, you'll need to use browser DevTools not CodeLLDB for WebAssembly debugging, since you need a JavaScript-capable environment.

I was able to get it working by loading my application in the following way.

My webpack entry config looks like this:

This construction:

ManuallyDrop does not stop the inner value from being destroyed. It only stops drop from being called. Consider a Vec:

I had a similar error when I updated the version of copy-webpack-plugin from the one specified in the tutorial files due to a security alert. The format of the config parameters changed at the same time, so I had to change them to match.

The tutorial had "copy-webpack-plugin": "^5.0.3" and I upgraded to "copy-webpack-plugin": "^6.0.3", and in webpack.config.js I had to change