game-of-life | write coordinates from a file using RLE algorithm | Game Engine library

Here, I answer your question in comments. The board of the Game of Life should be an infinite, two-dimensional orthogonal grid of square cells. Infinity can be 'approximated' by connecting the edges of the board. To do it the mod function should be defined as a modulo function.

As Drew said, you cannot use hooks in your useEffect (all hooks must be called on every render)

The problem in your code is you initialize grid with clearGrid() on the first render. but numRows used in that function still undefined.

you can use useRef and useEffect to initalize your grid

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.

When match gives Ok(Config::WorldDef { ... dead_char: Some(&d), alive_char: Some(&a), } the two last references are slices from Strings owned by args_vec (accessed via args_slice).

When the function exits, args_vec does not exist any more, thus the references in the result would be dangling if Rust didn't complain.

I suggest that you store Strings instead of &str in the dead_char and alive_char member; this way, the result could take ownership of these to strings from args_vec. By the way, if you do that, I'm not certain args_slice is useful; I think you can just consume args_vec in the match statement because it won't be used afterwards.

In the definition of new-timer, you're trying to get the grd field of cv.

And although cv is an instance of the class new-canvas%, its type does not include that field. You need to create a new Class type for new-canvas%. By convention, it should be a capitalized version like New-Canvas%.

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

It turns out that this is not expected behavior; instead it is a bug with wasm-pack.

The issue can be resolved for now by adding the following to the project's cargo.toml:

Your problem is how you update the cells. The rules are:

• a live cell dies if it doesn't have 2 or 3 live neighboure;
• a dead cell comes alive if it has 3 live neighbours.

That means that you must consider the current state of the cell to determine its next state, but your code doesn't do that. (It also means that it is enough to count the live neighbours.)

With the rules above, your update code should look like this: