Как вернуть связанный тип из признака, связанного с признаком более высокого ранга?

11

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

Мне нужно использовать замыкание, которое возвращает этот связанный тип.

У меня есть следующий код для этого:

#![allow(unreachable_code)]

use std::marker::PhantomData;

trait Endpoint: for<'a> EndpointBody<'a> {}
trait EndpointBody<'a> {
    type Out: 'a;
    fn serialize(body: &Self::Out) -> Vec<u8>;
    fn deserialize(raw_body: &'a [u8]) -> Self::Out;
}

// /////////////////////////////////////////////////////////

/// Trait object compatible handler
trait Handler {
    fn execute(&self, raw_body: &[u8]) -> Vec<u8>;
}

/// Wraps a function for an endpoint, convertint it to a Handler
struct FnHandler<EP, F>
where
    EP: Endpoint,
    F: 'static + for<'a> Fn(&'a [u8]) -> <EP as EndpointBody<'a>>::Out,
{
    func: F,
    _ph: PhantomData<EP>,
}
impl<EP, F> FnHandler<EP, F>
where
    EP: Endpoint,
    F: 'static + for<'a> Fn(&'a [u8]) -> <EP as EndpointBody<'a>>::Out,
{
    pub fn new(func: F) -> Self {
        Self {
            func,
            _ph: PhantomData,
        }
    }
}
impl<EP, F> Handler for FnHandler<EP, F>
where
    EP: Endpoint,
    F: 'static + for<'a> Fn(&'a [u8]) -> <EP as EndpointBody<'a>>::Out,
{
    fn execute(&self, in_raw_body: &[u8]) -> Vec<u8> {
        let body = (self.func)(in_raw_body);
        let serialized_body = unimplemented!();
        return serialized_body;
    }
}

// /////////////////////////////////////////////////////////

/// Collection of handlers
struct Handlers(Vec<Box<dyn Handler>>);
impl Handlers {
    pub fn new() -> Self {
        Self(vec![])
    }

    pub fn handle<EP: 'static, F>(&mut self, func: F)
    where
        EP: Endpoint,
        F: 'static + for<'a> Fn(&'a [u8]) -> <EP as EndpointBody<'a>>::Out,
    {
        self.0.push(Box::new(FnHandler::<EP, F>::new(func)));
    }
}

// /////////////////////////////////////////////////////////

struct MyEndpoint;
struct MyEndpointBody<'a> {
    pub string: &'a str,
}
impl Endpoint for MyEndpoint {}
impl<'a> EndpointBody<'a> for MyEndpoint {
    type Out = MyEndpointBody<'a>;

    fn serialize(body: &Self::Out) -> Vec<u8> {
        unimplemented!()
    }
    fn deserialize(raw_body: &'a [u8]) -> Self::Out {
        unimplemented!()
    }
}

// /////////////////////////////////////////////////////////

fn main() {
    let mut handlers = Handlers::new();
    handlers.handle::<MyEndpoint, _>(|_body| MyEndpointBody {
        string: "test string",
    });

    handlers.0[1].execute(&[]);
}

Я думаю, что это должно работать, но когда я проверяю это, я получаю ошибку типа:

error[E0271]: type mismatch resolving `for<'a> <[closure@src/main.rs:92:38: 94:6] as std::ops::FnOnce<(&'a [u8],)>>::Output == <MyEndpoint as EndpointBody<'a>>::Out`
  --> src/main.rs:92:14
   |
92 |     handlers.handle::<MyEndpoint, _>(|_body| MyEndpointBody {
   |              ^^^^^^ expected struct `MyEndpointBody`, found associated type
   |
   = note:       expected struct `MyEndpointBody<'_>`
           found associated type `<MyEndpoint as EndpointBody<'_>>::Out`
   = note: consider constraining the associated type `<MyEndpoint as EndpointBody<'_>>::Out` to `MyEndpointBody<'_>`
   = note: for more information, visit https://doc.rust-lang.org/book/ch19-03-advanced-traits.html

Это сбивает с толку, потому что MyEndpoint::Outэто MyEndpointBody, который я возвращаю из закрытия, но Rust не думает, что они одного типа. Я предполагаю, что это потому, что Rust выбирает несовместимые анонимные времена жизни для MyEndpointBodyтипа, но я не знаю, как это исправить.

Как я могу заставить этот код работать так, чтобы я мог использовать замыкание с типом, связанным с HRTB?

rust traits higher-rank-types Полковник тридцать два
источник

Ответы:

4

Закрытие, возвращающее возвращаемый тип в новый тип, устраняет проблему:

#![allow(unreachable_code)]

use std::marker::PhantomData;

trait Endpoint: for<'a> EndpointBody<'a> {}
trait EndpointBody<'a> {
    type Out: 'a;
    fn serialize(body: &Self::Out) -> Vec<u8>;
    fn deserialize(raw_body: &'a [u8]) -> Self::Out;
}

struct EPOut<'a, EP: Endpoint>(<EP as EndpointBody<'a>>::Out);

// /////////////////////////////////////////////////////////

/// Trait object compatible handler
trait Handler {
    fn execute(&self, raw_body: &[u8]) -> Vec<u8>;
}

/// Wraps a function for an endpoint, convertint it to a Handler
struct FnHandler<EP, F>
where
    EP: Endpoint,
    F: 'static + for<'a> Fn(&'a [u8]) -> EPOut<'a, EP>,
{
    func: F,
    _ph: PhantomData<EP>,
}
impl<EP, F> FnHandler<EP, F>
where
    EP: Endpoint,
    F: 'static + for<'a> Fn(&'a [u8]) -> EPOut<'a, EP>,
{
    pub fn new(func: F) -> Self {
        Self {
            func,
            _ph: PhantomData,
        }
    }
}
impl<EP, F> Handler for FnHandler<EP, F>
where
    EP: Endpoint,
    F: 'static + for<'a> Fn(&'a [u8]) -> EPOut<'a, EP>,
{
    fn execute(&self, in_raw_body: &[u8]) -> Vec<u8> {
        let body = (self.func)(in_raw_body);
        let serialized_body = unimplemented!();
        return serialized_body;
    }
}

// /////////////////////////////////////////////////////////

/// Collection of handlers
struct Handlers(Vec<Box<dyn Handler>>);
impl Handlers {
    pub fn new() -> Self {
        Self(vec![])
    }

    pub fn handle<EP: 'static, F>(&mut self, func: F)
    where
        EP: Endpoint,
        F: 'static + for<'a> Fn(&'a [u8]) -> EPOut<'a, EP>,
    {
        self.0.push(Box::new(FnHandler::<EP, F>::new(func)));
    }
}

// /////////////////////////////////////////////////////////

struct MyEndpoint;
struct MyEndpointBody<'a> {
    pub string: &'a str,
}
impl Endpoint for MyEndpoint {}
impl<'a> EndpointBody<'a> for MyEndpoint {
    type Out = MyEndpointBody<'a>;

    fn serialize(body: &Self::Out) -> Vec<u8> {
        unimplemented!()
    }
    fn deserialize(raw_body: &'a [u8]) -> Self::Out {
        unimplemented!()
    }
}

// /////////////////////////////////////////////////////////

fn main() {
    let mut handlers = Handlers::new();
    handlers.handle::<MyEndpoint, _>(|_body| EPOut(MyEndpointBody {
        string: "test string",
    }));

    handlers.0[1].execute(&[]);
}

Я испытываю желание сказать, что это ошибка компилятора Rust, учитывая, что newtype должен быть примерно таким же, как и связанный тип. Также, кажется, есть некоторые ICE, связанные с использованием связанных типов HRTB: https://github.com/rust-lang/rust/issues/62529

Полковник тридцать два
источник
0

Не могли бы вы проверить , что один

trait Endpoint: for<'a> DeserializeBody<'a> {}
trait DeserializeBody<'a> {
    type Out: 'a;
    fn deserialize(raw_body: &'a [u8]) -> Self::Out;
}

fn store_ep<'a, EP, F>(func: F)
where
    EP: Endpoint,
    F: 'static + Fn(&'a [u8]) -> <EP as DeserializeBody<'a>>::Out,
{
    let _ = Box::new(func);
    unimplemented!();
}

// /////////////////////////////////////////////////////////

struct MyEndpoint;
struct MyEndpointBody<'a> {
    pub string: &'a str,
}
impl Endpoint for MyEndpoint {}
impl<'a> DeserializeBody<'a> for MyEndpoint {
    type Out = MyEndpointBody<'a>;
    fn deserialize(raw_body: &'a [u8]) -> Self::Out {
        unimplemented!();
    }
}

// /////////////////////////////////////////////////////////

fn main() {
    store_ep::<MyEndpoint, _>(|raw_body| MyEndpointBody { string: "test" });
}
MAXV
источник
Это не может быть обобщенным решением, так Fnкак параметр должен иметь произвольное время жизни. Но здесь это время жизни становится зависимым и делает невозможным использование этого вида, пожалуйста, проверьте: play.rust-lang.org/…
Ömer Erden
К сожалению, хотя это работает с простым примером, оно не работает с кодом, который у меня есть для моего проекта. Я обновлю свой пример, чтобы лучше проиллюстрировать, что я делаю.
полковник тридцать два
0

Определить DeserializeBodyкак:

trait DeserializeBody {
    type Out;
    fn deserialize(raw_body: &[u8]) -> Self::Out;
}

Outявляется объявлением универсального типа. Не объявляйте время жизни здесь, это будет явно на сайте определения.

На этом этапе больше нет необходимости в Признаке Высшего Ранга для Endpoint:

trait Endpoint: DeserializeBody {}

trait DeserializeBody {
    type Out;
    fn deserialize(raw_body: &[u8]) -> Self::Out;
}

На сайте определения требования времени жизни должны быть выражены для связанного типа Out. Если DeserializeBodyне является более универсальным, то MyEndpointдолжно быть:

impl<'a> DeserializeBody for MyEndpoint<'a> {
    type Out = MyEndpointBody<'a>;

    ...

И чтобы реализовать такое требование, давайте прибегнем к фантомному типу, который требует жизни 'a.

Собираем все кусочки вместе:

use core::marker::PhantomData;

trait Endpoint: DeserializeBody {}

trait DeserializeBody {
    type Out;
    fn deserialize(raw_body: &[u8]) -> Self::Out;
}

fn store_ep<EP, F>(func: F)
where
    EP: Endpoint,
    F: 'static + for<'a> Fn(&'a [u8]) -> <EP as DeserializeBody>::Out,
{
    let _ = Box::new(func);
    unimplemented!();
}

struct MyEndpoint<'a> {
    phantom: PhantomData<&'a ()>
}

struct MyEndpointBody<'a> {
    pub string: &'a str,
}

impl<'a> Endpoint for MyEndpoint<'a> {}

impl<'a> DeserializeBody for MyEndpoint<'a> {
    type Out = MyEndpointBody<'a>;

    fn deserialize(raw_body: &[u8]) -> Self::Out {
        unimplemented!();
    }
}

fn main() {
    store_ep::<MyEndpoint, _>(|raw_body| MyEndpointBody { string: "test" });
}
attdona
источник
Нет. MyEndpointBodyне может заимствовать raw_bodyв этом случае, потому что 'aпереживает raw_bodyанонимную жизнь. Вся точка HRTB, чтобы дать raw_bodyна 'aвсю жизнь.
полковник тридцать два
А ну понятно. С HRTB вы пытаетесь десериализовать на любой срок жизни, а затем заимствовать из входных данных. Часть, которая кажется ограничением компилятора, похоже, что ваше решение - это serde :: DeserializeOwned, и команда serde не может позаимствовать какие-либо данные из десериализатора.
Аттдона
Должен ли этот обходной путь работать для вас? Vec<u8>должно быть где-то выделено: перемещается вниз в deserialize.
Аттдона
Ну, да, я мог бы просто сдаться и удалить время жизни, но тогда у меня не может быть десериализации без копий, и это побеждает суть вопроса.
полковник тридцать два
0

Я думаю, что проблема заключается в том, что вы запрашиваете, чтобы ваши обработчики могли обрабатывать все возможные времена жизни с этим ограничением HK - что компилятор не может доказать, что оно проверено, поэтому не может сделать эквивалентность MyEndpointBody <=> MyEndpoint::Out.

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

#![allow(unreachable_code)]

use std::marker::PhantomData;

trait Endpoint: for<'a> EndpointBody<'a> {}
trait EndpointBody<'a> {
    type Out: 'a;
    fn serialize(body: &Self::Out) -> Vec<u8>;
    fn deserialize(raw_body: &'a [u8]) -> Self::Out;
}
/// Trait object compatible handler
trait Handler<'a> {
    fn execute(&self, raw_body: &'a [u8]) -> Vec<u8>;
}

/// Wraps a function for an endpoint, convertint it to a Handler
struct FnHandler<EP, F>
where
    EP: Endpoint,
    F: 'static,
{
    func: F,
    _ph: PhantomData<EP>,
}
impl<EP, F> FnHandler<EP, F>
where
    EP: Endpoint,
    F: 'static,
{
    pub fn new(func: F) -> Self {
        Self {
            func,
            _ph: PhantomData,
        }
    }
}
impl<'a, EP, F> Handler<'a> for FnHandler<EP, F>
where
    EP: Endpoint,
    F: 'static + Fn(&'a [u8]) -> <EP as EndpointBody<'a>>::Out,
{
    fn execute(&self, in_raw_body: &'a [u8]) -> Vec<u8> {
        let body = (self.func)(in_raw_body);
        let serialized_body = unimplemented!();
        return serialized_body;
    }
}

// /////////////////////////////////////////////////////////

/// Collection of handlers
struct Handlers<'a>(Vec<Box<dyn Handler<'a>>>);
impl<'a> Handlers<'a> {
    pub fn new() -> Self {
        Self(vec![])
    }

    pub fn handle<EP: 'static, F>(&mut self, func: F)
    where
        EP: Endpoint,
        F: 'static + Fn(&'a [u8]) -> <EP as EndpointBody<'a>>::Out,
    {
        self.0.push(Box::new(FnHandler::<EP, F>::new(func)));
    }
}

// /////////////////////////////////////////////////////////

struct MyEndpoint;
struct MyEndpointBody<'a> {
    pub string: &'a str,
}
impl Endpoint for MyEndpoint {}
impl<'a> EndpointBody<'a> for MyEndpoint {
    type Out = MyEndpointBody<'a>;

    fn serialize(body: &Self::Out) -> Vec<u8> {
        unimplemented!()
    }
    fn deserialize(raw_body: &'a [u8]) -> Self::Out {
        unimplemented!()
    }
}

// /////////////////////////////////////////////////////////

fn main() {
    let mut handlers = Handlers::new();
    handlers.handle::<MyEndpoint, _>(|_body| MyEndpointBody {
        string: "test string",
    });

    handlers.0[1].execute(&[]);
}
вал
источник
Я не понимаю ваш первый абзац. Вы можете сделать, например, for<'a> Fn(&'a [u8]) -> &'a [u8]просто отлично, и компилятор примет это. Проблема возникает только тогда, когда возвращается связанный тип.
полковник тридцать два
Я имел в виду, что ваш FnHandlerпринимает функцию, которая для каждого возможного времени жизни что-то возвращает. В вашем случае бывает, что для любого времени жизни 'aоно всегда будет одинаковым (а Vec<u8>), но если вы этого не знали, этот результат может зависеть от времени жизни, 'aпараметризующего функцию. Запрос этой функции на возврат этого (возможно, зависящего от времени жизни) типа для всех времен жизни в юниверсе , возможно, и сбивает с толку компилятор: вы не можете проверить это ограничение, не «нарушая локальность» и не зная, что ваше ограничение на самом деле не зависит от времени жизни.
вал
Это не так, поскольку в моем ответе оболочка newtype работает просто отлично при использовании связанного типа. Я не думаю, что вы можете иметь разные связанные типы для разных жизней; Единственное именованное время жизни, доступное в глобальной области видимости, где вы должны поместить impls, 'staticтак как бы вы реализовали вещи для разных жизней?
полковник тридцать два