Rust 在实现serde'；MessagePack的s序列序列化程序

我想在Rust中编写一个不兼容std的序列化程序/反序列化程序。我的大部分序列化工作正常，但我正在努力使用serde序列化结构、序列和映射。我从中复制了很多，但是我无法获得序列序列化程序的正确生存期

extern板条箱通用数组\u 0\u 13\u 2；//0.13.2
外部板条箱；
使用serde：：ser；
发布结构序列化程序ser:：SerializeSeq for SerializeSeq ser:：Serializer for&'a mut Serializer；
类型SerializeTuple=SerializeSeq；
类型SerializeStruct=SerializeStruct结果{
待办事项！（）
}
fn序列化单元变量(
自己
_：&'s static str，
_：u32，
_：&'s static str，
)->结果{
待办事项！（）
}
fn序列化新类型结构(
自己
_：&'s static str，
_：&T，
)->结果
哪里
T:serde:：序列化，
{
待办事项！（）
}
fn序列化新类型变量(
自己
_：&'s static str，
_：u32，
_：&'s static str，
_：&T，
)->结果
哪里
T:serde:：序列化，
{
待办事项！（）
}
fn序列化\u元组\u结构(
自己
_：&'s static str，
_：使用，
)->std:：result:：result<
：：序列化元组结构，
：：错误，
> {
待办事项！（）
}
fn序列化\u元组\u变量(
自己
_：&'s static str，
_：u32，
_：&'s static str，
_：使用，
)->std:：result:：result<
：：我是一个左派，
：：错误，
> {
待办事项！（）
}
fn序列化_映射(
自己
_：std:：option:：option，
)->std:：result:：result<
：：地图，
：：错误，
> {
待办事项！（）
}
fn序列化结构(
自己
_：&'s static str，
_：使用，
)->std:：result:：result<
：：序列化结构，
：：错误，
> {
待办事项！（）
}
fn序列化结构变量(
自己
_：&'s static str，
_：u32，
_：&'s static str，
_：使用，
)->std:：result:：result<
：：序列化结构变量，
：：错误，
> {
待办事项！（）
}
}
//----剩下的部分只是让编译器停止抱怨缺少实现
恳求{
pub fn new（ser:&'a mut序列化程序{
ser:&'a mut序列化程序{
ser:&'SerializeSeq ser:：SerializeStruct的mut序列化程序ser:：SerializeTuple用于SerializeStruct结果
哪里
T:ser：：序列化，
{
//序列化（&mut*self.ser）？；
好（（））
}
fn结束（自身）->结果{
好（（））
}
}
恳求{
类型Ok=（）；
类型错误=错误；
fn结束（自身）->结果{
好（（））
}
fn序列化\u键（&mut self，键：&T）->结果
哪里
T:ser：：序列化，
{
//key.serialize（&mut*self.ser）？；
好（（））
}
fn序列化\u值（&mut self，值：&T）->结果
哪里
T:ser：：序列化，
{
//序列化（&mut*self.ser）？；
好（（））
}
}
#[导出（调试）]
枚举错误{}
impl std:：fmt:：错误显示{
fn fmt（&self，f:&mut std:：fmt:：Formatter）->std:：fmt:：Result{
待办事项！（）
}
}
impl std:：error:：error{}的错误
impl serde:：ser:：Error for Error{
fn自定义（uu:T）->Self
哪里
T:std:：fmt:：显示，
{
待办事项！（）
}
}
发布枚举不可访问{}
impl-ser:：SerializeTupleStruct for Unreachable{
类型Ok=（）；
类型错误=错误；
fn序列化\u字段（&mut self，\u值：&T）->结果{
遥不可及！（）
}
fn结束（自身）->结果{
遥不可及！（）
}
}
impl ser:：SerializeTupleVariant for Unreachable{
类型Ok=（）；
类型错误=错误；
fn序列化\u字段（&mut self，\u值：&T）->结果{
遥不可及！（）
}
fn结束（自身）->结果{
遥不可及！（）
}
}
impl ser:：无法访问的序列化映射{
类型Ok=（）；
类型错误=错误；
fn序列化\u键（&mut self，\u键：&T）->结果
哪里
T:ser：：序列化，
{
遥不可及！（）
}
fn序列化_值（&mut self，_值：&T）->结果
哪里
T:ser：：序列化，
{
遥不可及！（）
}
fn结束（自身）->结果{
遥不可及！（）
}
}
impl ser:：SerializeStructVariant for Unreachable{
类型Ok=（）；
类型错误=错误；
fn序列化_字段(
&莫特·赛尔夫，
_键：&'static str，
_值：&T，
)->结果
哪里
T:ser：：序列化，
{
遥不可及！（）
}
fn结束（自身）->结果{
遥不可及！（）
}
}

这是我得到的错误：

错误[E0495]：由于需求冲突，无法推断借用表达式的适当生存期
-->src/lib.rs:23:25
|
23 | value.serialize（&mut*self.ser）？；
|                         ^^^^^^^^^^^^^^
|
注意：首先，生命周期不能超过方法体上18:5定义的匿名生命周期#1。。。
-->src/lib.rs:18:5
|
18 |/fn序列化_元素（&mut self，value:&T）->结果
19 | |在哪里
20 | T:ser：：序列化，
21 | |     {
...  |
24 | |好（（））
25 | |     }
| |_____^
注意：…这样引用就不会超过借用的内容
-->src/lib.rs:23:25
|
23 | value.serialize（&mut*self.ser）？；
|                         ^^^^^^^^^^^^^^
注意：但是，生存期必须对impl上14:6定义的生存期“a”有效。。。
-->src/lib.rs:14:6
|
14 | impl{
|      ^^
注意：…以便类型兼容
-->src/lib.rs:23:15
|
23 | value.serialize（&mut*self.ser）？；
|               ^^^^^^^^^
=注意：应为`serde:：Serializer`
找到“serde:：序列化程序”`

它与

序列化程序

中的字节片的生存期以及

&mut序列化程序

冲突的生存期有关，但我可以

extern crate generic_array_0_13_2; // 0.13.2
extern crate serde; 

use serde::ser;

pub struct Serializer<'a> {
    buf: &'a mut [u8],
    pos: usize,
}
pub struct SerializeSeq<'a> {
    ser: &'a mut Serializer<'a>,
}

impl<'a> ser::SerializeSeq for SerializeSeq<'a> {
    type Ok = ();
    type Error = Error;

    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<Self::Ok, Self::Error>
    where
        T: ser::Serialize,
    {
        // -------- This does not compile
        value.serialize(&mut *self.ser)?;
        Ok(())
    }
    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(())
    }
}

impl<'a> ser::Serializer for &'a mut Serializer<'a> {
    type Ok = ();
    type Error = Error;
    type SerializeSeq = SerializeSeq<'a>;
    type SerializeTuple = SerializeSeq<'a>;
    type SerializeTupleStruct = Unreachable;
    type SerializeTupleVariant = Unreachable;
    type SerializeMap = SerializeMap<'a>;
    type SerializeStruct = SerializeStruct<'a>;
    type SerializeStructVariant = Unreachable;
    // ...

    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
        Ok(SerializeSeq::new(self))
    }
    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
        self.serialize_seq(Some(len))
    }

    fn serialize_bool(self, _: bool) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_i8(self, _: i8) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_i16(self, _: i16) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_i32(self, _: i32) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_i64(self, _: i64) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_u8(self, _: u8) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_u16(self, _: u16) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_u32(self, _: u32) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_u64(self, _: u64) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_f32(self, _: f32) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_f64(self, _: f64) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_char(self, _: char) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_str(self, _: &str) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_bytes(self, _: &[u8]) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_some<T: ?Sized>(self, _: &T) -> Result<Self::Ok, Self::Error>
    where
        T: ser::Serialize,
    {
        todo!()
    }
    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_unit_struct(self, _: &'static str) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_unit_variant(
        self,
        _: &'static str,
        _: u32,
        _: &'static str,
    ) -> Result<Self::Ok, Self::Error> {
        todo!()
    }
    fn serialize_newtype_struct<T: ?Sized>(
        self,
        _: &'static str,
        _: &T,
    ) -> Result<Self::Ok, Self::Error>
    where
        T: serde::Serialize,
    {
        todo!()
    }
    fn serialize_newtype_variant<T: ?Sized>(
        self,
        _: &'static str,
        _: u32,
        _: &'static str,
        _: &T,
    ) -> Result<Self::Ok, Self::Error>
    where
        T: serde::Serialize,
    {
        todo!()
    }
    fn serialize_tuple_struct(
        self,
        _: &'static str,
        _: usize,
    ) -> std::result::Result<
        <Self as serde::Serializer>::SerializeTupleStruct,
        <Self as serde::Serializer>::Error,
    > {
        todo!()
    }
    fn serialize_tuple_variant(
        self,
        _: &'static str,
        _: u32,
        _: &'static str,
        _: usize,
    ) -> std::result::Result<
        <Self as serde::Serializer>::SerializeTupleVariant,
        <Self as serde::Serializer>::Error,
    > {
        todo!()
    }
    fn serialize_map(
        self,
        _: std::option::Option<usize>,
    ) -> std::result::Result<
        <Self as serde::Serializer>::SerializeMap,
        <Self as serde::Serializer>::Error,
    > {
        todo!()
    }
    fn serialize_struct(
        self,
        _: &'static str,
        _: usize,
    ) -> std::result::Result<
        <Self as serde::Serializer>::SerializeStruct,
        <Self as serde::Serializer>::Error,
    > {
        todo!()
    }
    fn serialize_struct_variant(
        self,
        _: &'static str,
        _: u32,
        _: &'static str,
        _: usize,
    ) -> std::result::Result<
        <Self as serde::Serializer>::SerializeStructVariant,
        <Self as serde::Serializer>::Error,
    > {
        todo!()
    }
}

// ---- The remaining part is just to make the compiler stop complaining about missing implementations

impl<'a> SerializeSeq<'a> {
    pub fn new(ser: &'a mut Serializer<'a>) -> Self {
        SerializeSeq { ser }
    }
}

pub struct SerializeMap<'a> {
    ser: &'a mut Serializer<'a>,
}
pub struct SerializeStruct<'a> {
    ser: &'a mut Serializer<'a>,
}

impl<'a> ser::SerializeTuple for SerializeSeq<'a> {
    type Ok = ();
    type Error = Error;

    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<Self::Ok, Self::Error>
    where
        T: ser::Serialize,
    {
        ser::SerializeSeq::serialize_element(self, value)
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        ser::SerializeSeq::end(self)
    }
}

impl<'a> ser::SerializeStruct for SerializeStruct<'a> {
    type Ok = ();
    type Error = Error;

    fn serialize_field<T: ?Sized>(
        &mut self,
        key: &'static str,
        value: &T,
    ) -> Result<Self::Ok, Self::Error>
    where
        T: ser::Serialize,
    {
        //value.serialize(&mut *self.ser)?;
        Ok(())
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(())
    }
}

impl<'a> ser::SerializeMap for SerializeMap<'a> {
    type Ok = ();
    type Error = Error;

    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(())
    }

    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<Self::Ok, Self::Error>
    where
        T: ser::Serialize,
    {
        //key.serialize(&mut *self.ser)?;
        Ok(())
    }

    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<Self::Ok, Self::Error>
    where
        T: ser::Serialize,
    {
        //value.serialize(&mut *self.ser)?;
        Ok(())
    }
}

#[derive(Debug)]
enum Error {}
impl std::fmt::Display for Error {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        todo!()
    }
}
impl std::error::Error for Error {}
impl serde::ser::Error for Error {
    fn custom<T>(_: T) -> Self
    where
        T: std::fmt::Display,
    {
        todo!()
    }
}
pub enum Unreachable {}

impl ser::SerializeTupleStruct for Unreachable {
    type Ok = ();
    type Error = Error;

    fn serialize_field<T: ?Sized>(&mut self, _value: &T) -> Result<Self::Ok, Self::Error> {
        unreachable!()
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        unreachable!()
    }
}

impl ser::SerializeTupleVariant for Unreachable {
    type Ok = ();
    type Error = Error;

    fn serialize_field<T: ?Sized>(&mut self, _value: &T) -> Result<Self::Ok, Self::Error> {
        unreachable!()
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        unreachable!()
    }
}

impl ser::SerializeMap for Unreachable {
    type Ok = ();
    type Error = Error;

    fn serialize_key<T: ?Sized>(&mut self, _key: &T) -> Result<Self::Ok, Self::Error>
    where
        T: ser::Serialize,
    {
        unreachable!()
    }

    fn serialize_value<T: ?Sized>(&mut self, _value: &T) -> Result<Self::Ok, Self::Error>
    where
        T: ser::Serialize,
    {
        unreachable!()
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        unreachable!()
    }
}

impl ser::SerializeStructVariant for Unreachable {
    type Ok = ();
    type Error = Error;

    fn serialize_field<T: ?Sized>(
        &mut self,
        _key: &'static str,
        _value: &T,
    ) -> Result<Self::Ok, Self::Error>
    where
        T: ser::Serialize,
    {
        unreachable!()
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        unreachable!()
    }
}