IArray: avoid heap allocation if there is only one element

src/array.rs

@@ -13,6 +13,8 @@ pub enum IArray<T: ImplicitClone + 'static> {
     Static(&'static [T]),
     /// A reference counted slice.
     Rc(Rc<[T]>),
+    /// A single element.
+    Single([T; 1]),
 }
 
 // TODO add insta tests
@@ -21,6 +23,7 @@ impl<T: fmt::Debug + ImplicitClone + 'static> fmt::Debug for IArray<T> {
         match self {
             Self::Static(a) => a.fmt(f),
             Self::Rc(a) => a.fmt(f),
+            Self::Single(x) => x.fmt(f),
         }
     }
 }
@@ -30,6 +33,7 @@ impl<T: ImplicitClone + 'static> Clone for IArray<T> {
         match self {
             Self::Static(a) => Self::Static(a),
             Self::Rc(a) => Self::Rc(a.clone()),
+            Self::Single(x) => Self::Single(x.clone()),
         }
     }
 }
@@ -67,6 +71,18 @@ impl<T: ImplicitClone + 'static> From<Rc<[T]>> for IArray<T> {
     }
 }
 
+impl<T: ImplicitClone + 'static> From<T> for IArray<T> {
+    fn from(x: T) -> IArray<T> {
+        IArray::Single([x])
+    }
+}
+
+impl<T: ImplicitClone + 'static> From<[T; 1]> for IArray<T> {
+    fn from(a: [T; 1]) -> IArray<T> {
+        IArray::Single(a)
+    }
+}
+
 impl<T: ImplicitClone + 'static> IArray<T> {
     /// Returns an iterator over the slice.
     ///
@@ -87,6 +103,7 @@ impl<T: ImplicitClone + 'static> IArray<T> {
         match self {
             Self::Static(a) => a.iter().cloned(),
             Self::Rc(a) => a.iter().cloned(),
+            Self::Single(a) => a.iter().cloned(),
         }
     }
 
@@ -105,6 +122,7 @@ impl<T: ImplicitClone + 'static> IArray<T> {
         match self {
             Self::Static(a) => a.len(),
             Self::Rc(a) => a.len(),
+            Self::Single(_) => 1,
         }
     }
 
@@ -125,6 +143,7 @@ impl<T: ImplicitClone + 'static> IArray<T> {
         match self {
             Self::Static(a) => a.is_empty(),
             Self::Rc(a) => a.is_empty(),
+            Self::Single(_) => false,
         }
     }
 
@@ -145,6 +164,7 @@ impl<T: ImplicitClone + 'static> IArray<T> {
         match self {
             Self::Static(a) => a,
             Self::Rc(a) => a,
+            Self::Single(a) => a,
         }
     }
 
@@ -163,6 +183,8 @@ impl<T: ImplicitClone + 'static> IArray<T> {
         match self {
             Self::Static(a) => a.get(index).cloned(),
             Self::Rc(a) => a.get(index).cloned(),
+            Self::Single(a) if index == 0 => Some(a[0].clone()),
+            Self::Single(_) => None,
         }
     }
 
@@ -194,7 +216,7 @@ impl<T: ImplicitClone + 'static> IArray<T> {
     pub fn get_mut(&mut self) -> Option<&mut [T]> {
         match self {
             Self::Rc(ref mut rc) => Rc::get_mut(rc),
-            Self::Static(_) => None,
+            Self::Static(_) | Self::Single(_) => None,
         }
     }
 
@@ -238,6 +260,13 @@ impl<T: ImplicitClone + 'static> IArray<T> {
                     _ => unreachable!(),
                 }
             }
+            Self::Single(slice) => {
+                *self = Self::Rc(slice.iter().cloned().collect());
+                match self {
+                    Self::Rc(rc) => Rc::get_mut(rc).unwrap(),
+                    _ => unreachable!(),
+                }
+            }
         }
     }
 }
@@ -250,6 +279,8 @@ where
         match self {
             Self::Static(a) => a.eq(other),
             Self::Rc(a) => a.eq(*other),
+            Self::Single(a) if N == 1 => a[0].eq(&other[0]),
+            Self::Single(_) => false,
         }
     }
 }
@@ -262,6 +293,8 @@ where
         match self {
             Self::Static(a) => a.eq(other),
             Self::Rc(a) => a.eq(other),
+            Self::Single(a) if N == 1 => a[0].eq(&other[0]),
+            Self::Single(_) => false,
         }
     }
 }
@@ -274,6 +307,7 @@ where
         match self {
             Self::Static(a) => a.eq(&other),
             Self::Rc(a) => a.eq(other),
+            Self::Single(a) => a.eq(other),
         }
     }
 }
@@ -286,6 +320,7 @@ where
         match self {
             Self::Static(a) => a.eq(other),
             Self::Rc(a) => a.eq(*other),
+            Self::Single(a) => a.eq(*other),
         }
     }
 }
@@ -356,4 +391,13 @@ mod test_array {
         const _ARRAY_F32: IArray<f32> = IArray::Static(&[]);
         const _ARRAY_F64: IArray<f64> = IArray::Static(&[]);
     }
+
+    #[test]
+    fn from() {
+        let _array: IArray<u32> = IArray::from(&[1, 2, 3][..]);
+        let _array: IArray<u32> = IArray::from(vec![1, 2, 3]);
+        let _array: IArray<u32> = IArray::from(Rc::from(vec![1, 2, 3]));
+        let _array: IArray<u32> = IArray::from(1);
+        let _array: IArray<u32> = IArray::from([1]);
+    }
 }