chore(versionable): remove unneeded bounds in examples

utils/tfhe-versionable/examples/manual_impl.rs

@@ -2,11 +2,10 @@
 
 use std::convert::Infallible;
 
-use serde::de::DeserializeOwned;
 use serde::{Deserialize, Serialize};
 use tfhe_versionable::{Unversionize, UnversionizeError, Upgrade, Versionize, VersionizeOwned};
 
-struct MyStruct<T: Default> {
+struct MyStruct<T> {
     attr: T,
     builtin: u32,
 }
@@ -28,18 +27,18 @@ impl<T: Default> Upgrade<MyStruct<T>> for MyStructV0 {
 }
 
 #[derive(Serialize)]
-struct MyStructVersion<'vers, T: 'vers + Default + Versionize> {
+struct MyStructVersion<'vers, T: 'vers + Versionize> {
     attr: T::Versioned<'vers>,
     builtin: u32,
 }
 
 #[derive(Serialize, Deserialize)]
-struct MyStructVersionOwned<T: Default + VersionizeOwned> {
+struct MyStructVersionOwned<T: VersionizeOwned> {
     attr: T::VersionedOwned,
     builtin: u32,
 }
 
-impl<T: Default + Versionize + Serialize + DeserializeOwned> Versionize for MyStruct<T> {
+impl<T: Versionize + Serialize> Versionize for MyStruct<T> {
     type Versioned<'vers> = MyStructVersionsDispatch<'vers, T>
     where
         Self: 'vers;
@@ -53,7 +52,7 @@ impl<T: Default + Versionize + Serialize + DeserializeOwned> Versionize for MySt
     }
 }
 
-impl<T: Default + VersionizeOwned + Serialize + DeserializeOwned> VersionizeOwned for MyStruct<T> {
+impl<T: VersionizeOwned + Serialize + for<'de> Deserialize<'de>> VersionizeOwned for MyStruct<T> {
     type VersionedOwned = MyStructVersionsDispatchOwned<T>;
 
     fn versionize_owned(self) -> Self::VersionedOwned {
@@ -65,7 +64,7 @@ impl<T: Default + VersionizeOwned + Serialize + DeserializeOwned> VersionizeOwne
     }
 }
 
-impl<T: Default + VersionizeOwned + Unversionize + Serialize + DeserializeOwned> Unversionize
+impl<T: Unversionize + Serialize + for<'de> Deserialize<'de> + Default> Unversionize
     for MyStruct<T>
 {
     fn unversionize(versioned: Self::VersionedOwned) -> Result<Self, UnversionizeError> {
@@ -81,28 +80,80 @@ impl<T: Default + VersionizeOwned + Unversionize + Serialize + DeserializeOwned>
     }
 }
 
+// Since MyStructV0 is only composed of built-in types, it does not need recursive versioning and
+// can be used as its own "version type".
 #[derive(Serialize)]
 #[allow(dead_code)]
-enum MyStructVersionsDispatch<'vers, T: 'vers + Default + Versionize> {
+enum MyStructVersionsDispatch<'vers, T: 'vers + Versionize> {
     V0(MyStructV0),
     V1(MyStructVersion<'vers, T>),
 }
 
 #[derive(Serialize, Deserialize)]
-enum MyStructVersionsDispatchOwned<T: Default + VersionizeOwned> {
+enum MyStructVersionsDispatchOwned<T: VersionizeOwned> {
     V0(MyStructV0),
     V1(MyStructVersionOwned<T>),
 }
 
+mod v0 {
+    use serde::{Deserialize, Serialize};
+    use tfhe_versionable::{Unversionize, UnversionizeError, Versionize, VersionizeOwned};
+
+    #[derive(Serialize, Deserialize)]
+    pub(super) struct MyStruct {
+        pub(super) builtin: u32,
+    }
+
+    impl Versionize for MyStruct {
+        type Versioned<'vers> = MyStructVersionsDispatch;
+
+        fn versionize(&self) -> Self::Versioned<'_> {
+            let ver = MyStruct {
+                builtin: self.builtin,
+            };
+            MyStructVersionsDispatch::V0(ver)
+        }
+    }
+
+    impl VersionizeOwned for MyStruct {
+        type VersionedOwned = MyStructVersionsDispatchOwned;
+
+        fn versionize_owned(self) -> Self::VersionedOwned {
+            MyStructVersionsDispatchOwned::V0(self)
+        }
+    }
+
+    impl Unversionize for MyStruct {
+        fn unversionize(versioned: Self::VersionedOwned) -> Result<Self, UnversionizeError> {
+            match versioned {
+                MyStructVersionsDispatchOwned::V0(v0) => Ok(v0),
+            }
+        }
+    }
+
+    #[derive(Serialize)]
+    #[allow(dead_code)]
+    pub(super) enum MyStructVersionsDispatch {
+        V0(MyStruct),
+    }
+
+    #[derive(Serialize, Deserialize)]
+    pub(super) enum MyStructVersionsDispatchOwned {
+        V0(MyStruct),
+    }
+}
+
 fn main() {
-    let ms = MyStruct {
-        attr: 37u64,
-        builtin: 1234,
-    };
+    let value = 1234;
+    let ms = v0::MyStruct { builtin: value };
 
     let serialized = bincode::serialize(&ms.versionize()).unwrap();
 
-    let _unserialized = MyStruct::<u64>::unversionize(bincode::deserialize(&serialized).unwrap());
+    let unserialized =
+        MyStruct::<u64>::unversionize(bincode::deserialize(&serialized).unwrap()).unwrap();
+
+    assert_eq!(unserialized.builtin, value);
+    assert_eq!(unserialized.attr, u64::default());
 }
 
 #[test]

utils/tfhe-versionable/examples/recursive.rs

@@ -7,7 +7,7 @@ use tfhe_versionable::{Unversionize, Upgrade, Version, Versionize, VersionsDispa
 // The inner struct is independently versioned
 #[derive(Versionize)]
 #[versionize(MyStructInnerVersions)]
-struct MyStructInner<T: Default> {
+struct MyStructInner<T> {
     attr: T,
     builtin: u32,
 }
@@ -30,21 +30,21 @@ impl<T: Default> Upgrade<MyStructInner<T>> for MyStructInnerV0 {
 
 #[derive(VersionsDispatch)]
 #[allow(unused)]
-enum MyStructInnerVersions<T: Default> {
+enum MyStructInnerVersions<T> {
     V0(MyStructInnerV0),
     V1(MyStructInner<T>),
 }
 
 // An upgrade of the inner struct does not require an upgrade of the outer struct
 #[derive(Versionize)]
 #[versionize(MyStructVersions)]
-struct MyStruct<T: Default> {
+struct MyStruct<T> {
     inner: MyStructInner<T>,
 }
 
 #[derive(VersionsDispatch)]
 #[allow(unused)]
-enum MyStructVersions<T: Default> {
+enum MyStructVersions<T> {
     V0(MyStruct<T>),
 }
 

utils/tfhe-versionable/examples/simple.rs

@@ -8,7 +8,7 @@ use tfhe_versionable::{Unversionize, Upgrade, Version, Versionize, VersionsDispa
 #[derive(Versionize)]
 #[versionize(MyStructVersions)] // Link to the enum type that will holds all the versions of this
                                 // type
-struct MyStruct<T: Default> {
+struct MyStruct<T> {
     attr: T,
     builtin: u32,
 }
@@ -38,7 +38,7 @@ impl<T: Default> Upgrade<MyStruct<T>> for MyStructV0 {
 // This enum is not directly used but serves as a template to generate a new enum that will be
 // serialized. This allows recursive versioning.
 #[allow(unused)]
-enum MyStructVersions<T: Default> {
+enum MyStructVersions<T> {
     V0(MyStructV0),
     V1(MyStruct<T>),
 }

utils/tfhe-versionable/examples/upgrades.rs

@@ -34,7 +34,7 @@ mod v1 {
 
     #[derive(Serialize, Deserialize, Versionize)]
     #[versionize(MyStructVersions)]
-    pub struct MyStruct<T: Default>(pub u32, pub T);
+    pub struct MyStruct<T>(pub u32, pub T);
 
     mod backward_compat {
         use std::convert::Infallible;
@@ -56,7 +56,7 @@ mod v1 {
 
         #[derive(VersionsDispatch)]
         #[allow(unused)]
-        pub enum MyStructVersions<T: Default> {
+        pub enum MyStructVersions<T> {
             V0(MyStructV0),
             V1(MyStruct<T>),
         }
@@ -71,15 +71,15 @@ mod v2 {
 
     #[derive(Serialize, Deserialize, Versionize)]
     #[versionize(MyEnumVersions)]
-    pub enum MyEnum<T: Default> {
+    pub enum MyEnum<T> {
         Variant0,
         Variant1 { count: u64 },
         Variant2(T),
     }
 
     #[derive(Serialize, Deserialize, Versionize)]
     #[versionize(MyStructVersions)]
-    pub struct MyStruct<T: Default> {
+    pub struct MyStruct<T> {
         pub count: u32,
         pub attr: T,
     }
@@ -118,15 +118,15 @@ mod v2 {
 
         #[derive(VersionsDispatch)]
         #[allow(unused)]
-        pub enum MyStructVersions<T: Default> {
+        pub enum MyStructVersions<T> {
             V0(MyStructV0),
             V1(MyStructV1<T>),
             V2(MyStruct<T>),
         }
 
         #[derive(VersionsDispatch)]
         #[allow(unused)]
-        pub enum MyEnumVersions<T: Default> {
+        pub enum MyEnumVersions<T> {
             V0(MyEnum<T>),
         }
     }