Async Serde

这是一个用于 async fn 的 crate。它不一定更高效，只是不同。它允许直接使用 serde 与数据格式（如 JSON 等）交互，而不是通过反序列化。

其主要功能是将非确定性（在自动机意义上）的转换直接应用于反序列化过程。如果你正在制作一个直接在数据流上操作的 jq 克隆，而不是首先将整个数据流加载到内存数据结构中，这特别有用。

注意

请注意，类型 Instructor 和 Step 可以在 Run impl 中自由传递。虽然这不是不安全的，但这可能导致难以调试的错误。建议仅按照这些示例中所示使用它们，以避免难以调试的运行时错误。

示例

use std::borrow::Cow;

use async_serde::Deserialize;
use async_serde::Inspect;
use async_serde::Instructor;
use async_serde::Run;
use async_serde::Visit;
use async_trait::async_trait;

struct Foo;
#[async_trait(?Send)]
impl<'de, E: serde::de::Error> Run<'de, E> for Foo {
    type Output = Cow<'de, str>;
    async fn run(
        self,
        instructor: Instructor<'_, 'de>
    ) -> Result<Self::Output, E> {
        let step = instructor.ask(Deserialize::String).unwrap().await;
        match step.kind() {
            Visit::Str => {
                step.inspect_string(|s| {
                    match s {
                        Inspect::Borrowed(s) => Cow::from(s),
                        Inspect::Owned(s) => Cow::from(String::from(s)),
                        Inspect::Buffered(s) => Cow::from(s.to_owned()),
                    }
                }).ok_or_else(|| E::custom("wrong type"))
            },
            _ => Err(E::custom("wrong type")),
        }
    }
}

fn main() {
    let mut json = serde_json::Deserializer::from_str("\"hello\"");
    let exec = async_serde::Executor::new(&mut json);
    // this is returning an Result<Option<Cow<'de, str>>, Error>
    let res = exec.run::<_, serde_json::Error>(Foo);
    assert_eq!(res.unwrap(), "hello");
}

use std::borrow::Cow;

use async_serde::Deserialize;
use async_serde::Inspect;
use async_serde::Instructor;
use async_serde::Run;
use async_serde::Visit;
use async_trait::async_trait;

struct Foo;
#[async_trait(?Send)]
impl<'de, E: serde::de::Error> Run<'de, E> for Foo {
    type Output = [Vec<Cow<'de, str>>; 2];
    async fn run(
        self,
        instructor: Instructor<'_, 'de>
    ) -> Result<Self::Output, E> {
        let mut step = instructor.ask(Deserialize::Seq).unwrap().await;
        match step.kind() {
            Visit::Seq => {
                let step2 = step.cloned();
                match futures::join!(
                    step.inspect_seq(|s| async move {
                        // TODO
                        Ok(Vec::new())
                    }).ok_or_else(|| E::custom("wrong type"))?,
                    step2.inspect_seq(|s| async move {
                        // TODO
                        Ok(Vec::new())
                    }).ok_or_else(|| E::custom("wrong type"))?
                ) {
                    (a, b) => Ok([a?, b?])
                }
            },
            _ => Err(E::custom("wrong type")),
        }
    }
}

fn main() {
    let mut json = serde_json::Deserializer::from_str("[\"a\", \"b\"]");
    let exec = async_serde::Executor::new(&mut json);
    // this is returning an Result<Option<Cow<'de, str>>, Error>
    let res = exec.run::<_, serde_json::Error>(Foo).unwrap();
    assert_eq!(res[0], &[Cow::from("a"), "b".into()][..]);
    assert_eq!(res[1], &[Cow::from("a"), "b".into()][..]);
}