Как передать трейт-объект в штучной упаковке по значению в Rust?

Я писал код, и у меня был трейт с методом, который принимает self по значению. Я хочу вызвать этот метод для трейт-объекта Box'd (используя Box и его значение). Это возможно? Если да, то как?

С точки зрения кода минимальный пример выглядит как следующий (неполный) код:

trait Consumable {
    fn consume(self) -> u64;
}
fn consume_box(ptr: Box<dyn Consumable>) -> u64 {
    //what can I put here?
}

Мой вопрос заключается в том, как заполнить функцию consume_box указанной сигнатурой, чтобы возвращаемое значение было тем значением, которое будет получено путем вызова consume для значения Box'd.

Я изначально написал

ptr.consume()

как тело функции, хотя я понимаю, что это не совсем правильная идея, поскольку она не передает тот факт, что я хочу, чтобы Box потреблялся, а не только его содержимое, но это единственное, о чем я мог подумать. из. Не компилируется, выдает ошибку:

невозможно переместить значение типа dyn Consumable: размер dyn Consumable не может быть определен статически

Это было несколько неожиданно для меня, поскольку я новичок в Rust, я подумал, что, возможно, аргумент self передается аналогично ссылке rvalue в C++ (это действительно то, что я хочу — в C++ я, вероятно, реализовал бы это с помощью метода с подпись virtual std::uint64_t consume() &&, позволяя std::unique_ptr очистить объект, перемещенный из, с помощью виртуального деструктора), но я думаю, что Rust действительно передает по значению, перемещая аргумент на место раньше, поэтому разумно, что он отклоняет код.

Проблема в том, что я не знаю, как добиться желаемого поведения, когда я могу потреблять трейт-объект Box'd. Я попытался добавить метод к трейту с реализацией по умолчанию, думая, что это может принести мне что-то полезное в vtable:

trait Consumable {
    fn consume(self) -> u64;
    fn consume_box(me: Box<Self>) -> u64 {
        me.consume()
    }
}

Однако это приводит к ошибке

черта Consumable не может быть превращена в объект

когда я упоминаю тип Box<dyn Consumable> - что не так уж удивительно, поскольку компилятор, выясняющий, что делать с функцией, тип аргумента которой меняется с Self, было бы чудом.

Можно ли реализовать функцию consume_box с предоставленной сигнатурой, даже изменив трейт при необходимости?

Если это полезно, точнее, это часть своего рода представления некоторых математических выражений - возможно, игрушечной моделью будут конкретные реализации, которые выглядят примерно так:

impl Consumable for u64 {
    fn consume(self) -> u64 {
        self
    }
}
struct Sum<A, B>(A, B);
impl<A: Consumable, B: Consumable> Consumable for Sum<A, B> {
    fn consume(self) -> u64 {
        self.0.consume() + self.1.consume()
    }
}
struct Product<A, B>(A, B);
impl<A: Consumable, B: Consumable> Consumable for Product<A, B> {
    fn consume(self) -> u64 {
        self.0.consume() * self.1.consume()
    }
}
fn parse(&str) -> Option<Box<dyn Consumable> > {
    //do fancy stuff
}

где, по большей части, вещи представляют собой простые старые данные (но произвольно большие их блоки, потенциально из-за дженериков), но также чтобы это было совместимо с передачей более непрозрачных дескрипторов для таких вещей - отсюда желание уметь работать с Box<dyn Consumable>. По крайней мере, на уровне языка это хорошая модель того, чем я занимаюсь - единственными ресурсами, принадлежащими этим объектам, являются части памяти (ничего общего с многопоточностью и без самореферентных махинаций) - хотя это модель не отражает тот вариант использования, который у меня есть, когда для реализации полезно потреблять объект, а не просто читать его, и при этом она не моделирует должным образом то, что мне нужен «открытый» класс возможных сегментов, а не конечный набор возможностей (из-за чего сложно сделать что-то вроде enum, которое напрямую представляет дерево) - поэтому я спрашиваю о передаче по значению, а не пытаюсь переписать его для передачи по ссылке.