Type conversion and casting - rust

Question

I am beginner in rust. I have simple script but I have to use too much type casting.
Point of script: search clusters of neighbour cels with the same value in matrix (using flood fill algo with queue https://en.wikipedia.org/wiki/Flood_fill).
This is full code:
fn find_clusters(playground: [[u8; SIZE]; SIZE]) -> Vec<Cluster> {
let directions_cluster: [[i8; 2]; 4] = [[0, 1], [0, -1], [1, 0], [-1, 0]];
let mut clusters: Vec<Cluster> = Vec::new();
let mut queue: Vec<[usize; 2]> = Vec::new();
let mut marked_cells: [[u8; SIZE]; SIZE] = [[0; SIZE]; SIZE];
for i in 0..SIZE {
for j in 0..SIZE {
if marked_cells[i][j] == 1 { continue; }
let code = playground[i][j];
let mut cluster = Cluster::new();
queue.push([i, j]);
marked_cells[i][j] = 1;
while !queue.is_empty() {
let coords = queue.pop().unwrap();
cluster.coords.push(coords);
for direction in &directions_cluster {
let check_i = coords[0] as i8 + direction[0];
if check_i < 0 || check_i as usize >= SIZE {continue;}
let check_j = coords[1] as i8 + direction[1];
if check_j < 0 || check_j as usize >= SIZE {continue;}
let ni = check_i as usize;
let nj = check_j as usize;
if playground[ni][nj] == code && marked_cells[ni][nj] == 0 {
queue.push([ni, nj]);
marked_cells[ni][nj] = 1;
}
}
}
if cluster.coords.len() >= 5 {
cluster.code = code;
clusters.push(cluster);
}
};
};
return clusters;
}
But I don't like this part:
for direction in &directions_cluster {
let check_i = coords[0] as i8 + direction[0];
if check_i < 0 || check_i as usize >= SIZE {continue;}
let check_j = coords[1] as i8 + direction[1];
if check_j < 0 || check_j as usize >= SIZE {continue;}
let ni = check_i as usize;
let nj = check_j as usize;
if playground[ni][nj] == code && marked_cells[ni][nj] == 0 {
queue.push([ni, nj]);
marked_cells[ni][nj] = 1;
}
}
I even had to define additional variables (check_i, check_j) to not use casting for ni/nj each time later.
What the best way of type casting in may case?

Answer 1

You can use the TryInto trait from the standard library to abstract away from the overflow checking. This is how I would implement it:
use std::convert::TryInto;
type Pos = [usize; 2];
fn add_to_coords(coords: Pos, offset: [i8; 2]) -> Option<Pos> {
let ni: usize = (coords[0] as i8 + direction[0]).try_into().ok()?;
let nj: usize = (coords[1] as i8 + direction[1]).try_into().ok()?;
[ni, nj]
}
// ...
for [ni, nj] in directions.flat_map(|dir| add_to_coords(coords, dir)) {
// ...
}
// ...
The call to flat_map filters out all the return values that were None, in case you were wondering where the continue went.