Remove sized bounds where appropriate (#101)

* Remove sized bounds where appropriate

* Make bounds compatible with stable

src/serde/mod.rs

@@ -33,8 +33,9 @@ mod writer;
 /// If this returns an `SerializeError` (other than SizeLimit), assume that the
 /// writer is in an invalid state, as writing could bail out in the middle of
 /// serializing.
-pub fn serialize_into<W, T>(writer: &mut W, value: &T, size_limit: SizeLimit) -> SerializeResult<()>
-    where W: Write, T: serde::Serialize,
+pub fn serialize_into<W: ?Sized, T: ?Sized>(writer: &mut W, value: &T, size_limit: SizeLimit) -> SerializeResult<()>
+    where W: Write, 
+          T: serde::Serialize,
 {
     match size_limit {
         SizeLimit::Infinite => { }
@@ -52,8 +53,8 @@ pub fn serialize_into<W, T>(writer: &mut W, value: &T, size_limit: SizeLimit) ->
 ///
 /// If the serialization would take more bytes than allowed by `size_limit`,
 /// an error is returned.
-pub fn serialize<T>(value: &T, size_limit: SizeLimit) -> SerializeResult<Vec<u8>>
-    where T: serde::Serialize,
+pub fn serialize<T: ?Sized>(value: &T, size_limit: SizeLimit) -> SerializeResult<Vec<u8>>
+    where T: serde::Serialize
 {
     // Since we are putting values directly into a vector, we can do size
     // computation out here and pre-allocate a buffer of *exactly*
@@ -77,7 +78,9 @@ pub fn serialize<T>(value: &T, size_limit: SizeLimit) -> SerializeResult<Vec<u8>
 ///
 /// This is used internally as part of the check for encode_into, but it can
 /// be useful for preallocating buffers if thats your style.
-pub fn serialized_size<T: serde::Serialize>(value: &T) -> u64 {
+pub fn serialized_size<T: ?Sized>(value: &T) -> u64 
+    where T: serde::Serialize
+{
     use std::u64::MAX;
     let mut size_checker = SizeChecker::new(MAX);
     value.serialize(&mut size_checker).ok();
@@ -89,7 +92,9 @@ pub fn serialized_size<T: serde::Serialize>(value: &T) -> u64 {
 ///
 /// If it can be serialized in `max` or fewer bytes, that number will be returned
 /// inside `Some`.  If it goes over bounds, then None is returned.
-pub fn serialized_size_bounded<T: serde::Serialize>(value: &T, max: u64) -> Option<u64> {
+pub fn serialized_size_bounded<T: ?Sized>(value: &T, max: u64) -> Option<u64> 
+    where T: serde::Serialize
+{
     let mut size_checker = SizeChecker::new(max);
     value.serialize(&mut size_checker).ok().map(|_| size_checker.written)
 }
@@ -103,7 +108,7 @@ pub fn serialized_size_bounded<T: serde::Serialize>(value: &T, max: u64) -> Opti
 /// If this returns an `DeserializeError`, assume that the buffer that you passed
 /// in is in an invalid state, as the error could be returned during any point
 /// in the reading.
-pub fn deserialize_from<R, T>(reader: &mut R, size_limit: SizeLimit) -> DeserializeResult<T>
+pub fn deserialize_from<R: ?Sized, T>(reader: &mut R, size_limit: SizeLimit) -> DeserializeResult<T>
     where R: Read,
           T: serde::Deserialize,
 {