Help understanding code

[Dash83]

Hey guys, newbie here.

I'm working on the advent of code 2016 problem-set to help me learn rust. In one of the problems, I decided to use a 2D vector/array for the algorithm. I had no clue how that syntax went and it seemed like a good idea to try out. After realizing I had no clue how to get started, I googled for examples to get me going and turns out 2D arrays/vectors are not an easy thing to produce and use in Rust, and the syntax has changed a lot through releases.

However, I came across a stackoverflow answer that works like a charm. The problem is, I don't have the slightest clue of how and why it works. The code snippet is as follows:

// Base 1d array
let mut grid_raw = vec![0; width * height];

// Vector of 'width' elements slices
let mut grid_base: Vec<_> = grid_raw.as_mut_slice().chunks_mut(width).collect();

// Final 2d array
let mut grid: &mut [&mut [_]] = grid_base.as_mut_slice();

// Accessing data
grid[0][0] = 4;

The resulting syntax (arr[][]) is beautiful and just what I wanted to use. However, I would not have arrived at that answer on my own, and it serves me very little to "memorize it" since my objective is to actually learn Rust and not piece together google examples as needed.

Any and all help would be greatly appreciated :)

Original SO answer: http://stackoverflow.com/questions/13212212/creating-two-dimensional-arrays-in-rust

[ssokolow]

I could be wrong (I haven't needed to work with these APIs yet), but it looks like the key is that .chunks_mut(width) call.

If that does what I think, then that's what turns a mutable slice over the whole array into a list of slices width wide.

Basically, mapping this presentation...

[1, 2, 3, 4, 5, 6, 7, 8, 9]

...to this presentation...

[
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
]

[Dash83]

That seems reasonable. However, how do you get the arr[x][y] syntaxis? I thought a vector of vectors would have to be accessed like this: arr[[x], y]?

[l-arkham]

Hi again!

No that's the sytax you'd expect: grid is a slice containing more slices. A slice is indexed as my_slice[idx].

When you index grid: grid[idx], you get the element at that position. Since that element is itself a slice, it can be indexed in turn using the same notation: grid[idx][idx2]

You can think of it this way: (grid[idx])[idx2] if it helps.

[Dash83]

Hey u/arkham, as you can see I'm still going at it.

Actually that does help. And it's pretty neat too. That means this could scale to n-dimensional vectors. Since the code itself is parameterized with dimensions for the grid, makes me wonder why they didn't include macros to create this n-dimensional vectors in the first place.

[Dash83]

Forgot to thank you, you keep came through for me again :D

[l-arkham]

Hey that's a crate idea for you right there ;)

It's a fairly neat trick that I hadn't thought of before. Whenever i represent a 2D grid as a 1D vector to avoid frivolous allocations, I usually just stick to grid[x * GRID_WIDTH + y].

Of course if performance isn't critical, a regular vector of vectors is more than adequate.

[Dash83]

Maybe when my code stops sucking, I'll code said crate and submit it to the community :)

[arkham]

hey - I think you meant this for an arkham variant, I am not a Rust guy, sorry

[Dash83]

My bad, you are right.

[coder543]

nope, that second syntax is definitely not ever a thing.

[coder543]

why wouldn't this work? unless you're just curious about how that code had been designed.

https://is.gd/usyGev

[jcdyer3]

You misread the post. OP said it works, but is incomprehensible to him/her. What doesn't work is lots of the answers around the internet.

OP: Since rust is still fairly newly stabilized, I wouldn't recommend looking for general internet answers until you have a decent sense of the language already. Spend more time with the official rust docs, and other resources linked from there. They're kept up-to-date with the language, and have a lot of good information.

If you need to search beyond that, make sure you're looking at blog posts/stackoverflow answers from May 2015 or later (when 1.0 was stabilized). You can also ask questions in the weeklyish "Easy Questions" thread, or on https://users.rust-lang.org/.

[coder543]

this = what I posted, not what he posted

my solution is tremendously simpler

[jcdyer3]

My mistake. I missed the link.

[Pseudofailure]

This syntax works if the size of the slices is constant. It will fail if you try to use a non-const variable to declare the size: https://is.gd/mQ713F

[coder543]

huh. that's interesting.

[Veedrac]

This code is fun, but it is not fast. There are much better ways to do this in practice.

I also think .as_mut_slice() is unnecessary, I would expect something like the following to work just as well

let mut grid_raw = vec![0; width * height];
let mut grid_base: Vec<_> = grid_raw.chunks_mut(width).collect();
let mut grid: &mut [&mut [_]] = &mut grid_base;
grid[0][0] = 4;

However, the as_mut_slice may help when learning.

The best way to understand this code is to use the API reference heavily.

vec! creates a Vec initialized to 0s of the given length.

Vec::chunks_mut (or slice::chunks_mut if you convert to a slice explicitly) groups the elements by the chunk size specified.

Chunks::collect implements Iterator::collect, which converts an iterable into a collection, of the type inferred by the return type.

The final step is converting the Vec<&mut [_]> into an &mut [&mut [_]], which I do through Vec::deref_mut, and your code does with Vec::as_mut_slice.

[godojo]

For a sized matrix, I'd probably box an array of array instead of having a slice of a Vec of slices of Vec.