Rust 锈蚀期货——将两个期货连接在一起

我有这个密码

use futures::Map;
use futures::sink::SendAll;
use futures::sink::SinkFromErr;
use futures::stream::Forward;
use futures::sync::mpsc::Receiver;
use futures::sync::mpsc::Sender;
use futures::{Future, Stream, Sink};
use std::boxed::FnBox;
use tokio_core::reactor::Core;
use websocket::async::futures::stream::SplitSink;
use websocket::async::futures::stream::SplitStream;
use websocket::ClientBuilder;
use websocket;

pub fn main(recv: Receiver<String>, send: Sender<websocket::OwnedMessage>) -> Box<FnBox() -> () + Send> {
    Box::new(move || {
        let mut core = Core::new().unwrap();
        let handle = core.handle();

        let f = ClientBuilder::new("wss://...")
            .unwrap()
            .async_connect(None, &handle)
            .from_err::<Error>()
            .map(|(duplex, _)| duplex.split())
            .and_then(|(sink, stream): (SplitSink<_>, SplitStream<_>)| {

                let writer: Map<SendAll<SinkFromErr<SplitSink<_>, _>, _>, _> =
                    sink
                    .sink_from_err()
                    .send_all(recv.map(websocket::OwnedMessage::Text).map_err(Error::Receiver))
                    .map(|_| ());

                // Trying to uncomment these lines:
                // let reader =
                //     stream
                //     .forward(send);
                //
                // reader.join(writer)

                // Comment this out:
                writer
            });

        core.run(f).expect("Unable to run");
    })
}

quick_error! {
    #[derive(Debug)]
    pub enum Error {
        WebSocket(err: websocket::WebSocketError) {
            from()
            description("websocket error")
            display("WebSocket error: {}", err)
            cause(err)
        }
        Receiver(err: ()) {
            description("receiver error")
            display("Receiver error")
        }
    }
}

use futures:：Map；
使用futures:：sink:：SendAll；
使用futures:：sink:：SinkFromErr；
使用futures:：stream:：Forward；
使用futures:：sync:：mpsc:：Receiver；
使用futures:：sync:：mpsc:：Sender；
使用未来：{Future，Stream，Sink}；
使用std:：boxed:：FnBox；
使用tokio_堆芯：：反应堆：：堆芯；
使用websocket:：async:：futures:：stream:：SplitSink；
使用websocket:：async:：futures:：stream:：SplitStream；
使用websocket:：ClientBuilder；
使用websocket；
pub fn main（recv:Receiver，send:Sender）->Box（）+send>{
框：：新（移动| |）{
让mut core=core:：new（）.unwrap（）；
让handle=core.handle（）；
设f=ClientBuilder:：new（“wss://...")
.unwrap（）
.async_connect（无和句柄）
.from_err:：（）
.map（|（duplex，|）duplex.split（））
.然后（|（水槽，小溪）：（水槽，小溪）|{
让作者：地图=
下沉
.sink_from_err（）
.send_all（recv.map（websocket:：OwnedMessage:：Text）.map_err（Error:：Receiver））
.地图（| |（））；
//正在尝试取消注释这些行：
//让读者=
//溪流
//.转发（发送）；
//
//reader.join（writer）
//评论一下：
作家
});
core.run（f）expect（“无法运行”）；
})
}
快速出错！{
#[导出（调试）]
发布枚举错误{
WebSocket（错误：WebSocket:：WebSocketError）{
from（）
说明（“websocket错误”）
显示（“WebSocket错误：{}”，错误）
原因（错误）
}
接收器（错误：（））{
说明（“接收器错误”）
显示（“接收器错误”）
}
}
}

为了清晰起见，我添加了一些类型注释。这个版本可以编译，但我需要另一个未来版本，从流（

stream

）读取并写入

send

。我不能让它编译，我输入的错误是完全不可理解的。因此，我的问题是：

如何使

forward（）

调用编译？（尝试启用注释掉的代码）

您是如何编写代码来编译此文件的？根据我的经验，由于类型太复杂，类型错误难以理解，因此编写和理解未来繁重的代码是不可能的

---

我需要两个

map\u err

调用，一个用于映射

stream

中的websocket错误，一个用于映射

send

中的发件人错误：

pub fn main(recv: Receiver<String>, send: Sender<websocket::OwnedMessage>) -> Box<FnBox() -> () + Send> {
    Box::new(move || {
        let mut core = Core::new().unwrap();
        let handle = core.handle();

        let f = ClientBuilder::new("wss://...")
            .unwrap()
            .async_connect(None, &handle)
            .from_err::<Error>()
            .map(|(duplex, _)| duplex.split())
            .and_then(|(sink, stream): (SplitSink<_>, SplitStream<_>)| {

                let writer: Map<SendAll<SinkFromErr<SplitSink<_>, _>, _>, _> =
                    sink
                    .sink_from_err()
                    .send_all(recv.map(websocket::OwnedMessage::Text).map_err(Error::Receiver))
                    .map(|_| ());

                let reader =
                    stream
                    .map_err(Error::WebSocket)
                    .forward(send.sink_map_err(Error::Sender));

                reader.join(writer)
            });

        core.run(f).expect("Unable to run");
    })
}

pub fn main（recv:Receiver，send:Sender）->Box（）+send>{
框：：新（移动| |）{
让mut core=core:：new（）.unwrap（）；
让handle=core.handle（）；
设f=ClientBuilder:：new（“wss://...")
.unwrap（）
.async_connect（无和句柄）
.from_err:：（）
.map（|（duplex，|）duplex.split（））
.然后（|（水槽，小溪）：（水槽，小溪）|{
让作者：地图=
下沉
.sink_from_err（）
.send_all（recv.map（websocket:：OwnedMessage:：Text）.map_err（Error:：Receiver））
.地图（| |（））；
让读者=
流动
.map_err（错误：：WebSocket）
.forward（send.sink\u map\u err（Error:：Sender））；
reader.join（writer）
});
core.run（f）expect（“无法运行”）；
})
}

您将两个期货与。就像你注释掉的代码一样。请回顾如何创建一个，强调最小。例如，为什么

serde_json

存在但未使用？您得到的错误消息在哪里？你基本上已经问过这个问题了，所以你需要超越这些，使这个问题变得清晰。从该答案中注释掉

reader

或

writer

，并返回另一个答案是有效的。@Shepmaster抱歉，除非我启用注释掉的代码，否则忘记提到代码是有效的。更新了问题。@Shepmaster

Future:：join

引发了疯狂的错误，这就是我的问题。“我怎样才能做到这一点？”谢普马斯特把这个例子缩小了一些。