Merge pull request #233 from chmp/feature/remove-refs-and-sized

Remove refs and sized

serde_arrow/src/arrow2_impl/api.rs

@@ -52,10 +52,7 @@ use crate::{
 /// # }
 /// ```
 ///
-pub fn to_arrow2<T>(fields: &[ArrowField], items: &T) -> Result<Vec<Box<dyn Array>>>
-where
-    T: Serialize + ?Sized,
-{
+pub fn to_arrow2<T: Serialize>(fields: &[ArrowField], items: T) -> Result<Vec<Box<dyn Array>>> {
     let builder = ArrayBuilder::from_arrow2(fields)?;
     items
         .serialize(Serializer::new(builder))?

serde_arrow/src/arrow2_impl/schema.rs

@@ -43,18 +43,15 @@ impl Sealed for Vec<ArrowField> {}
 /// Schema support for `Vec<arrow2::datatype::Field>` (*requires one of the
 /// `arrow2-*` features*)
 impl SchemaLike for Vec<ArrowField> {
-    fn from_value<T: serde::Serialize + ?Sized>(value: &T) -> Result<Self> {
+    fn from_value<T: serde::Serialize>(value: T) -> Result<Self> {
         SerdeArrowSchema::from_value(value)?.try_into()
     }
 
     fn from_type<'de, T: serde::Deserialize<'de>>(options: TracingOptions) -> Result<Self> {
         SerdeArrowSchema::from_type::<T>(options)?.try_into()
     }
 
-    fn from_samples<T: serde::Serialize + ?Sized>(
-        samples: &T,
-        options: TracingOptions,
-    ) -> Result<Self> {
+    fn from_samples<T: serde::Serialize>(samples: T, options: TracingOptions) -> Result<Self> {
         SerdeArrowSchema::from_samples(samples, options)?.try_into()
     }
 }

serde_arrow/src/arrow_impl/api.rs

@@ -57,7 +57,7 @@ use super::type_support::fields_from_field_refs;
 /// # }
 /// ```
 ///
-pub fn to_arrow<T: Serialize + ?Sized>(fields: &[FieldRef], items: &T) -> Result<Vec<ArrayRef>> {
+pub fn to_arrow<T: Serialize>(fields: &[FieldRef], items: T) -> Result<Vec<ArrayRef>> {
     let builder = ArrayBuilder::from_arrow(fields)?;
     items
         .serialize(Serializer::new(builder))?
@@ -138,10 +138,7 @@ where
 /// # Ok(())
 /// # }
 /// ```
-pub fn to_record_batch<T: Serialize + ?Sized>(
-    fields: &[FieldRef],
-    items: &T,
-) -> Result<RecordBatch> {
+pub fn to_record_batch<T: Serialize>(fields: &[FieldRef], items: &T) -> Result<RecordBatch> {
     let builder = ArrayBuilder::from_arrow(fields)?;
     items
         .serialize(Serializer::new(builder))?

serde_arrow/src/arrow_impl/schema.rs

@@ -1,5 +1,7 @@
 use std::sync::Arc;
 
+use serde::{Deserialize, Serialize};
+
 use crate::{
     _impl::arrow::datatypes::{
         DataType as ArrowDataType, Field as ArrowField, FieldRef, TimeUnit as ArrowTimeUnit,
@@ -76,18 +78,15 @@ impl Sealed for Vec<ArrowField> {}
 /// Schema support for `Vec<arrow::datatype::Field>` (*requires one of the
 /// `arrow-*` features*)
 impl SchemaLike for Vec<ArrowField> {
-    fn from_value<T: serde::Serialize + ?Sized>(value: &T) -> Result<Self> {
+    fn from_value<T: Serialize>(value: T) -> Result<Self> {
         SerdeArrowSchema::from_value(value)?.try_into()
     }
 
-    fn from_type<'de, T: serde::Deserialize<'de>>(options: TracingOptions) -> Result<Self> {
+    fn from_type<'de, T: Deserialize<'de>>(options: TracingOptions) -> Result<Self> {
         SerdeArrowSchema::from_type::<T>(options)?.try_into()
     }
 
-    fn from_samples<T: serde::Serialize + ?Sized>(
-        samples: &T,
-        options: TracingOptions,
-    ) -> Result<Self> {
+    fn from_samples<T: Serialize>(samples: T, options: TracingOptions) -> Result<Self> {
         SerdeArrowSchema::from_samples(samples, options)?.try_into()
     }
 }
@@ -97,18 +96,15 @@ impl Sealed for Vec<FieldRef> {}
 /// Schema support for `Vec<arrow::datatype::FieldRef>` (*requires one of the
 /// `arrow-*` features*)
 impl SchemaLike for Vec<FieldRef> {
-    fn from_value<T: serde::Serialize + ?Sized>(value: &T) -> Result<Self> {
+    fn from_value<T: Serialize>(value: T) -> Result<Self> {
         SerdeArrowSchema::from_value(value)?.try_into()
     }
 
-    fn from_type<'de, T: serde::Deserialize<'de>>(options: TracingOptions) -> Result<Self> {
+    fn from_type<'de, T: Deserialize<'de>>(options: TracingOptions) -> Result<Self> {
         SerdeArrowSchema::from_type::<T>(options)?.try_into()
     }
 
-    fn from_samples<T: serde::Serialize + ?Sized>(
-        samples: &T,
-        options: TracingOptions,
-    ) -> Result<Self> {
+    fn from_samples<T: Serialize>(samples: T, options: TracingOptions) -> Result<Self> {
         SerdeArrowSchema::from_samples(samples, options)?.try_into()
     }
 }

serde_arrow/src/internal/array_builder.rs

@@ -73,13 +73,13 @@ impl std::fmt::Debug for ArrayBuilder {
 impl ArrayBuilder {
     /// Add a single record to the arrays
     ///
-    pub fn push<T: Serialize + ?Sized>(&mut self, item: &T) -> Result<()> {
+    pub fn push<T: Serialize>(&mut self, item: T) -> Result<()> {
         self.builder.push(item)
     }
 
     /// Add multiple records to the arrays
     ///
-    pub fn extend<T: Serialize + ?Sized>(&mut self, items: &T) -> Result<()> {
+    pub fn extend<T: Serialize>(&mut self, items: T) -> Result<()> {
         self.builder.extend(items)
     }
 }

serde_arrow/src/internal/schema/from_samples/mod.rs

@@ -18,10 +18,7 @@ use super::tracer::{
 };
 
 impl Tracer {
-    pub fn from_samples<T: Serialize + ?Sized>(
-        samples: &T,
-        options: TracingOptions,
-    ) -> Result<Self> {
+    pub fn from_samples<T: Serialize>(samples: T, options: TracingOptions) -> Result<Self> {
         let options = options.tracing_mode(TracingMode::FromSamples);
         let mut tracer = Tracer::new(String::from("$"), String::from("$"), Arc::new(options));
         samples.serialize(OuterSequenceSerializer(&mut tracer))?;

serde_arrow/src/internal/schema/mod.rs

@@ -133,7 +133,7 @@ pub trait SchemaLike: Sized + Sealed {
     ///   fields, named `"key"` of integer type and named `"value"` of string
     ///   type
     ///
-    fn from_value<T: Serialize + ?Sized>(value: &T) -> Result<Self>;
+    fn from_value<T: Serialize>(value: T) -> Result<Self>;
 
     /// Determine the schema from the given record type. See [`TracingOptions`] for customization
     /// options.
@@ -271,7 +271,7 @@ pub trait SchemaLike: Sized + Sealed {
     /// # #[cfg(not(has_arrow))]
     /// # fn main() { }
     /// ```
-    fn from_samples<T: Serialize + ?Sized>(samples: &T, options: TracingOptions) -> Result<Self>;
+    fn from_samples<T: Serialize>(samples: T, options: TracingOptions) -> Result<Self>;
 }
 
 /// A collection of fields as understood by `serde_arrow`
@@ -286,15 +286,15 @@ pub struct SerdeArrowSchema {
 impl Sealed for SerdeArrowSchema {}
 
 impl SchemaLike for SerdeArrowSchema {
-    fn from_value<T: Serialize + ?Sized>(value: &T) -> Result<Self> {
+    fn from_value<T: Serialize>(value: T) -> Result<Self> {
         value::transmute(value)
     }
 
     fn from_type<'de, T: Deserialize<'de>>(options: TracingOptions) -> Result<Self> {
         Tracer::from_type::<T>(options)?.to_schema()
     }
 
-    fn from_samples<T: Serialize + ?Sized>(samples: &T, options: TracingOptions) -> Result<Self> {
+    fn from_samples<T: Serialize>(samples: T, options: TracingOptions) -> Result<Self> {
         Tracer::from_samples(samples, options)?.to_schema()
     }
 }

serde_arrow/src/internal/serialization/outer_sequence_builder.rs

@@ -45,13 +45,13 @@ impl OuterSequenceBuilder {
     }
 
     /// Extend the builder with a sequence of items
-    pub fn extend<T: Serialize + ?Sized>(&mut self, value: &T) -> Result<()> {
+    pub fn extend<T: Serialize>(&mut self, value: T) -> Result<()> {
         value.serialize(Mut(self))
     }
 
     /// Push a single item into the builder
-    pub fn push<T: Serialize + ?Sized>(&mut self, value: &T) -> Result<()> {
-        self.element(value)
+    pub fn push<T: Serialize>(&mut self, value: T) -> Result<()> {
+        self.element(&value)
     }
 }
 

serde_arrow/src/internal/utils/value.rs

@@ -82,7 +82,7 @@ impl std::hash::Hash for HashF64 {
     }
 }
 
-pub fn transmute<S: Serialize + ?Sized, T: DeserializeOwned>(value: &S) -> Result<T> {
+pub fn transmute<S: Serialize, T: DeserializeOwned>(value: S) -> Result<T> {
     let value = value.serialize(ValueSerializer)?;
     T::deserialize(ValueDeserializer::new(&value))
 }