Merge pull request #22 from alecmocatta/serialize-ref

mergify[bot] · web-flow · commit a57dc7efd25c · 2019-10-18T20:04:08.000Z
More general Serialize impls on convenience traits
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "serde_traitobject"
-version = "0.2.1"
+version = "0.2.2"
 license = "MIT OR Apache-2.0"
 authors = ["Alec Mocatta <alec@mocatta.net>"]
 categories = ["development-tools","encoding","rust-patterns","network-programming"]
@@ -12,7 +12,7 @@ This library enables the serialization and deserialization of trait objects such
 """
 repository = "https://github.com/alecmocatta/serde_traitobject"
 homepage = "https://github.com/alecmocatta/serde_traitobject"
-documentation = "https://docs.rs/serde_traitobject/0.2.1"
+documentation = "https://docs.rs/serde_traitobject/0.2.2"
 readme = "README.md"
 edition = "2018"
 
diff --git a/README.md b/README.md
@@ -4,15 +4,15 @@
 [![MIT / Apache 2.0 licensed](https://img.shields.io/crates/l/serde_traitobject.svg?maxAge=2592000)](#License)
 [![Build Status](https://dev.azure.com/alecmocatta/serde_traitobject/_apis/build/status/tests?branchName=master)](https://dev.azure.com/alecmocatta/serde_traitobject/_build/latest?branchName=master)
 
-[Docs](https://docs.rs/serde_traitobject/0.2.1/serde_traitobject/)
+[Docs](https://docs.rs/serde_traitobject/0.2.2/serde_traitobject/)
 
 **Serializable and deserializable trait objects.**
 
 This library enables the serialization and deserialization of trait objects so they can be sent between other processes running the same binary.
 
 For example, if you have multiple forks of a process, or the same binary running on each of a cluster of machines, this library lets you send trait objects between them.
 
-Any trait can be made (de)serializable when made into a trait object by adding this crate's [Serialize](https://docs.rs/serde_traitobject/0.2.1/serde_traitobject/trait.Serialize.html) and [Deserialize](https://docs.rs/serde_traitobject/0.2.1/serde_traitobject/trait.Deserialize.html) traits as supertraits:
+Any trait can be made (de)serializable when made into a trait object by adding this crate's [Serialize](https://docs.rs/serde_traitobject/0.2.2/serde_traitobject/trait.Serialize.html) and [Deserialize](https://docs.rs/serde_traitobject/0.2.2/serde_traitobject/trait.Deserialize.html) traits as supertraits:
 
 ```rust
 trait MyTrait: serde_traitobject::Serialize + serde_traitobject::Deserialize {
@@ -28,12 +28,12 @@ struct Message(#[serde(with = "serde_traitobject")] Box<dyn MyTrait>);
 And that's it! The two traits are automatically implemented for all `T: serde::Serialize` and all `T: serde::de::DeserializeOwned`, so as long as all implementors of your trait are themselves serializable then you're good to go.
 
 There are two ways to (de)serialize your trait object:
- * Apply the `#[serde(with = "serde_traitobject")]` [field attribute](https://serde.rs/attributes.html), which instructs serde to use this crate's [serialize](https://docs.rs/serde_traitobject/0.2.1/serde_traitobject/fn.serialize.html) and [deserialize](https://docs.rs/serde_traitobject/0.2.1/serde_traitobject/fn.deserialize.html) functions;
- * The [Box](https://docs.rs/serde_traitobject/0.2.1/serde_traitobject/struct.Box.html), [Rc](https://docs.rs/serde_traitobject/0.2.1/serde_traitobject/struct.Rc.html) and [Arc](https://docs.rs/serde_traitobject/0.2.1/serde_traitobject/struct.Arc.html) structs, which are simple wrappers around their stdlib counterparts that automatically handle (de)serialization without needing the above annotation;
+ * Apply the `#[serde(with = "serde_traitobject")]` [field attribute](https://serde.rs/attributes.html), which instructs serde to use this crate's [serialize](https://docs.rs/serde_traitobject/0.2.2/serde_traitobject/fn.serialize.html) and [deserialize](https://docs.rs/serde_traitobject/0.2.2/serde_traitobject/fn.deserialize.html) functions;
+ * The [Box](https://docs.rs/serde_traitobject/0.2.2/serde_traitobject/struct.Box.html), [Rc](https://docs.rs/serde_traitobject/0.2.2/serde_traitobject/struct.Rc.html) and [Arc](https://docs.rs/serde_traitobject/0.2.2/serde_traitobject/struct.Arc.html) structs, which are simple wrappers around their stdlib counterparts that automatically handle (de)serialization without needing the above annotation;
 
 Additionally, there are several convenience traits implemented that extend their stdlib counterparts:
 
- * [Any](https://docs.rs/serde_traitobject/0.2.1/serde_traitobject/trait.Any.html), [Debug](https://docs.rs/serde_traitobject/0.2.1/serde_traitobject/trait.Debug.html), [Display](https://docs.rs/serde_traitobject/0.2.1/serde_traitobject/trait.Display.html), [Error](https://docs.rs/serde_traitobject/0.2.1/serde_traitobject/trait.Error.html), [Fn](https://docs.rs/serde_traitobject/0.2.1/serde_traitobject/trait.Fn.html), [FnMut](https://docs.rs/serde_traitobject/0.2.1/serde_traitobject/trait.FnMut.html), [FnOnce](https://docs.rs/serde_traitobject/0.2.1/serde_traitobject/trait.FnOnce.html)
+ * [Any](https://docs.rs/serde_traitobject/0.2.2/serde_traitobject/trait.Any.html), [Debug](https://docs.rs/serde_traitobject/0.2.2/serde_traitobject/trait.Debug.html), [Display](https://docs.rs/serde_traitobject/0.2.2/serde_traitobject/trait.Display.html), [Error](https://docs.rs/serde_traitobject/0.2.2/serde_traitobject/trait.Error.html), [Fn](https://docs.rs/serde_traitobject/0.2.2/serde_traitobject/trait.Fn.html), [FnMut](https://docs.rs/serde_traitobject/0.2.2/serde_traitobject/trait.FnMut.html), [FnOnce](https://docs.rs/serde_traitobject/0.2.2/serde_traitobject/trait.FnOnce.html)
 
 These are automatically implemented on all implementors of their stdlib counterparts that also implement `serde::Serialize` and `serde::de::DeserializeOwned`.
 
diff --git a/src/convenience.rs b/src/convenience.rs
@@ -415,12 +415,23 @@ where
 	}
 }
 
-impl serde::ser::Serialize for boxed::Box<dyn Any + 'static> {
+impl<'a> AsRef<Self> for dyn Any + 'a {
+	fn as_ref(&self) -> &Self {
+		self
+	}
+}
+impl<'a> AsRef<Self> for dyn Any + Send + 'a {
+	fn as_ref(&self) -> &Self {
+		self
+	}
+}
+
+impl serde::ser::Serialize for dyn Any {
 	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 	where
 		S: serde::Serializer,
 	{
-		serialize(&self, serializer)
+		serialize(self, serializer)
 	}
 }
 impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Any + 'static> {
@@ -431,12 +442,12 @@ impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Any + 'static> {
 		<Box<dyn Any + 'static>>::deserialize(deserializer).map(|x| x.0)
 	}
 }
-impl serde::ser::Serialize for boxed::Box<dyn Any + Send + 'static> {
+impl serde::ser::Serialize for dyn Any + Send {
 	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 	where
 		S: serde::Serializer,
 	{
-		serialize(&self, serializer)
+		serialize(self, serializer)
 	}
 }
 impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Any + Send + 'static> {
@@ -484,6 +495,17 @@ impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Any + Send + 'static> {
 pub trait Error: error::Error + Serialize + Deserialize {}
 impl<T: ?Sized> Error for T where T: error::Error + Serialize + Deserialize {}
 
+impl<'a> AsRef<Self> for dyn Error + 'a {
+	fn as_ref(&self) -> &Self {
+		self
+	}
+}
+impl<'a> AsRef<Self> for dyn Error + Send + 'a {
+	fn as_ref(&self) -> &Self {
+		self
+	}
+}
+
 #[allow(clippy::use_self)]
 impl<'a, E: error::Error + Serialize + Deserialize + 'a> From<E> for Box<dyn Error + 'a> {
 	fn from(err: E) -> Self {
@@ -497,12 +519,12 @@ impl<'a, E: error::Error + Serialize + Deserialize + 'a> From<E> for boxed::Box<
 	}
 }
 
-impl serde::ser::Serialize for boxed::Box<dyn Error + 'static> {
+impl serde::ser::Serialize for dyn Error {
 	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 	where
 		S: serde::Serializer,
 	{
-		serialize(&self, serializer)
+		serialize(self, serializer)
 	}
 }
 impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Error + 'static> {
@@ -513,12 +535,12 @@ impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Error + 'static> {
 		<Box<dyn Error + 'static>>::deserialize(deserializer).map(|x| x.0)
 	}
 }
-impl serde::ser::Serialize for boxed::Box<dyn Error + Send + 'static> {
+impl serde::ser::Serialize for dyn Error + Send {
 	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 	where
 		S: serde::Serializer,
 	{
-		serialize(&self, serializer)
+		serialize(self, serializer)
 	}
 }
 impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Error + Send + 'static> {
@@ -555,12 +577,23 @@ impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Error + Send + 'static>
 pub trait Display: fmt::Display + Serialize + Deserialize {}
 impl<T: ?Sized> Display for T where T: fmt::Display + Serialize + Deserialize {}
 
-impl serde::ser::Serialize for boxed::Box<dyn Display + 'static> {
+impl<'a> AsRef<Self> for dyn Display + 'a {
+	fn as_ref(&self) -> &Self {
+		self
+	}
+}
+impl<'a> AsRef<Self> for dyn Display + Send + 'a {
+	fn as_ref(&self) -> &Self {
+		self
+	}
+}
+
+impl serde::ser::Serialize for dyn Display {
 	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 	where
 		S: serde::Serializer,
 	{
-		serialize(&self, serializer)
+		serialize(self, serializer)
 	}
 }
 impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Display + 'static> {
@@ -571,12 +604,12 @@ impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Display + 'static> {
 		<Box<dyn Display + 'static>>::deserialize(deserializer).map(|x| x.0)
 	}
 }
-impl serde::ser::Serialize for boxed::Box<dyn Display + Send + 'static> {
+impl serde::ser::Serialize for dyn Display + Send {
 	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 	where
 		S: serde::Serializer,
 	{
-		serialize(&self, serializer)
+		serialize(self, serializer)
 	}
 }
 impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Display + Send + 'static> {
@@ -613,12 +646,23 @@ impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Display + Send + 'stati
 pub trait Debug: fmt::Debug + Serialize + Deserialize {}
 impl<T: ?Sized> Debug for T where T: fmt::Debug + Serialize + Deserialize {}
 
-impl serde::ser::Serialize for boxed::Box<dyn Debug + 'static> {
+impl<'a> AsRef<Self> for dyn Debug + 'a {
+	fn as_ref(&self) -> &Self {
+		self
+	}
+}
+impl<'a> AsRef<Self> for dyn Debug + Send + 'a {
+	fn as_ref(&self) -> &Self {
+		self
+	}
+}
+
+impl serde::ser::Serialize for dyn Debug {
 	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 	where
 		S: serde::Serializer,
 	{
-		serialize(&self, serializer)
+		serialize(self, serializer)
 	}
 }
 impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Debug + 'static> {
@@ -629,12 +673,12 @@ impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Debug + 'static> {
 		<Box<dyn Debug + 'static>>::deserialize(deserializer).map(|x| x.0)
 	}
 }
-impl serde::ser::Serialize for boxed::Box<dyn Debug + Send + 'static> {
+impl serde::ser::Serialize for dyn Debug + Send {
 	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 	where
 		S: serde::Serializer,
 	{
-		serialize(&self, serializer)
+		serialize(self, serializer)
 	}
 }
 impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Debug + Send + 'static> {
@@ -652,14 +696,23 @@ impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Debug + Send + 'static>
 pub trait FnOnce<Args>: ops::FnOnce<Args> + Serialize + Deserialize {}
 impl<T: ?Sized, Args> FnOnce<Args> for T where T: ops::FnOnce<Args> + Serialize + Deserialize {}
 
-impl<Args: 'static, Output: 'static> serde::ser::Serialize
-	for boxed::Box<dyn FnOnce<Args, Output = Output> + 'static>
-{
+impl<'a, Args, Output> AsRef<Self> for dyn FnOnce<Args, Output = Output> + 'a {
+	fn as_ref(&self) -> &Self {
+		self
+	}
+}
+impl<'a, Args, Output> AsRef<Self> for dyn FnOnce<Args, Output = Output> + Send + 'a {
+	fn as_ref(&self) -> &Self {
+		self
+	}
+}
+
+impl<Args: 'static, Output: 'static> serde::ser::Serialize for dyn FnOnce<Args, Output = Output> {
 	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 	where
 		S: serde::Serializer,
 	{
-		serialize(&self, serializer)
+		serialize(self, serializer)
 	}
 }
 impl<'de, Args: 'static, Output: 'static> serde::de::Deserialize<'de>
@@ -673,13 +726,13 @@ impl<'de, Args: 'static, Output: 'static> serde::de::Deserialize<'de>
 	}
 }
 impl<Args: 'static, Output: 'static> serde::ser::Serialize
-	for boxed::Box<dyn FnOnce<Args, Output = Output> + Send + 'static>
+	for dyn FnOnce<Args, Output = Output> + Send
 {
 	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 	where
 		S: serde::Serializer,
 	{
-		serialize(&self, serializer)
+		serialize(self, serializer)
 	}
 }
 impl<'de, Args: 'static, Output: 'static> serde::de::Deserialize<'de>
@@ -700,14 +753,23 @@ impl<'de, Args: 'static, Output: 'static> serde::de::Deserialize<'de>
 pub trait FnMut<Args>: ops::FnMut<Args> + Serialize + Deserialize {}
 impl<T: ?Sized, Args> FnMut<Args> for T where T: ops::FnMut<Args> + Serialize + Deserialize {}
 
-impl<Args: 'static, Output: 'static> serde::ser::Serialize
-	for boxed::Box<dyn FnMut<Args, Output = Output> + 'static>
-{
+impl<'a, Args, Output> AsRef<Self> for dyn FnMut<Args, Output = Output> + 'a {
+	fn as_ref(&self) -> &Self {
+		self
+	}
+}
+impl<'a, Args, Output> AsRef<Self> for dyn FnMut<Args, Output = Output> + Send + 'a {
+	fn as_ref(&self) -> &Self {
+		self
+	}
+}
+
+impl<Args: 'static, Output: 'static> serde::ser::Serialize for dyn FnMut<Args, Output = Output> {
 	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 	where
 		S: serde::Serializer,
 	{
-		serialize(&self, serializer)
+		serialize(self, serializer)
 	}
 }
 impl<'de, Args: 'static, Output: 'static> serde::de::Deserialize<'de>
@@ -721,13 +783,13 @@ impl<'de, Args: 'static, Output: 'static> serde::de::Deserialize<'de>
 	}
 }
 impl<Args: 'static, Output: 'static> serde::ser::Serialize
-	for boxed::Box<dyn FnMut<Args, Output = Output> + Send + 'static>
+	for dyn FnMut<Args, Output = Output> + Send
 {
 	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 	where
 		S: serde::Serializer,
 	{
-		serialize(&self, serializer)
+		serialize(self, serializer)
 	}
 }
 impl<'de, Args: 'static, Output: 'static> serde::de::Deserialize<'de>
@@ -748,14 +810,23 @@ impl<'de, Args: 'static, Output: 'static> serde::de::Deserialize<'de>
 pub trait Fn<Args>: ops::Fn<Args> + Serialize + Deserialize {}
 impl<T: ?Sized, Args> Fn<Args> for T where T: ops::Fn<Args> + Serialize + Deserialize {}
 
-impl<Args: 'static, Output: 'static> serde::ser::Serialize
-	for boxed::Box<dyn Fn<Args, Output = Output> + 'static>
-{
+impl<'a, Args, Output> AsRef<Self> for dyn Fn<Args, Output = Output> + 'a {
+	fn as_ref(&self) -> &Self {
+		self
+	}
+}
+impl<'a, Args, Output> AsRef<Self> for dyn Fn<Args, Output = Output> + Send + 'a {
+	fn as_ref(&self) -> &Self {
+		self
+	}
+}
+
+impl<Args: 'static, Output: 'static> serde::ser::Serialize for dyn Fn<Args, Output = Output> {
 	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 	where
 		S: serde::Serializer,
 	{
-		serialize(&self, serializer)
+		serialize(self, serializer)
 	}
 }
 impl<'de, Args: 'static, Output: 'static> serde::de::Deserialize<'de>
@@ -769,13 +840,13 @@ impl<'de, Args: 'static, Output: 'static> serde::de::Deserialize<'de>
 	}
 }
 impl<Args: 'static, Output: 'static> serde::ser::Serialize
-	for boxed::Box<dyn Fn<Args, Output = Output> + Send + 'static>
+	for dyn Fn<Args, Output = Output> + Send
 {
 	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
 	where
 		S: serde::Serializer,
 	{
-		serialize(&self, serializer)
+		serialize(self, serializer)
 	}
 }
 impl<'de, Args: 'static, Output: 'static> serde::de::Deserialize<'de>
diff --git a/src/lib.rs b/src/lib.rs
@@ -94,7 +94,7 @@
 //!
 //! This crate currently requires Rust nightly.
 
-#![doc(html_root_url = "https://docs.rs/serde_traitobject/0.2.1")]
+#![doc(html_root_url = "https://docs.rs/serde_traitobject/0.2.2")]
 #![feature(
 	arbitrary_self_types,
 	coerce_unsized,
diff --git a/tests/test.rs b/tests/test.rs

Original file line number	Diff line number	Diff line change
`@@ -415,12 +415,23 @@ where`
`415`	`415`	`}`
`416`	`416`	`}`
`417`	`417`
`418`		`-impl serde::ser::Serialize for boxed::Box<dyn Any + 'static> {`
	`418`	`+impl<'a> AsRef<Self> for dyn Any + 'a {`
	`419`	`+ fn as_ref(&self) -> &Self {`
	`420`	`+ self`
	`421`	`+ }`
	`422`	`+}`
	`423`	`+impl<'a> AsRef<Self> for dyn Any + Send + 'a {`
	`424`	`+ fn as_ref(&self) -> &Self {`
	`425`	`+ self`
	`426`	`+ }`
	`427`	`+}`
	`428`	`+`
	`429`	`+impl serde::ser::Serialize for dyn Any {`
`419`	`430`	`fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>`
`420`	`431`	`where`
`421`	`432`	`S: serde::Serializer,`
`422`	`433`	`{`
`423`		`- serialize(&self, serializer)`
	`434`	`+ serialize(self, serializer)`
`424`	`435`	`}`
`425`	`436`	`}`
`426`	`437`	`impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Any + 'static> {`
`@@ -431,12 +442,12 @@ impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Any + 'static> {`
`431`	`442`	`<Box<dyn Any + 'static>>::deserialize(deserializer).map(\|x\| x.0)`
`432`	`443`	`}`
`433`	`444`	`}`
`434`		`-impl serde::ser::Serialize for boxed::Box<dyn Any + Send + 'static> {`
	`445`	`+impl serde::ser::Serialize for dyn Any + Send {`
`435`	`446`	`fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>`
`436`	`447`	`where`
`437`	`448`	`S: serde::Serializer,`
`438`	`449`	`{`
`439`		`- serialize(&self, serializer)`
	`450`	`+ serialize(self, serializer)`
`440`	`451`	`}`
`441`	`452`	`}`
`442`	`453`	`impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Any + Send + 'static> {`
`@@ -484,6 +495,17 @@ impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Any + Send + 'static> {`
`484`	`495`	`pub trait Error: error::Error + Serialize + Deserialize {}`
`485`	`496`	`impl<T: ?Sized> Error for T where T: error::Error + Serialize + Deserialize {}`
`486`	`497`
	`498`	`+impl<'a> AsRef<Self> for dyn Error + 'a {`
	`499`	`+ fn as_ref(&self) -> &Self {`
	`500`	`+ self`
	`501`	`+ }`
	`502`	`+}`
	`503`	`+impl<'a> AsRef<Self> for dyn Error + Send + 'a {`
	`504`	`+ fn as_ref(&self) -> &Self {`
	`505`	`+ self`
	`506`	`+ }`
	`507`	`+}`
	`508`	`+`
`487`	`509`	`#[allow(clippy::use_self)]`
`488`	`510`	`impl<'a, E: error::Error + Serialize + Deserialize + 'a> From<E> for Box<dyn Error + 'a> {`
`489`	`511`	`fn from(err: E) -> Self {`
`@@ -497,12 +519,12 @@ impl<'a, E: error::Error + Serialize + Deserialize + 'a> From<E> for boxed::Box<`
`497`	`519`	`}`
`498`	`520`	`}`
`499`	`521`
`500`		`-impl serde::ser::Serialize for boxed::Box<dyn Error + 'static> {`
	`522`	`+impl serde::ser::Serialize for dyn Error {`
`501`	`523`	`fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>`
`502`	`524`	`where`
`503`	`525`	`S: serde::Serializer,`
`504`	`526`	`{`
`505`		`- serialize(&self, serializer)`
	`527`	`+ serialize(self, serializer)`
`506`	`528`	`}`
`507`	`529`	`}`
`508`	`530`	`impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Error + 'static> {`
`@@ -513,12 +535,12 @@ impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Error + 'static> {`
`513`	`535`	`<Box<dyn Error + 'static>>::deserialize(deserializer).map(\|x\| x.0)`
`514`	`536`	`}`
`515`	`537`	`}`
`516`		`-impl serde::ser::Serialize for boxed::Box<dyn Error + Send + 'static> {`
	`538`	`+impl serde::ser::Serialize for dyn Error + Send {`
`517`	`539`	`fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>`
`518`	`540`	`where`
`519`	`541`	`S: serde::Serializer,`
`520`	`542`	`{`
`521`		`- serialize(&self, serializer)`
	`543`	`+ serialize(self, serializer)`
`522`	`544`	`}`
`523`	`545`	`}`
`524`	`546`	`impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Error + Send + 'static> {`
`@@ -555,12 +577,23 @@ impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Error + Send + 'static>`
`555`	`577`	`pub trait Display: fmt::Display + Serialize + Deserialize {}`
`556`	`578`	`impl<T: ?Sized> Display for T where T: fmt::Display + Serialize + Deserialize {}`
`557`	`579`
`558`		`-impl serde::ser::Serialize for boxed::Box<dyn Display + 'static> {`
	`580`	`+impl<'a> AsRef<Self> for dyn Display + 'a {`
	`581`	`+ fn as_ref(&self) -> &Self {`
	`582`	`+ self`
	`583`	`+ }`
	`584`	`+}`
	`585`	`+impl<'a> AsRef<Self> for dyn Display + Send + 'a {`
	`586`	`+ fn as_ref(&self) -> &Self {`
	`587`	`+ self`
	`588`	`+ }`
	`589`	`+}`
	`590`	`+`
	`591`	`+impl serde::ser::Serialize for dyn Display {`
`559`	`592`	`fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>`
`560`	`593`	`where`
`561`	`594`	`S: serde::Serializer,`
`562`	`595`	`{`
`563`		`- serialize(&self, serializer)`
	`596`	`+ serialize(self, serializer)`
`564`	`597`	`}`
`565`	`598`	`}`
`566`	`599`	`impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Display + 'static> {`
`@@ -571,12 +604,12 @@ impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Display + 'static> {`
`571`	`604`	`<Box<dyn Display + 'static>>::deserialize(deserializer).map(\|x\| x.0)`
`572`	`605`	`}`
`573`	`606`	`}`
`574`		`-impl serde::ser::Serialize for boxed::Box<dyn Display + Send + 'static> {`
	`607`	`+impl serde::ser::Serialize for dyn Display + Send {`
`575`	`608`	`fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>`
`576`	`609`	`where`
`577`	`610`	`S: serde::Serializer,`
`578`	`611`	`{`
`579`		`- serialize(&self, serializer)`
	`612`	`+ serialize(self, serializer)`
`580`	`613`	`}`
`581`	`614`	`}`
`582`	`615`	`impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Display + Send + 'static> {`
`@@ -613,12 +646,23 @@ impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Display + Send + 'stati`
`613`	`646`	`pub trait Debug: fmt::Debug + Serialize + Deserialize {}`
`614`	`647`	`impl<T: ?Sized> Debug for T where T: fmt::Debug + Serialize + Deserialize {}`
`615`	`648`
`616`		`-impl serde::ser::Serialize for boxed::Box<dyn Debug + 'static> {`
	`649`	`+impl<'a> AsRef<Self> for dyn Debug + 'a {`
	`650`	`+ fn as_ref(&self) -> &Self {`
	`651`	`+ self`
	`652`	`+ }`
	`653`	`+}`
	`654`	`+impl<'a> AsRef<Self> for dyn Debug + Send + 'a {`
	`655`	`+ fn as_ref(&self) -> &Self {`
	`656`	`+ self`
	`657`	`+ }`
	`658`	`+}`
	`659`	`+`
	`660`	`+impl serde::ser::Serialize for dyn Debug {`
`617`	`661`	`fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>`
`618`	`662`	`where`
`619`	`663`	`S: serde::Serializer,`
`620`	`664`	`{`
`621`		`- serialize(&self, serializer)`
	`665`	`+ serialize(self, serializer)`
`622`	`666`	`}`
`623`	`667`	`}`
`624`	`668`	`impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Debug + 'static> {`
`@@ -629,12 +673,12 @@ impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Debug + 'static> {`
`629`	`673`	`<Box<dyn Debug + 'static>>::deserialize(deserializer).map(\|x\| x.0)`
`630`	`674`	`}`
`631`	`675`	`}`
`632`		`-impl serde::ser::Serialize for boxed::Box<dyn Debug + Send + 'static> {`
	`676`	`+impl serde::ser::Serialize for dyn Debug + Send {`
`633`	`677`	`fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>`
`634`	`678`	`where`
`635`	`679`	`S: serde::Serializer,`
`636`	`680`	`{`
`637`		`- serialize(&self, serializer)`
	`681`	`+ serialize(self, serializer)`
`638`	`682`	`}`
`639`	`683`	`}`
`640`	`684`	`impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Debug + Send + 'static> {`
`@@ -652,14 +696,23 @@ impl<'de> serde::de::Deserialize<'de> for boxed::Box<dyn Debug + Send + 'static>`
`652`	`696`	`pub trait FnOnce<Args>: ops::FnOnce<Args> + Serialize + Deserialize {}`
`653`	`697`	`impl<T: ?Sized, Args> FnOnce<Args> for T where T: ops::FnOnce<Args> + Serialize + Deserialize {}`
`654`	`698`
`655`		`-impl<Args: 'static, Output: 'static> serde::ser::Serialize`
`656`		`- for boxed::Box<dyn FnOnce<Args, Output = Output> + 'static>`
`657`		`-{`
	`699`	`+impl<'a, Args, Output> AsRef<Self> for dyn FnOnce<Args, Output = Output> + 'a {`
	`700`	`+ fn as_ref(&self) -> &Self {`
	`701`	`+ self`
	`702`	`+ }`
	`703`	`+}`
	`704`	`+impl<'a, Args, Output> AsRef<Self> for dyn FnOnce<Args, Output = Output> + Send + 'a {`
	`705`	`+ fn as_ref(&self) -> &Self {`
	`706`	`+ self`
	`707`	`+ }`
	`708`	`+}`
	`709`	`+`
	`710`	`+impl<Args: 'static, Output: 'static> serde::ser::Serialize for dyn FnOnce<Args, Output = Output> {`
`658`	`711`	`fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>`
`659`	`712`	`where`
`660`	`713`	`S: serde::Serializer,`
`661`	`714`	`{`
`662`		`- serialize(&self, serializer)`
	`715`	`+ serialize(self, serializer)`
`663`	`716`	`}`
`664`	`717`	`}`
`665`	`718`	`impl<'de, Args: 'static, Output: 'static> serde::de::Deserialize<'de>`
`@@ -673,13 +726,13 @@ impl<'de, Args: 'static, Output: 'static> serde::de::Deserialize<'de>`
`673`	`726`	`}`
`674`	`727`	`}`
`675`	`728`	`impl<Args: 'static, Output: 'static> serde::ser::Serialize`
`676`		`- for boxed::Box<dyn FnOnce<Args, Output = Output> + Send + 'static>`
	`729`	`+ for dyn FnOnce<Args, Output = Output> + Send`
`677`	`730`	`{`
`678`	`731`	`fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>`
`679`	`732`	`where`
`680`	`733`	`S: serde::Serializer,`
`681`	`734`	`{`
`682`		`- serialize(&self, serializer)`
	`735`	`+ serialize(self, serializer)`
`683`	`736`	`}`
`684`	`737`	`}`
`685`	`738`	`impl<'de, Args: 'static, Output: 'static> serde::de::Deserialize<'de>`
`@@ -700,14 +753,23 @@ impl<'de, Args: 'static, Output: 'static> serde::de::Deserialize<'de>`
`700`	`753`	`pub trait FnMut<Args>: ops::FnMut<Args> + Serialize + Deserialize {}`
`701`	`754`	`impl<T: ?Sized, Args> FnMut<Args> for T where T: ops::FnMut<Args> + Serialize + Deserialize {}`
`702`	`755`
`703`		`-impl<Args: 'static, Output: 'static> serde::ser::Serialize`
`704`		`- for boxed::Box<dyn FnMut<Args, Output = Output> + 'static>`
`705`		`-{`
	`756`	`+impl<'a, Args, Output> AsRef<Self> for dyn FnMut<Args, Output = Output> + 'a {`
	`757`	`+ fn as_ref(&self) -> &Self {`
	`758`	`+ self`
	`759`	`+ }`
	`760`	`+}`
	`761`	`+impl<'a, Args, Output> AsRef<Self> for dyn FnMut<Args, Output = Output> + Send + 'a {`
	`762`	`+ fn as_ref(&self) -> &Self {`
	`763`	`+ self`
	`764`	`+ }`
	`765`	`+}`
	`766`	`+`
	`767`	`+impl<Args: 'static, Output: 'static> serde::ser::Serialize for dyn FnMut<Args, Output = Output> {`
`706`	`768`	`fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>`
`707`	`769`	`where`
`708`	`770`	`S: serde::Serializer,`
`709`	`771`	`{`
`710`		`- serialize(&self, serializer)`
	`772`	`+ serialize(self, serializer)`
`711`	`773`	`}`
`712`	`774`	`}`
`713`	`775`	`impl<'de, Args: 'static, Output: 'static> serde::de::Deserialize<'de>`
`@@ -721,13 +783,13 @@ impl<'de, Args: 'static, Output: 'static> serde::de::Deserialize<'de>`
`721`	`783`	`}`
`722`	`784`	`}`
`723`	`785`	`impl<Args: 'static, Output: 'static> serde::ser::Serialize`
`724`		`- for boxed::Box<dyn FnMut<Args, Output = Output> + Send + 'static>`
	`786`	`+ for dyn FnMut<Args, Output = Output> + Send`
`725`	`787`	`{`
`726`	`788`	`fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>`
`727`	`789`	`where`
`728`	`790`	`S: serde::Serializer,`
`729`	`791`	`{`
`730`		`- serialize(&self, serializer)`
	`792`	`+ serialize(self, serializer)`
`731`	`793`	`}`
`732`	`794`	`}`
`733`	`795`	`impl<'de, Args: 'static, Output: 'static> serde::de::Deserialize<'de>`
`@@ -748,14 +810,23 @@ impl<'de, Args: 'static, Output: 'static> serde::de::Deserialize<'de>`
`748`	`810`	`pub trait Fn<Args>: ops::Fn<Args> + Serialize + Deserialize {}`
`749`	`811`	`impl<T: ?Sized, Args> Fn<Args> for T where T: ops::Fn<Args> + Serialize + Deserialize {}`
`750`	`812`
`751`		`-impl<Args: 'static, Output: 'static> serde::ser::Serialize`
`752`		`- for boxed::Box<dyn Fn<Args, Output = Output> + 'static>`
`753`		`-{`
	`813`	`+impl<'a, Args, Output> AsRef<Self> for dyn Fn<Args, Output = Output> + 'a {`
	`814`	`+ fn as_ref(&self) -> &Self {`
	`815`	`+ self`
	`816`	`+ }`
	`817`	`+}`
	`818`	`+impl<'a, Args, Output> AsRef<Self> for dyn Fn<Args, Output = Output> + Send + 'a {`
	`819`	`+ fn as_ref(&self) -> &Self {`
	`820`	`+ self`
	`821`	`+ }`
	`822`	`+}`
	`823`	`+`
	`824`	`+impl<Args: 'static, Output: 'static> serde::ser::Serialize for dyn Fn<Args, Output = Output> {`
`754`	`825`	`fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>`
`755`	`826`	`where`
`756`	`827`	`S: serde::Serializer,`
`757`	`828`	`{`
`758`		`- serialize(&self, serializer)`
	`829`	`+ serialize(self, serializer)`
`759`	`830`	`}`
`760`	`831`	`}`
`761`	`832`	`impl<'de, Args: 'static, Output: 'static> serde::de::Deserialize<'de>`
`@@ -769,13 +840,13 @@ impl<'de, Args: 'static, Output: 'static> serde::de::Deserialize<'de>`
`769`	`840`	`}`
`770`	`841`	`}`
`771`	`842`	`impl<Args: 'static, Output: 'static> serde::ser::Serialize`
`772`		`- for boxed::Box<dyn Fn<Args, Output = Output> + Send + 'static>`
	`843`	`+ for dyn Fn<Args, Output = Output> + Send`
`773`	`844`	`{`
`774`	`845`	`fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>`
`775`	`846`	`where`
`776`	`847`	`S: serde::Serializer,`
`777`	`848`	`{`
`778`		`- serialize(&self, serializer)`
	`849`	`+ serialize(self, serializer)`
`779`	`850`	`}`
`780`	`851`	`}`
`781`	`852`	`impl<'de, Args: 'static, Output: 'static> serde::de::Deserialize<'de>`