Rust implement modulo arithmetic for direction (up / left / down / right)

Question

I'm teaching Rust, and so I go to adventofcode (parallel with boring reading rustbook).

And in one task I need to track direction, during moving and rotations such as "Straight / Left / Back / Right" && "Straight + Right + Right == Back".

*) suppose for a second, that "absolute direction" and "relative direction" are represented as single type.

So I trying to solve this issue using enums. And during this I need two things:

1. Contiguosly place discriminants from "integer 0" to last
2. Get discriminants count (or "enum size") either straightforward or using some tricks.

But I can't do the second thing.

enum Dir {
    Up,
    Left,
    Down,
    Right,
    //Last = (Dir::Right) as isize,
} 
impl Dir {
    fn add_dir(&self, add_dir: &Self) -> Self {       
        let last = Dir::from_int((self.to_int() + add_dir.to_int) / (Dir::Last.to_int() + 1));
        return last;
    }
}

So the questoin is: how can I implement domain-specific, i.e. type-safe, modulo arithmetic in rust (with no performance requirements if it's important).

======= Updated: The local and narrow question is - how to get constant "4" (modulo for modular arithmetic), but don't type it as literal (the last thing, typing constants as literal - is a very errorfull way when programmer starts to change his code).

Answer 1

Get discriminants count (or "enum size") either straightforward or using some tricks.

my problem is - how to properly get constant 4 from enum. Butnot write it as literal in code (this is very errorfull way when programmer will change his code).

You can reliably get the number of enum variants using the strum crate's EnumCount, which adds the Dir::COUNT static usize value to your enum:

/*
[dependencies]
strum = { version = "0.24", features = ["derive"] }
*/
use strum::EnumCount;

#[derive(EnumCount)]
enum Dir {
    Up,
    Left,
    Down,
    Right,
} 

fn main() {
    assert_eq!(Dir::COUNT, 4);
}

Rustexplorer

---

Contiguously place discriminants from "integer 0" to last

Rust does so for variants implicitly. See @Sven Marnach's answer.

Answer 2

Enums without any data on its variants can be easily converted into integers. The first variant will have discriminant 0, the second 1 and so on. The conversion can be performed with, e.g., dir as u8, where dir has type Dir.

The conversion in the other direction is less straight-forward. Since not all integers are valid discriminants, the conversion is fallible. There are crates helping to implement this conversion automatically (e.g. num_enum, but for this simple case I recommend implementing the conversion yourself. You can use the built-in TryFrom trait for the fallible conversion, and the built-in Add trait for the addition:

use anyhow::{Error, Result};
use std::ops::Add;

#[derive(Copy, Clone, Debug)]
enum Dir {
    Up,
    Left,
    Down,
    Right,
}

impl TryFrom<u8> for Dir {
    type Error = Error;

    fn try_from(value: u8) -> Result<Self> {
        let dir = match value {
            0 => Dir::Up,
            1 => Dir::Left,
            2 => Dir::Down,
            3 => Dir::Right,
            _ => return Err(Error::msg("direction out of bounds")),
        };
        return Ok(dir);
    }
}

impl Add<Dir> for Dir {
    type Output = Dir;

    fn add(self, other: Dir) -> Self {
        ((self as u8 + other as u8) % 4).try_into().unwrap()
    }
}

fn main() {
    dbg!(Dir::Left + Dir::Down);
}

Playground

I've used anyhow::Error as the conversion error, but of course you can use whatever custom error type you prefer. The implementation of addition uses % 4 to make sure the result isn't out of range, so using unwrap() on the result of the conversion is fine.

The implementation of the conversion is a bit verbose, but for only four variants I wouldn't mind it, since it's obvious on a glance what it does. For more complex cases (or even for this one) you may prefer one of the crates that automate this.