Impl 'IntoCollection' for '[T; N]'.

This introduces const generics into the codebase for a more efficient,
clone-free 'IntoCollection' for arrays.

core/codegen/tests/route-format.rs

@@ -89,10 +89,10 @@ fn test_custom_formats() {
 
     let client = Client::debug(rocket).unwrap();
 
-    let foo_a = Accept::new(&[MediaType::new("application", "foo").into()]);
+    let foo_a = Accept::new([MediaType::new("application", "foo").into()]);
     let foo_ct = ContentType::new("application", "foo");
     let bar_baz_ct = ContentType::new("bar", "baz");
-    let bar_baz_a = Accept::new(&[MediaType::new("bar", "baz").into()]);
+    let bar_baz_a = Accept::new([MediaType::new("bar", "baz").into()]);
 
     let response = client.get("/").header(foo_a).dispatch();
     assert_eq!(response.into_string().unwrap(), "get_foo");

core/http/src/ext.rs

@@ -46,35 +46,33 @@ impl<T> IntoCollection<T> for Vec<T> {
     }
 }
 
-macro_rules! impl_for_slice {
+impl<T: Clone> IntoCollection<T> for &[T] {
-    ($($size:tt)*) => (
+    #[inline(always)]
-        impl<T: Clone> IntoCollection<T> for &[T $($size)*] {
+    fn into_collection<A: Array<Item=T>>(self) -> SmallVec<A> {
-            #[inline(always)]
+        self.iter().cloned().collect()
-            fn into_collection<A: Array<Item=T>>(self) -> SmallVec<A> {
+    }
-                self.iter().cloned().collect()
-            }
 
-            #[inline]
+    #[inline]
-            fn mapped<U, F, A: Array<Item=U>>(self, f: F) -> SmallVec<A>
+    fn mapped<U, F, A: Array<Item=U>>(self, f: F) -> SmallVec<A>
-                where F: FnMut(T) -> U
+        where F: FnMut(T) -> U
-            {
+    {
-                self.iter().cloned().map(f).collect()
+        self.iter().cloned().map(f).collect()
-            }
+    }
-        }
-    )
 }
 
-impl_for_slice!();
+impl<T, const N: usize> IntoCollection<T> for [T; N] {
-impl_for_slice!(; 1);
+    #[inline(always)]
-impl_for_slice!(; 2);
+    fn into_collection<A: Array<Item=T>>(self) -> SmallVec<A> {
-impl_for_slice!(; 3);
+        std::array::IntoIter::new(self).collect()
-impl_for_slice!(; 4);
+    }
-impl_for_slice!(; 5);
+
-impl_for_slice!(; 6);
+    #[inline]
-impl_for_slice!(; 7);
+    fn mapped<U, F, A: Array<Item=U>>(self, f: F) -> SmallVec<A>
-impl_for_slice!(; 8);
+        where F: FnMut(T) -> U
-impl_for_slice!(; 9);
+    {
-impl_for_slice!(; 10);
+        std::array::IntoIter::new(self).map(f).collect()
+    }
+}
 
 use std::borrow::Cow;
 

core/http/src/header/accept.rs

@@ -85,9 +85,10 @@ macro_rules! accept_constructor {
 impl Accept {
     /// Constructs a new `Accept` header from one or more media types.
     ///
-    /// The `items` parameter may be of type `QMediaType`, `&[QMediaType]`, or
+    /// The `items` parameter may be of type `QMediaType`, `[QMediaType]`,
-    /// `Vec<QMediaType>`. To prevent additional allocations, prefer to provide
+    /// `&[QMediaType]` or `Vec<QMediaType>`. To prevent additional allocations,
-    /// inputs of type `QMediaType` and `Vec<QMediaType>`.
+    /// prefer to provide inputs of type `QMediaType`, `[QMediaType]`, or
+    /// `Vec<QMediaType>`.
     ///
     /// # Example
     ///
@@ -100,8 +101,8 @@ impl Accept {
     /// let accept = Accept::new(json_then_html);
     /// assert_eq!(accept.preferred().media_type(), &MediaType::JSON);
     ///
-    /// // Construct an `Accept` via an `&[QMediaType]`.
+    /// // Construct an `Accept` via an `[QMediaType]`.
-    /// let accept = Accept::new(&[MediaType::JSON.into(), MediaType::HTML.into()]);
+    /// let accept = Accept::new([MediaType::JSON.into(), MediaType::HTML.into()]);
     /// assert_eq!(accept.preferred().media_type(), &MediaType::JSON);
     ///
     /// // Construct an `Accept` via a `QMediaType`.