Использование компилятора Rust, чтобы не забыть вызвать метод

Вы можете использовать фантомные типы для переноса дополнительной информации, которую можно использовать для проверки типов без каких-либо затрат времени выполнения. Ограничение состоит в том, что move_left_by и move_right_by должны возвращать новый принадлежащий объект, потому что им нужно изменить тип, но часто это не будет проблемой.

Кроме того, компилятор будет жаловаться, если вы на самом деле не используете типы в своей структуре, поэтому вам нужно добавить поля, которые их используют. Rust std предоставляет тип PhantomData нулевого размера для удобства этой цели.

Ваше ограничение может быть закодировано следующим образом:

use std::marker::PhantomData;

pub struct GoneLeft;
pub struct GoneRight;
pub type Completed = (GoneLeft, GoneRight);

pub struct Thing<S = ((), ())> {
    pub position: i32,
    phantom: PhantomData<S>,
}


// private to control how Thing can be constructed
fn new_thing<S>(position: i32) -> Thing<S> {
    Thing {
        position: position,
        phantom: PhantomData,
    }
}

impl Thing {
    pub fn new() -> Thing {
        new_thing(0)
    }
}

impl<L, R> Thing<(L, R)> {
    pub fn move_left_by(self, by: i32) -> Thing<(GoneLeft, R)> {
        new_thing(self.position - by)
    }

    pub fn move_right_by(self, by: i32) -> Thing<(L, GoneRight)> {
        new_thing(self.position + by)
    }
}

Вы можете использовать его следующим образом:

// This function can only be called if both move_right_by and move_left_by
// have been called on Thing already
fn do_something(thing: &Thing<Completed>) {
    println!("It's gone both ways: {:?}", thing.position);
}

fn main() {
    let thing = Thing::new()
          .move_right_by(4)
          .move_left_by(1);
    do_something(&thing);
}

И если вы пропустите один из необходимых методов,

fn main(){
    let thing = Thing::new()
          .move_right_by(3);
    do_something(&thing);
}

то вы получите ошибку компиляции:

error[E0308]: mismatched types
  --> <anon>:49:18
   |
49 |     do_something(&thing);
   |                  ^^^^^^ expected struct `GoneLeft`, found ()
   |
   = note: expected type `&Thing<GoneLeft, GoneRight>`
   = note:    found type `&Thing<(), GoneRight>`

Я не думаю, что #[must_use] действительно то, что вам нужно в этом случае. Вот два разных подхода к решению вашей проблемы. Первый — просто заключить то, что вам нужно сделать, в замыкание и абстрагироваться от прямых вызовов:

#[derive(Debug)]
pub struct Foo {
    x: isize,
    y: isize,
}

impl Foo {
    pub fn new(x: isize, y: isize) -> Foo {
        Foo { x: x, y: y }
    }

    fn move_left_by(&mut self, steps: isize) {
        self.x -= steps;
    }

    fn move_right_by(&mut self, steps: isize) {
        self.x += steps;
    }

    pub fn do_while_right<F>(&mut self, steps: isize, f: F)
        where F: FnOnce(&mut Self)
    {
        self.move_right_by(steps);
        f(self);
        self.move_left_by(steps);
    }
}

fn main() {
    let mut x = Foo::new(0, 0);
    println!("{:?}", x);
    x.do_while_right(10, |foo| {
        println!("{:?}", foo);
    });
    println!("{:?}", x);
}

Второй подход заключается в создании типа оболочки, который вызывает функцию при удалении (аналогично тому, как Mutex::lock создает MutexGuard, который разблокирует Mutex при удалении):

#[derive(Debug)]
pub struct Foo {
    x: isize,
    y: isize,
}

impl Foo {
    fn new(x: isize, y: isize) -> Foo {
        Foo { x: x, y: y }
    }

    fn move_left_by(&mut self, steps: isize) {
        self.x -= steps;
    }

    fn move_right_by(&mut self, steps: isize) {
        self.x += steps;
    }

    pub fn returning_move_right(&mut self, x: isize) -> MovedFoo {
        self.move_right_by(x);
        MovedFoo {
            inner: self,
            move_x: x,
            move_y: 0,
        }
    }
}

#[derive(Debug)]
pub struct MovedFoo<'a> {
    inner: &'a mut Foo,
    move_x: isize,
    move_y: isize,
}

impl<'a> Drop for MovedFoo<'a> {
    fn drop(&mut self) {
        self.inner.move_left_by(self.move_x);
    }
}

fn main() {
    let mut x = Foo::new(0, 0);
    println!("{:?}", x);
    {
        let wrapped = x.returning_move_right(5);
        println!("{:?}", wrapped);
    }
    println!("{:?}", x);
}

Я просмотрел только начальное описание и, вероятно, пропустил детали в разговоре, но один из способов принудительного выполнения действий — это использовать исходный объект (правильно) и заменить его тем, который заставляет вас двигаться осталось на такое же количество, прежде чем вы сможете сделать все, что хотели, чтобы закончить задачу.

Новый тип может запрещать/требовать выполнения различных вызовов перед переходом в состояние завершения. Например (не проверено):

struct CanGoRight { .. }
impl CanGoRight {
    fn move_right_by(self, steps: usize) -> MustGoLeft {
        // Note: self is consumed and only `MustGoLeft` methods are allowed
        MustGoLeft{steps: steps}
    }
}
struct MustGoLeft {
    steps: usize;
}
impl MustGoLeft {
    fn move_left_by(self, steps: usize) -> Result<CanGoRight, MustGoLeft> {
        // Totally making this up as I go here...
        // If you haven't moved left at least the same amount of steps,
        // you must move a bit further to the left; otherwise you must
        // switch back to `CanGoRight` again
        if steps < self.steps {
            Err(MustGoLeft{ steps: self.steps - steps })
        } else {
            Ok(CanGoRight{ steps: steps - self.steps })
        }
    }
    fn open_box(self) -> MustGoLeftCanCloseBox {..}
}

let foo = foo.move_right_by(10); // can't move right anymore

В этот момент foo больше не может двигаться вправо, поскольку это не разрешено MustGoLeft, но он может двигаться влево или открывать коробку. Если он перемещается влево достаточно далеко, он снова возвращается в состояние CanGoRight. Но если он открывает коробку, то применяются совершенно новые правила. В любом случае вам придется иметь дело с обеими возможностями.

Вероятно, между состояниями будет некоторое дублирование, но его должно быть достаточно легко реорганизовать. Добавление пользовательской черты может помочь.

В конце концов, это звучит так, как будто вы делаете своего рода конечную машину. Возможно, https://hoverbear.org/2016/10/12/rust-state-machine-pattern/ будет полезен.