Как реализовать черту, которой я не владею, для типа, которым я не владею?

Я хотел реализовать Shl черта для Vecкод ниже. Это сделало бы такие вещи, как vec << 4 возможно, что было бы хорошим сахаром для vec.push(4),

use std::ops::Shl;

impl<T> Shl<T> for Vec<T> {
    type Output = Vec<T>;

    fn shl(&self, elem: &T) -> Vec<T> {
        self.push(*elem);
        *self
    }
}

fn main() {
    let v = vec![1, 2, 3];
    v << 4;
}

Компиляция завершается со следующей ошибкой:

не может обеспечить реализацию расширения, в которой в этом ящике не определены ни признак, ни тип [E0117]

или же

параметр типа T должен использоваться в качестве параметра типа для некоторого локального типа (например, MyStruct<T>); только параметры, определенные в текущем ящике, могут быть реализованы для параметра типа [E0210]

Насколько я понимаю, мне придется исправлять stdlib, а точнее collections::vec обрешетка. Есть ли другой способ изменить этот код для успешной компиляции?

Источник

3 ответа

Решение

Хотя вы не можете сделать это точно, обычный обходной путь заключается в том, чтобы просто обернуть нужный вам тип в свой собственный тип и реализовать в нем черту.

use somecrate::FooType;
use somecrate::BarTrait;

struct MyType(FooType);

impl BarTrait for MyType {
    fn bar(&self) {
        // use `self.0` here
    }
}
Источник

Это сделало бы такие вещи, как vec << 4 возможно, что было бы хорошим сахаром для vec.push(4),

Хотя это может быть сделано, обычно плохая идея реализовать оператор с неожиданной семантикой.

Вот пример того, как это можно сделать:

use std::ops::Shl;

struct BadVec<T>(Vec<T>);

impl<T> Shl<T> for BadVec<T> {
    type Output = BadVec<T>;

    fn shl(mut self, elem: T) -> Self::Output {
        self.0.push(elem);
        self
    }
}

fn main() {
    let mut v = BadVec(vec![1, 2, 3]);
    v = v << 4;
    assert_eq!(vec![1, 2, 3, 4], v.0)
}

Если вы реализуете Deref(DerefMut):

use std::ops::{Deref, DerefMut};

impl<T> Deref for BadVec<T> {
    type Target = Vec<T>;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl<T> DerefMut for BadVec<T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

ты можешь позвонить Vec методы:

fn main() {
    let mut v = BadVec(vec![1, 2, 3]);
    v = v << 4;
    v.truncate(2);
    assert_eq!(2, v.len());
}

Посмотрите на newtype_derive Ящик, он может генерировать некоторый шаблонный код для вас.

Источник

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

Однако есть некоторые обходные пути, наиболее распространенным из которых является шаблон newtype . В паттерне newtype мы оборачиваем внешний тип в локальную структуру и через эту обертку реализуем нужные методы.

      // External struct
use foo::Foo;

// Create a new type.
pub struct Bar(Foo);

// Provide your own implementations
impl Bar {
    pub fn new() -> Self {
        //..
    }
}

Для получения дополнительной информации ознакомьтесь с этими ссылками:

Источник
Другие вопросы по тегам