Rust Futures-应为（），已找到结构Futures:：Map

我试图用发送一个请求，然后通过JSON反序列化它，但我似乎无法理解未来，我收到了类型不匹配错误，声明

expected（），find struct[在此处放置一些奇怪的结构]

。我也不能对他们在每次更改时吐出的令人难以置信的长而混乱的错误信息束手无策。这是我的密码：

extern crate futures;
extern crate hyper;
extern crate serde;
extern crate serde_json;

use futures::{
    Future,
    Stream,
    future
};
use hyper::{
    Body,
    Client,
    Response,
    StatusCode,
    Uri,
    client::HttpConnector,
};
use serde::{ Deserialize };
use std::error::{ Error };

enum JsonError
{
    RequestError(hyper::Error),
    ResponseError(StatusCode),
    DeserializeError(serde_json::Error),
}

fn get_json
    <'t, T, F>
    (client: &Client<HttpConnector>, uri: Uri)
-> impl Future<Item = T, Error = JsonError>
where
    T : Deserialize<'t>
{
    let f = client
        .get(uri)
        .map(|response|
        {
            let (parts, body) = response.into_parts();

            if parts.status.is_success()
            {
                body
                    .fold(
                        vec![],
                        |mut accum, chunk|
                        {
                            accum.extend_from_slice(&*chunk);
                            Ok(accum)
                        }
                    )
                    .map(|v|
                    {
                        serde_json::from_slice::<T>(&v)
                            .map_err(|err| JsonError::DeserializeError(err))
                    })
            }

            future::err(JsonError::ResponseError(parts.status))
        })
        .map_err(|err| JsonError::RequestError(err));

    return f;
}

extern板条箱期货；
外部板条箱；
外部板条箱；
外部板条箱serde_json；
使用期货：{
未来,，
流动
未来
};
使用超链接：{
身体，
客户
答复,，
状态码，
乌里，
客户端：：HttpConnector，
};
使用serde:：{反序列化}；
使用std:：error:：{error}；
枚举JsonError
{
RequestError（hyper:：Error），
响应者（状态代码），
反序列化错误（serde_json:：Error），
}
fn get_json
{
设f=client
.get（uri）
.map（|响应|
{
let（parts，body）=response.into_parts（）；
如果parts.status.is_success（）
{
身体
.折叠(
vec！[]，
|多个累计，块|
{
从块（&*块）累积扩展块；
正常（累计）
}
)
.map（| v|
{
serde_json:：from_slice:：（&v）
.map_err（| err | JsonError:：反序列化错误（err））
})
}
future:：err（JsonError:：ResponseError（parts.status））
})
.map_err（| err | JsonError:：RequestError（err））；
返回f；
}

---

我完全不知所措，我认为任何建议都可以在这一点上有所帮助。

在链接期货时，您会遇到多个由逻辑问题引起的错误。我已经修复了它的实现，但我强烈建议您与我一起完成我所更改的内容

但首先，代码中出现了一种反复出现的趋势：

#1:

Future:：map（）

的返回类型

Future:：map（）

允许您将类型为

T

的未来结果更改为类型

R

，并假设转换不会失败（即

Fn（T）->R

）。您在代码中多次使用

map（）

，同时返回另一个

Future

，或

结果。两者都是错误的

对于
Future
链接，
和_then（）
允许您执行
fn（T）->到Future
的映射，错误类型保持不变

对于
Result
，请通过
future:：Result（）
将它们转换为已执行的future，这样您也可以
和\u then（）

#2：错误
错误不会自行转换，尤其是在未定义其转换方法的情况下。为此，我已从

为您的错误类型实现了

：

impl From<hyper::Error> for JsonError {
    fn from(s: hyper::Error) -> JsonError {
        JsonError::RequestError(s)
    }
}

您从这段代码中得到的确切错误是什么，它指的是哪一行？第32行给出了错误
预期结构“get_json:：futures:：Finished”，找到类型参数
。第44行到第57行给出了错误
expected（），找到了结构“get_json:：futures:：Map”
。您能在问题中粘贴完整的错误消息吗？这将使我们更容易看到哪一行是第32行，哪一行是第44行到第57行，并允许我们看到编译器正在抱怨哪一部分。您知道您使用的是旧的
Future
API吗？如果可以，您应该使用
async
/
.await
符号，这使代码更易于阅读。请看：我通常使用的是
的别名，首先，非常感谢！当时我花了大约8个小时试图找出从哪里开始解决我的问题，但我并没有思考清楚。你的回答澄清了一大堆我没有想到的教程。第二，我从来没有见过
，因为我知道连接器的问题，但在我解决了以后的bug之后，我就离开了。这是否足以使它具有适当的特征和生命周期，或者这仍然是一个太过严格的限制？在我看来，你可以使用任何客户。
use futures::{future, Future, Stream};
use hyper::{client::HttpConnector, Client, StatusCode, Uri};
use serde::Deserialize;

enum JsonError {
    RequestError(hyper::Error),
    ResponseError(StatusCode),
    DeserializeError(serde_json::Error),
}

impl From<hyper::Error> for JsonError {
    fn from(s: hyper::Error) -> JsonError {
        JsonError::RequestError(s)
    }
}

fn get_json<T, F>(
    client: &Client<HttpConnector>,
    uri: Uri,
) -> impl Future<Item = T, Error = JsonError>
where
    T: for<'t> Deserialize<'t> + 'static,
{
    client.get(uri).map_err(|e| e.into()).and_then(
        |response| -> Box<dyn Future<Item = T, Error = JsonError>> {
            let (parts, body) = response.into_parts();

            match parts.status.is_success() {
                true => Box::new(body
                    .map_err(|e| e.into())
                    .fold(
                        vec![],
                        |mut accum, chunk| -> Box<dyn Future<Item = Vec<u8>, Error = JsonError>>
                        {
                            accum.extend_from_slice(&*chunk);
                            Box::new(future::ok(accum))
                        }
                    )
                    .and_then(|v|
                    {
                        future::result(serde_json::from_slice::<T>(&v))
                            .map_err(|err| JsonError::DeserializeError(err))
                    })),
                false => Box::new(future::err(JsonError::ResponseError(parts.status)))
            }
        },
    )
}