该特征不能成为 object，因为方法 `merge` 引用了此参数中的 `Self` 类型 - rust

Question

I'm trying to implement an undo/redo system for my app via the undo crate. I want a globally accessible HISTORY variable to which I can push Box<dyn Action> trait objects.

use undo::{Action, History};

lazy_static::lazy_static! {
    static ref HISTORY: History<Box<dyn Action<Output = (), Error = String, Target = AppState>>> = History::new();
}

This gives error:

error[E0038]: the trait `Action` cannot be made into an object
note: for a trait to be "object safe" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
   --> C:\Users\Primary User\.cargo\registry\src\github.com-1ecc6299db9ec823\undo-0.46.0\src\lib.rs:135:8
    |
135 |     fn merge(&mut self, _: &mut Self) -> Merged {
    |        ^^^^^ the trait cannot be made into an object because method `merge` references the `Self` type in this parameter

Is there any way to work around this?

Here's the problem trait Action , from the undo library source code:

pub trait Action {
    /// The target type.
    type Target;
    /// The output type.
    type Output;
    /// The error type.
    type Error;

    /// Applies the action on the target and returns `Ok` if everything went fine,
    /// and `Err` if something went wrong.
    fn apply(&mut self, target: &mut Self::Target) -> Result<Self>;

    /// Restores the state of the target as it was before the action was applied
    /// and returns `Ok` if everything went fine, and `Err` if something went wrong.
    fn undo(&mut self, target: &mut Self::Target) -> Result<Self>;

    /// Reapplies the action on the target and return `Ok` if everything went fine,
    /// and `Err` if something went wrong.
    ///
    /// The default implementation uses the [`apply`](trait.Action.html#tymethod.apply) implementation.
    fn redo(&mut self, target: &mut Self::Target) -> Result<Self> {
        self.apply(target)
    }

    /// Used for manual merging of actions.
    fn merge(&mut self, _: &mut Self) -> Merged {
        Merged::No
    }
}

Answer 1

You seem to be attempting to create a history that can contain different types of Action , but this is not how undo is meant to be used. The type for which you implement Action is intended to represent all possible actions in the history, so if there are multiple kinds you would typically implement Action on an enum to represent this. If the reason you want to use a trait object is simply to avoid match statements in the all methods of your Action impl, I would recommend using the crate enum_dispatch to generate this boilerplate for you. However, if you have a very good reason to use a trait instead of an enum (ie you need the set of actions in your app to be extensible by other code), then the trait object approach can be made to work, though it will be more complicated, a little slower, and less readable. I have illustrated both possible solutions below:

Using enum_dispatch

enum_dispatch simply automatically implements a trait for an enum composed of types that implement that trait. In order to use it to create a type you can implement Action for, you would create your own trait AppAction that is just like undo::Action , except that the return types are fixed and the second argument of merge takes the enum type rather than Self , like so:

#[enum_dispatch(AppActionEnum)]
pub trait AppAction {
    fn apply(&mut self, target: &mut AppState) -> Result<(), String>;

    fn undo(&mut self, target: &mut AppState) -> Result<(), String>;

    fn redo(&mut self, target: &mut AppState) -> Result<(), String> {
        self.apply(target)
    }

    fn merge(&mut self, _: &mut AppActionEnum) -> Merged {
        Merged::No
    }
}

#[enum_dispatch]
pub enum AppActionEnum {
    MyAction1,
    MyAction2,
    ...
}

impl Action for AppActionEnum {
    type Target = AppState;
    type Output = ();
    type Error = String;

    fn apply(&mut self, target: &mut AppState) -> Result<(), String> {
        AppAction::apply(self, target)
    }

    fn undo(&mut self, target: &mut AppState) -> Result<(), String> {
        AppAction::undo(self, target)
    }

    fn redo(&mut self, target: &mut AppState) -> Result<(), String> {
        AppAction::redo(self, target)
    }

    fn merge(&mut self, other: &mut AppActionEnum) -> Merged {
        AppAction::merge(self, other)
    }
} 

With this solution, you can implement AppAction::merge for a particular concrete type by matching on the second argument for types that can merge with Self and using _ => Merged::No to ignore everything else.

Using a trait object and as_any

If you would still like to use dynamic dispatch, just like before you can create your own trait AppAction , but this time make the argument of merge a trait object, and implement undo::Action for boxes of that type.

pub trait AppAction {
    fn apply(&mut self, target: &mut AppState) -> Result<(), String>;

    fn undo(&mut self, target: &mut AppState) -> Result<(), String>;

    fn redo(&mut self, target: &mut AppState) -> Result<(), String> {
        self.apply(target)
    }

    fn merge(&mut self, _: &mut dyn AppAction) -> Merged {
        Merged::No
    }
}

impl Action for Box<dyn AppAction> {
    type Target = AppState;
    type Output = ();
    type Error = String;
    
    fn apply(&mut self, target: &mut AppState) -> Result<(), String> {
        self.deref_mut().apply(target);
    }

    fn undo(&mut self, target: &mut AppState) -> Result<(), String> {
        self.deref_mut().undo(target);
    }

    fn redo(&mut self, target: &mut AppState) -> Result<(), String> {
        self.deref_mut().redo(target);
    }

    fn merge(&mut self, other: &mut Box<dyn MyAction>) -> Merged {
        self.deref_mut().merge(other.deref_mut());
    }
}

However, now comes the question of how to actually implement the merge method when you don't know the concrete type of the other action. For this, you will have to use Any to attempt to downcast to each concrete type the action could be merged with. Ideally, this would be as simple as using &mut dyn MyAction + Any in merge and Box<dyn MyAction + Any> in your History , however Rust does not support compound trait objects at present. There is a somewhat involved workaround based on making Any a supertrait of your trait, but you would be better off using the crate as_any to handle this for you. Once you make as_any::AsAny a supertrait of AppAction and impl as_any::Downcast for dyn AppAction , you can write a merge implementation like so:

fn merge(&mut self, other: &mut dyn MyAction) -> Merged {
    if let Some(other) = other.downcast_mut::<MyOtherAction1>() {
         // handle actions of type MyOtherAction1
         return Merged::Yes // or Merged::Annul if appropriate
    }
    if let Some(other) = other.downcast_mut::<MyOtherAction2>() {
         // handle actions of type MyOtherAction2
         return Merged::Yes // or Merged::Annul if appropriate
    }
    // and so on for all the other types this action can merge with...
    Merged::No
}

Again, this option is by far the more confusing of the two, so only use it if you really need to.