小编Bor*_*ris的帖子

我想构建一个自定义反序列化器来Vec<Child>将值数组的数组反序列化为Child.

一个想法是Vec<Child>直接添加一个客户解串器，但我想知道是否存在更优雅的解决方案。

作为一个例子，我正在尝试制作类似下面的内容，但array在 Parent 中使用字段而不是single.

extern crate serde_json; // 1.0.32
extern crate serde; // 1.0.80
#[macro_use] extern crate serde_derive;

use serde::de::{Deserializer, SeqAccess, Visitor};
use std::fmt;

#[derive(Debug, Deserialize)]
struct Parent {
    #[serde(deserialize_with = "parse_child")]
    single: Child,
    //#[serde(deserialize_with = "parse_child")]
    //array: Vec<Child>,
}

#[derive(Default, Debug, Deserialize)]
struct Child {
    a: u64,
    b: f32,
    c: usize,
}

fn parse_child<'de, D>(deserializer: D) -> Result<Child, D::Error>
where
    D: Deserializer<'de>,
{
    struct ChildParser;
    impl<'de> Visitor<'de> for …

我正在尝试使用hyper来获取HTML页面的内容，并希望同步返回将来的输出。我意识到我可以选择一个更好的示例，因为同步HTTP请求已经存在，但是我对了解我们是否可以从异步计算中返回一个值更感兴趣。

extern crate futures;
extern crate hyper;
extern crate hyper_tls;
extern crate tokio;

use futures::{future, Future, Stream};
use hyper::Client;
use hyper::Uri;
use hyper_tls::HttpsConnector;

use std::str;

fn scrap() -> Result<String, String> {
    let scraped_content = future::lazy(|| {
        let https = HttpsConnector::new(4).unwrap();
        let client = Client::builder().build::<_, hyper::Body>(https);

        client
            .get("https://hyper.rs".parse::<Uri>().unwrap())
            .and_then(|res| {
                res.into_body().concat2().and_then(|body| {
                    let s_body: String = str::from_utf8(&body).unwrap().to_string();
                    futures::future::ok(s_body)
                })
            }).map_err(|err| format!("Error scraping web page: {:?}", &err))
    });

    scraped_content.wait()
}

fn read() {
    let scraped_content = future::lazy(|| {
        let https = HttpsConnector::new(4).unwrap(); …

根据 Serde 规范，一个Object/Map<String, Value>是一个Value：

pub enum Value {
    Null,
    Bool(bool),
    Number(Number),
    String(String),
    Array(Vec<Value>),
    Object(Map<String, Value>),
}

然而，当我编译这段代码时：

extern crate serde;
#[macro_use]
extern crate serde_json;

#[derive(Debug)]
struct Wrapper {
    ok: bool,
    data: Option<serde_json::Value>,
}

impl Wrapper {
    fn ok() -> Wrapper {
        Wrapper {
            ok: true,
            data: None,
        }
    }

    pub fn data(&mut self, data: serde_json::Value) -> &mut Wrapper {
        self.data = Some(data);
        self
    }

    pub fn finalize(self) -> Wrapper {
        self
    }
}

trait …