Compute Manhattan distance from origin given a set of left-right-step directions
Your code looks more complicated than necessary for this task.

The first thing I noticed was the directions N, E, S, W. There is no need to explicitly name them. It is simpler to just define a direction as a 2-dimensional tuple:

struct Direction {
    dx: i32,
    dy: i32
}


That's the essence of a direction. As the next step, I remembered that rotating such a direction by 90 degrees is quite simple. It just involves swapping the coordinates and reversing one of them. To get these right, I manually checked all the combinations after writing this code:

impl Direction {
    fn left(&amp;self) -&gt; Direction { Direction { dx: self.dy, dy: -self.dx } }
    fn right(&amp;self) -&gt; Direction { Direction { dx: -self.dy, dy: self.dx } }
}


By these simple definitions, I avoided dealing with N, E, S, W at all.

When I tested the program using the example you provided, my IDE added a trailing newline to the file, as is usual for text files. Then the program crashed because it could not parse an empty string. Therefore I changed split_dir(&amp;s) into split_dir(s.trim()), and it worked.

To understand the main program, I separated it into the part that deals with input and output, and the processing part in between. To do this, I defined this function:

fn manhattan_distance(s: &amp;str) -&gt; i32 {
    ...
}


I inlined the split_dir, update_x, update_y and get_manhattan_dist functions, and in the end my code became:

use std::fs;

struct Pos {
    x: i32,
    y: i32,
    dir: Direction,
}

struct Direction {
    dx: i32,
    dy: i32,
}

impl Direction {
    fn left(&amp;self) -&gt; Direction {
        Direction {
            dx: self.dy,
            dy: -self.dx,
        }
    }

    fn right(&amp;self) -&gt; Direction {
        Direction {
            dx: -self.dy,
            dy: self.dx,
        }
    }
}

fn manhattan_distance(s: &amp;str) -&gt; i32 {
    let steps = s.trim().split(", ");

    let mut pos = Pos {
        x: 0,
        y: 0,
        dir: Direction { dx: 0, dy: -1 },
    };

    for step in steps {
        let (turn, dist) = step.split_at(1);

        // Update direction
        pos.dir = match turn {
            "L" =&gt; pos.dir.left(),
            "R" =&gt; pos.dir.right(),
            _ =&gt; panic!("invalid turn {} in step {}", turn, step),
        };

        // Update position
        let dist = dist.parse::&lt;i32&gt;().unwrap();
        pos.x += pos.dir.dx * dist;
        pos.y += pos.dir.dy * dist;
    }

    pos.x.abs() + pos.y.abs()
}

fn main() {
    let s = fs::read_to_string("2016-1.txt").expect("Failed to read file.");

    println!("{}", manhattan_distance(&amp;s));
}


What's left now are some automatic tests. The function manhattan_distance is well-prepared for that since it has no side-effects, does not need any input or output, gets its parameter as a simple string and just returns its result.

And here are some example tests. You should add some more to explore other interesting cases, like crossing the x or y axis. The current tests might also pass if you omit the calls to abs.

#[cfg(test)]
mod tests {
    use crate::manhattan_distance;

    #[test]
    fn manhattan_distance_example() {
        assert_eq!(11, manhattan_distance("R5, L2, L1, R1, R3, R3, L3, R3, R4, L2, R4, L4, R4"))
    }

    #[test]
    fn manhattan_distance_empty() {
        assert_eq!(0, manhattan_distance(" \t\n"))
    }

    #[test]
    fn manhattan_distance_simple() {
        assert_eq!(13, manhattan_distance("R8, L5"))
    }

    #[test]
    fn manhattan_distance_rectangle() {
        assert_eq!(0, manhattan_distance("R8, L5, L8, L5"))
    }
}


Your code is a good working base, it was just longer than necessary. I also changed most of the variable names to be a little more precise and easier to grasp for a casual reader of the code. For example, since the task talks about "steps", it's only natural to name the corresponding variables in the code also "steps" and "step".

Since this is my first real program in Rust as well, I don't know what the really idiomatic Rust code looks like, I hope I could improve the code nevertheless.

To check whether I made any typical beginner's mistakes, I ran cargo-clippy, and I didn't get any complaints.