Add schemars support (#219)

The implementation is based on
https://docs.rs/schemars/latest/src/schemars/json_schema_impls/arrayvec07.rs.html

Author: wojciech-graj

Cargo.toml

@@ -24,6 +24,8 @@ generic-array = { version = "1.1.1", optional = true, default-features = false }
 bin-proto = { version = "0.12.5", optional = true, default-features = false }
 # Provides `Format` implementations
 defmt = { version = "1.0", optional = true }
+# Provides `JsonSchema` implementations
+schemars = { version = "1.0", optional = true, default-features = false }
 
 
 [features]
@@ -82,12 +84,14 @@ experimental_write_impl = []
 # and thus a nightly compiler, but is only used in benchmarks.
 real_blackbox = ["criterion/real_blackbox"]
 
+schemars = ["dep:schemars", "alloc"]
+
 [package.metadata.docs.rs]
-features = ["alloc", "std", "grab_spare_slice", "latest_stable_rust", "serde", "borsh", "defmt", "bin-proto"]
+features = ["alloc", "std", "grab_spare_slice", "latest_stable_rust", "serde", "borsh", "defmt", "bin-proto", "schemars"]
 rustdoc-args = ["--cfg","docs_rs"]
 
 [package.metadata.playground]
-features = ["alloc", "std", "grab_spare_slice", "latest_stable_rust", "serde", "borsh"]
+features = ["alloc", "std", "grab_spare_slice", "latest_stable_rust", "serde", "borsh", "schemars"]
 
 [profile.dev]
 lto = "thin"

src/arrayvec.rs

@@ -362,6 +362,33 @@ where
   }
 }
 
+#[cfg(feature = "schemars")]
+#[cfg_attr(docs_rs, doc(cfg(feature = "schemars")))]
+impl<A> schemars::JsonSchema for ArrayVec<A>
+where
+  A: Array,
+  <A as Array>::Item: schemars::JsonSchema,
+{
+  fn schema_name() -> alloc::borrow::Cow<'static, str> {
+    alloc::format!(
+      "Array_up_to_size_{}_of_{}",
+      A::CAPACITY,
+      <A as Array>::Item::schema_name()
+    )
+    .into()
+  }
+
+  fn json_schema(
+    generator: &mut schemars::SchemaGenerator,
+  ) -> schemars::Schema {
+    schemars::json_schema!({
+        "type": "array",
+        "items": generator.subschema_for::<<A as Array>::Item>(),
+        "maxItems": A::CAPACITY
+    })
+  }
+}
+
 impl<A: Array> ArrayVec<A> {
   /// Move all values from `other` into this vec.
   ///
@@ -493,7 +520,7 @@ impl<A: Array> ArrayVec<A> {
   /// assert_eq!(av2.as_slice(), &[2, 3][..]);
   ///
   /// av.drain(..);
-  /// assert_eq!(av.as_slice(), &[]);
+  /// assert_eq!(av.as_slice(), &[] as &[i32]);
   /// ```
   #[inline]
   pub fn drain<R>(&mut self, range: R) -> ArrayVecDrain<'_, A::Item>
@@ -758,7 +785,7 @@ impl<A: Array> ArrayVec<A> {
   /// ```rust
   /// # use tinyvec::*;
   /// let mut av = array_vec!([i32; 2]);
-  /// assert_eq!(&av[..], []);
+  /// assert_eq!(&av[..], [] as [i32; 0]);
   /// av.push(1);
   /// assert_eq!(&av[..], [1]);
   /// av.push(2);
@@ -777,7 +804,7 @@ impl<A: Array> ArrayVec<A> {
   /// ```rust
   /// # use tinyvec::*;
   /// let mut av = array_vec!([i32; 2]);
-  /// assert_eq!(av.as_slice(), []);
+  /// assert_eq!(av.as_slice(), [] as [i32; 0]);
   /// assert_eq!(av.try_push(1), None);
   /// assert_eq!(&av[..], [1]);
   /// assert_eq!(av.try_push(2), None);
@@ -1090,7 +1117,7 @@ impl<A: Array> ArrayVec<A> {
   /// assert_eq!(av2.as_slice(), &[2, 3][..]);
   ///
   /// av.splice(.., None);
-  /// assert_eq!(av.as_slice(), &[]);
+  /// assert_eq!(av.as_slice(), &[] as &[i32]);
   /// ```
   #[inline]
   pub fn splice<R, I>(
@@ -1246,7 +1273,7 @@ impl<A> ArrayVec<A> {
   /// ```rust
   /// # use tinyvec::ArrayVec;
   /// let mut data = ArrayVec::from_array_empty([1, 2, 3, 4]);
-  /// assert_eq!(&data[..], &[]);
+  /// assert_eq!(&data[..], &[] as &[i32]);
   /// data.push(42);
   /// assert_eq!(&data[..], &[42]);
   /// ```

src/lib.rs

@@ -57,6 +57,8 @@
 //!   implementation.
 //! * `defmt` provides a `Format` implementation for all types, provided the
 //!   inner item also has an implementation.
+//! * `schemars` provides a `JsonSchema` implementation for [`TinyVec`] and
+//!   [`ArrayVec`] types, provided the inner item also has an implementation.
 //!
 //! ## API
 //! The general goal of the crate is that, as much as possible, the vecs here

src/slicevec.rs

@@ -143,7 +143,7 @@ impl<'s, T> SliceVec<'s, T> {
   /// assert_eq!(drained_values.as_slice(), &[7, 8][..]);
   ///
   /// sv.drain(..);
-  /// assert_eq!(sv.as_slice(), &[]);
+  /// assert_eq!(sv.as_slice(), &[] as &[i32]);
   /// ```
   #[inline]
   pub fn drain<'p, R: RangeBounds<usize>>(
@@ -345,7 +345,7 @@ impl<'s, T> SliceVec<'s, T> {
   /// # use tinyvec::*;
   /// let mut arr = [0, 0];
   /// let mut sv = SliceVec::from_slice_len(&mut arr, 0);
-  /// assert_eq!(&sv[..], []);
+  /// assert_eq!(&sv[..], [] as [i32; 0]);
   /// sv.push(1);
   /// assert_eq!(&sv[..], [1]);
   /// sv.push(2);

src/tinyvec.rs

@@ -360,6 +360,33 @@ where
   }
 }
 
+#[cfg(feature = "schemars")]
+#[cfg_attr(docs_rs, doc(cfg(feature = "schemars")))]
+impl<A> schemars::JsonSchema for TinyVec<A>
+where
+  A: Array,
+  <A as Array>::Item: schemars::JsonSchema,
+{
+  fn schema_name() -> alloc::borrow::Cow<'static, str> {
+    alloc::format!(
+      "Array_up_to_size_{}_of_{}",
+      A::CAPACITY,
+      <A as Array>::Item::schema_name()
+    )
+    .into()
+  }
+
+  fn json_schema(
+    generator: &mut schemars::SchemaGenerator,
+  ) -> schemars::Schema {
+    schemars::json_schema!({
+        "type": "array",
+        "items": generator.subschema_for::<<A as Array>::Item>(),
+        "maxItems": A::CAPACITY
+    })
+  }
+}
+
 impl<A: Array> TinyVec<A> {
   /// Returns whether elements are on heap
   #[inline(always)]
@@ -933,7 +960,7 @@ impl<A: Array> TinyVec<A> {
   /// assert_eq!(tv2.as_slice(), &[2, 3][..]);
   ///
   /// tv.drain(..);
-  /// assert_eq!(tv.as_slice(), &[]);
+  /// assert_eq!(tv.as_slice(), &[] as &[i32]);
   /// ```
   #[inline]
   pub fn drain<R: RangeBounds<usize>>(
@@ -1188,7 +1215,7 @@ impl<A: Array> TinyVec<A> {
   /// assert_eq!(tv2.as_slice(), &[2, 3][..]);
   ///
   /// tv.splice(.., None);
-  /// assert_eq!(tv.as_slice(), &[]);
+  /// assert_eq!(tv.as_slice(), &[] as &[i32]);
   /// ```
   #[inline]
   pub fn splice<R, I>(

tests/arrayvec.rs

@@ -132,7 +132,7 @@ fn ArrayVec_append() {
   //
   av.append(&mut av2);
   assert_eq!(av.as_slice(), &[1_i32, 2, 3, 4, 5, 6]);
-  assert_eq!(av2.as_slice(), &[]);
+  assert_eq!(av2.as_slice(), &[] as &[i32]);
 }
 
 #[test]
@@ -167,7 +167,7 @@ fn ArrayVec_swap_remove() {
   assert_eq!(av.swap_remove(0), 3);
   assert_eq!(&av[..], &[2][..]);
   assert_eq!(av.swap_remove(0), 2);
-  assert_eq!(&av[..], &[][..]);
+  assert_eq!(&av[..], &[][..] as &[i32]);
 }
 
 #[test]
@@ -552,7 +552,7 @@ fn ArrayVec_try_from_slice() {
 
   let empty: Result<ArrayVec<[i32; 2]>, _> = ArrayVec::try_from(&nums[..0]);
   assert!(empty.is_ok());
-  assert_eq!(empty.unwrap().as_slice(), &[]);
+  assert_eq!(empty.unwrap().as_slice(), &[] as &[i32]);
 
   let fits: Result<ArrayVec<[i32; 2]>, _> = ArrayVec::try_from(&nums[..2]);
   assert!(fits.is_ok());

tests/tinyvec.rs

@@ -23,7 +23,7 @@ fn TinyVec_swap_remove() {
   assert_eq!(tv.swap_remove(0), 3);
   assert_eq!(&tv[..], &[2][..]);
   assert_eq!(tv.swap_remove(0), 2);
-  assert_eq!(&tv[..], &[][..]);
+  assert_eq!(&tv[..], &[][..] as &[i32]);
 }
 
 #[test]