Rust：特性中的通用返回类型，用于返回非对象安全特性的实现

Question

I'm new to Rust and I wanted to learn the language and get a better understanding by implementing some small projects. My first attempt was to parse JSON data received from an MQTT Broker. I was very pleased how easy it was to accomplish this with the help of tornado and serde . However, there quickly arose a pattern that I wanted to (ideally) extract into a Trait.

let person_stream = sender.subscribe().filter_map(|data| {
    if let Ok(value) = data {
        return serde_json::from_slice::<Person>(&value).ok();
    }
    None
});

where sender typically is a tokio::sync::*::Sender and Person would implement the serde::de::DeserializeOwned Trait.

So the goal was to implement something that takes a tokio::stream::StreamExt<Item = Vec<u8>> and transform it into another StreamExt where the associated type Item would implement DeserializOwned .

It took me quite some time to figure something out (since I originally wanted to use a Trait or a function with generics) and I came up with

fn transform<T, U, V>(stream: U) -> impl StreamExt<Item = T>
where
    T: serde::de::DeserializeOwned,
    U: StreamExt<Item = Result<Vec<u8>, V>>,
{
    stream.filter_map(|data| {
        if let Ok(value) = data {
            return serde_json::from_slice::<T>(&value).ok();
        }
        None
    })
}

While this works I originally wanted a Trait like

trait Transform<T>
{
    fn transform(self) -> T;
}

or implement Into which is actually the same, which I could implement for StreamExt<Item = Vec<u8>> . Since impl Trait return is not available for Traits this was the only option I thought I had. However, I'm facing a couple of issues implementing this.

1. Using tokio::stream::filter_map::FilterMap<_,_> for T (which is the return type of filter_map() ) is not possible since the module filter_map is private .
2. Using Box<dyn StreamExt> isn't possible either, since StreamExt returns Self in a couple of functions. I didn't want the Heap overhead in the first place though;)

So my question is: Is there anything I could do here to get the syntactic sugar of a Trait implementation given the fact that the return type of filter_map() is private and StreamExt isn't object-safe? It would be cool to just use

let person_stream = receiver.transform();

or into() . Obviously I have a working implementation so this isn't really a critical question for me. But as I said at the beginning I wanted to get a deeper and better understanding about Rust in the first place.

I noticed that there is the tokio-serde crate, but at first glance it only deals with framed data, so I haven't dug deeper into it.

PS: I also faced a problem with the free function transform I implemented when the type inference fails. For example when handing of the new stream to a function like

async fn debug_sink<T>(mut receiver: T)
where
    T: StreamExt + Unpin,
    T::Item: std::fmt::Debug,
{
    while let Some(item) = receiver.next().await {
        println!("Item: {:#?}", item);
    }
}

In this case it obviously couldn't infer T in transfer in contrast to sinks like

async fn person_sink(mut receiver: impl StreamExt<Item = Person> + Unpin) {
    while let Some(person) = receiver.next().await {
        println!("Person: {:#?}", person);
    }
}

However I didn't want to annotate all type parameters, only the one it couldn't infer. With some trial and error I found out that I could use

transform::<Person, _, _>(stream);

which I was totally unaware of. I couldn't find this in the documentation, though. Is this some hidden feature, or am I just failing to properly rtfm? :)

Answer 1

I think that what you need is available in Nightly under the type_alias_impl_trait feature. Basically it allows you to write an associated type in a trait, and then, in the implementation, instead of writing a named type, usie the impl BaseTrait syntax.

I'm too lazy to write your code with a type_alias_impl_trait (and you didn't provide a compilable snippet) but here it is a working example ( playground ):

#![feature(type_alias_impl_trait)]

use std::fmt::Debug;

trait Foo {
    type Output: Debug;

    fn do_something() -> Self::Output;
}

impl Foo for () {
    type Output = impl Debug;

    fn do_something() -> Self::Output {
        "hello!"
    }
}

Note how ()::do_something actually returns a &'static str but this type is never mentioned.