Myujth

This is the data structure I am using to represent a single linked list:

type Link = Option<Box<Node>>;

pub struct Node 
 elem: i32,
 next: Link,

I would like to implement a method to remove the Nth node from the end of the list:

// Original list
A -> B -> C -> D -> None

// remove 1 from the end of the original list
A -> B -> C -> None

// Remove 2 from the end of the original list
A -> B -> D -> None

I am fighting with the borrow checker all the time:

fn remove_nth_node_from_end(list: &mut Link, n: usize) 
 if list.is_none() 
 return;
 
 let mut i = 0;
 let mut fast = list;
 while let Some(ref mut node) = fast 
 if i == n 
 break;
 
 i += 1;
 fast = &mut node.next;
 

 // issues start here, since I need to mutably borrow
 // the list (and it has already been moved above for fast)
 // but without moving I have troubles implementing the above loop
 let mut slow = &mut list;
 // iterate over the list using slow and fast
 // when fast is None
 // slow.next = slow.next.next

error[E0596]: cannot borrow immutable argument `list` as mutable
 --> src/lib.rs:25:25
 |
25 | let mut slow = &mut list;
 | ^^^^ cannot borrow mutably
help: consider removing the `&mut`, as it is an immutable binding to a mutable reference
 |
25 | let mut slow = list;
 | ^^^^

error[E0382]: use of moved value: `list`
 --> src/lib.rs:25:25
 |
13 | let mut fast = list;
 | -------- value moved here
...
25 | let mut slow = &mut list;
 | ^^^^ value used here after move
 |
 = note: move occurs because `list` has type `&mut std::option::Option<std::boxed::Box<Node>>`, which does not implement the `Copy` trait

How can I implement the remaining part of the method?

Please note my methods does not take self as argument and the list argument needs to be moved twice at least with the current implementation.

This is how you could write the method without using recursion.

fn remove_nth(list: &mut Link, n: usize) l: &Link

Unfortunately, I didn't manage to make the borrow checker happy by using the more efficient runner pattern.