How to call a method that consumes self on a boxed trait object?

Question

I have the following sketch of an implementation:

trait Listener {
    fn some_action(&mut self);
    fn commit(self);
}

struct FooListener {}

impl Listener for FooListener {
    fn some_action(&mut self) {
        println!("{:?}", "Action!!");
    }
    
    fn commit(self) {
        println!("{:?}", "Commit");
    }
}

struct Transaction {
    listeners: Vec<Box<dyn Listener>>,
}

impl Transaction {
    fn commit(self) {
        // How would I consume the listeners and call commit() on each of them?
    }
}

fn listener() {
    let transaction = Transaction {
        listeners: vec![Box::new(FooListener {})],
    };
    transaction.commit();
}

I can have Transaction s with listeners on them that will call the listener when something happens on that transaction. Since Listener is a trait, I store a Vec<Box<Listener>> .

I'm having a hard time implementing commit for Transaction . Somehow I have to consume the boxes by calling commit on each of the stored Listener s, but I can't move stuff out of a box as far as I know.

How would I consume my listeners on commit?

Answer 1

Applying commit to the boxed object is not allowed because the trait object doesn't know its size (and it's not constant at compile-time). Since you plan to use listeners as boxed objects, what you can do is acknowledge that commit will be invoked on the box and change its signature accordingly:

trait Listener {
    fn some_action(&mut self);
    fn commit(self: Box<Self>);
}

struct FooListener {}

impl Listener for FooListener {
    fn some_action(&mut self) {
        println!("{:?}", "Action!!");
    }

    fn commit(self: Box<Self>) {
        println!("{:?}", "Commit");
    }
}

This enables Transaction to compile as you wrote it, because inside the implementation of FooListener the size of Self is well known and it is perfectly possible to move the object out of the box and consume both.

The price of this solution is that Listener::commit now requires a Box . If that is not acceptable, you could declare both commit(self) and commit_boxed(self: Box<Self>) in the trait, requiring all types to implement both, possibly using private functions or macros to avoid code duplication. This is not very elegant, but it would satisfy both the boxed and unboxed use case without loss of performance.

Answer 2

With the unsized_locals feature enabled, the natural code works as-is :

// 1.37.0-nightly 2019-06-03 6ffb8f53ee1cb0903f9d
#![feature(unsized_locals)]

// ...

impl Transaction {
    fn commit(self) {
        for l in self.listeners {
            l.commit()
        }
    }
}

Answer 3

The accepted answer shows how to proceed when you have the agency to modify the Listener trait. If you don't have that option, ie if you control the Transaction type, but not Listener and its implementations, read on.

You can create another trait that can be used in a trait object because it doesn't require consuming self :

trait XListener {
    fn some_action(&mut self);
    fn commit(&mut self);
}

To use this trait everywhere Listener is usable, we provide a blanket implementation of the trait. Normally such an implementation would implement XListener for all types T: Listener . But that doesn't work here because Listener::commit() requires consuming self , and XListener::commit() only receives a reference, so it can't call Listener::commit() . To work around that, we implement XListener for Option<T> . This allows us to use Option::take() to get an owned value to pass to `Listener::commit():

impl<T: Listener> XListener for Option<T> {
    fn some_action(&mut self) {
        self.as_mut().unwrap().some_action();
    }

    fn commit(&mut self) {
        self.take().unwrap().commit();
    }
}

XListener::commit() takes value out of the Option , calls Listener::commit() on the value, and leaves the option as None . This compiles because the value is not "unsized" in the blanket implementation where the size of each individual T is known. The downside is that we are allowed to call XListener::commit() multiple times on the same option, with all attempts but the first panicking at run time.

The remaining work is to modify Transaction to make use of this:

struct Transaction {
    listeners: Vec<Box<dyn XListener>>,
}

impl Transaction {
    fn commit(self) {
        for mut listener in self.listeners {
            listener.commit();
        }
    }
}

fn listener() {
    let transaction = Transaction {
        listeners: vec![Box::new(Some(FooListener {}))],
    };
    transaction.commit();
}

Playground