Add "Count" suffix to known counters

Author: nvzqz

examples/benches/image.rs

@@ -1,6 +1,6 @@
 //! Benchmarks the [`image`](https://docs.rs/image) crate.
 
-use divan::{black_box, counter::Bytes, Bencher};
+use divan::{black_box, counter::BytesCount, Bencher};
 use image::{GenericImage, ImageBuffer, Rgba};
 
 fn main() {
@@ -18,7 +18,7 @@ fn copy_from(bencher: Bencher) {
     let mut dst = make_image(Rgba([0u8, 0, 0, 255]));
 
     bencher
-        .counter(Bytes::of_slice(&*src))
+        .counter(BytesCount::of_slice(&*src))
         .bench(|| black_box(&mut dst).copy_from(black_box(&src), 0, 0));
 }
 
@@ -29,6 +29,6 @@ fn memcpy(bencher: Bencher) {
     let mut dst = vec![0; src.len()];
 
     bencher
-        .counter(Bytes::of_slice(&*src))
+        .counter(BytesCount::of_slice(&*src))
         .bench(|| black_box(&mut dst).copy_from_slice(black_box(&src)));
 }

examples/benches/string.rs

@@ -1,6 +1,6 @@
 use divan::{
     black_box,
-    counter::{Bytes, Chars},
+    counter::{BytesCount, CharsCount},
     Bencher,
 };
 
@@ -44,9 +44,9 @@ impl GenString for Unicode {
 fn clear<G: GenString, const N: usize>(bencher: Bencher) {
     let mut gen = G::default();
     bencher
-        .counter(Chars::new(N))
+        .counter(CharsCount::new(N))
         .with_inputs(|| gen.gen_string(N))
-        .input_counter(Bytes::of_str)
+        .input_counter(BytesCount::of_str)
         .bench_local_refs(String::clear);
 }
 
@@ -57,9 +57,9 @@ fn clear<G: GenString, const N: usize>(bencher: Bencher) {
 fn drop<G: GenString, const N: usize>(bencher: Bencher) {
     let mut gen = G::default();
     bencher
-        .counter(Chars::new(N))
+        .counter(CharsCount::new(N))
         .with_inputs(|| gen.gen_string(N))
-        .input_counter(Bytes::of_str)
+        .input_counter(BytesCount::of_str)
         .bench_local_values(std::mem::drop);
 }
 
@@ -70,9 +70,9 @@ fn drop<G: GenString, const N: usize>(bencher: Bencher) {
 fn validate_utf8<G: GenString, const N: usize>(bencher: Bencher) {
     let mut gen = G::default();
     bencher
-        .counter(Chars::new(N))
+        .counter(CharsCount::new(N))
         .with_inputs(|| gen.gen_string(N))
-        .input_counter(Bytes::of_str)
+        .input_counter(BytesCount::of_str)
         .bench_local_refs(|s| {
             let bytes = black_box(s.as_bytes());
             _ = black_box(std::str::from_utf8(bytes));
@@ -86,9 +86,9 @@ fn validate_utf8<G: GenString, const N: usize>(bencher: Bencher) {
 fn char_count<G: GenString, const N: usize>(bencher: Bencher) {
     let mut gen = G::default();
     bencher
-        .counter(Chars::new(N))
+        .counter(CharsCount::new(N))
         .with_inputs(|| gen.gen_string(N))
-        .input_counter(Bytes::of_str)
+        .input_counter(BytesCount::of_str)
         .bench_local_refs(|s| s.chars().count());
 }
 
@@ -99,9 +99,9 @@ fn char_count<G: GenString, const N: usize>(bencher: Bencher) {
 fn make_ascii_lowercase<G: GenString, const N: usize>(bencher: Bencher) {
     let mut gen = G::default();
     bencher
-        .counter(Chars::new(N))
+        .counter(CharsCount::new(N))
         .with_inputs(|| gen.gen_string(N))
-        .input_counter(Bytes::of_str)
+        .input_counter(BytesCount::of_str)
         .bench_local_refs(|s| s.make_ascii_lowercase());
 }
 
@@ -112,9 +112,9 @@ fn make_ascii_lowercase<G: GenString, const N: usize>(bencher: Bencher) {
 fn make_ascii_uppercase<G: GenString, const N: usize>(bencher: Bencher) {
     let mut gen = G::default();
     bencher
-        .counter(Chars::new(N))
+        .counter(CharsCount::new(N))
         .with_inputs(|| gen.gen_string(N))
-        .input_counter(Bytes::of_str)
+        .input_counter(BytesCount::of_str)
         .bench_local_refs(|s| s.make_ascii_uppercase());
 }
 
@@ -125,9 +125,9 @@ fn make_ascii_uppercase<G: GenString, const N: usize>(bencher: Bencher) {
 fn to_ascii_lowercase<G: GenString, const N: usize>(bencher: Bencher) {
     let mut gen = G::default();
     bencher
-        .counter(Chars::new(N))
+        .counter(CharsCount::new(N))
         .with_inputs(|| gen.gen_string(N))
-        .input_counter(Bytes::of_str)
+        .input_counter(BytesCount::of_str)
         .bench_local_refs(|s| s.to_ascii_lowercase());
 }
 
@@ -138,9 +138,9 @@ fn to_ascii_lowercase<G: GenString, const N: usize>(bencher: Bencher) {
 fn to_ascii_uppercase<G: GenString, const N: usize>(bencher: Bencher) {
     let mut gen = G::default();
     bencher
-        .counter(Chars::new(N))
+        .counter(CharsCount::new(N))
         .with_inputs(|| gen.gen_string(N))
-        .input_counter(Bytes::of_str)
+        .input_counter(BytesCount::of_str)
         .bench_local_refs(|s| s.to_ascii_uppercase());
 }
 
@@ -151,9 +151,9 @@ fn to_ascii_uppercase<G: GenString, const N: usize>(bencher: Bencher) {
 fn to_lowercase<G: GenString, const N: usize>(bencher: Bencher) {
     let mut gen = G::default();
     bencher
-        .counter(Chars::new(N))
+        .counter(CharsCount::new(N))
         .with_inputs(|| gen.gen_string(N))
-        .input_counter(Bytes::of_str)
+        .input_counter(BytesCount::of_str)
         .bench_local_refs(|s| s.to_lowercase());
 }
 
@@ -164,8 +164,8 @@ fn to_lowercase<G: GenString, const N: usize>(bencher: Bencher) {
 fn to_uppercase<G: GenString, const N: usize>(bencher: Bencher) {
     let mut gen = G::default();
     bencher
-        .counter(Chars::new(N))
+        .counter(CharsCount::new(N))
         .with_inputs(|| gen.gen_string(N))
-        .input_counter(Bytes::of_str)
+        .input_counter(BytesCount::of_str)
         .bench_local_refs(|s| s.to_uppercase());
 }

src/bench/mod.rs

@@ -18,7 +18,7 @@ use crate::{
 
 // Used for intra-doc links.
 #[allow(unused)]
-use crate::counter::Bytes;
+use crate::counter::BytesCount;
 
 #[cfg(test)]
 mod tests;
@@ -169,15 +169,15 @@ impl<'a, 'b, GenI> Bencher<'a, 'b, BencherConfig<GenI>> {
     /// # Examples
     ///
     /// ```
-    /// use divan::{Bencher, counter::Bytes};
+    /// use divan::{Bencher, counter::BytesCount};
     ///
     /// #[divan::bench]
     /// fn char_count(bencher: Bencher) {
     ///     let s: String = // ...
     ///     # String::new();
     ///
     ///     bencher
-    ///         .counter(Bytes::of_str(&s))
+    ///         .counter(BytesCount::of_str(&s))
     ///         .bench(|| {
     ///             divan::black_box(&s).chars().count()
     ///         });
@@ -216,11 +216,11 @@ where
     ///
     /// The following example emits info for the number of bytes processed when
     /// benchmarking [`char`-counting](std::str::Chars::count). The byte count
-    /// is gotten by calling [`Bytes::of_str`] on each iteration's input
+    /// is gotten by calling [`BytesCount::of_str`] on each iteration's input
     /// [`String`].
     ///
     /// ```
-    /// use divan::{Bencher, counter::Bytes};
+    /// use divan::{Bencher, counter::BytesCount};
     ///
     /// #[divan::bench]
     /// fn char_count(bencher: Bencher) {
@@ -229,7 +229,7 @@ where
     ///             // ...
     ///             # String::new()
     ///         })
-    ///         .input_counter(Bytes::of_str)
+    ///         .input_counter(BytesCount::of_str)
     ///         .bench_refs(|s| {
     ///             s.chars().count()
     ///         });

src/counter/any_counter.rs

@@ -1,7 +1,7 @@
 use std::{any::TypeId, fmt};
 
 use crate::{
-    counter::{Bytes, BytesFormat, Chars, IntoCounter, Items, MaxCountUInt},
+    counter::{BytesCount, BytesFormat, CharsCount, IntoCounter, ItemsCount, MaxCountUInt},
     time::FineDuration,
     util,
 };
@@ -21,11 +21,11 @@ impl AnyCounter {
     pub(crate) fn new<C: IntoCounter>(counter: C) -> Self {
         let counter = counter.into_counter();
 
-        if let Some(bytes) = util::cast_ref::<Bytes>(&counter) {
+        if let Some(bytes) = util::cast_ref::<BytesCount>(&counter) {
             Self::bytes(bytes.count)
-        } else if let Some(chars) = util::cast_ref::<Chars>(&counter) {
+        } else if let Some(chars) = util::cast_ref::<CharsCount>(&counter) {
             Self::chars(chars.count)
-        } else if let Some(items) = util::cast_ref::<Items>(&counter) {
+        } else if let Some(items) = util::cast_ref::<ItemsCount>(&counter) {
             Self::items(items.count)
         } else {
             unreachable!()
@@ -90,11 +90,11 @@ impl KnownCounterKind {
     #[inline]
     pub fn of<C: IntoCounter>() -> Self {
         let id = TypeId::of::<C::Counter>();
-        if id == TypeId::of::<Bytes>() {
+        if id == TypeId::of::<BytesCount>() {
             Self::Bytes
-        } else if id == TypeId::of::<Chars>() {
+        } else if id == TypeId::of::<CharsCount>() {
             Self::Chars
-        } else if id == TypeId::of::<Items>() {
+        } else if id == TypeId::of::<ItemsCount>() {
             Self::Items
         } else {
             unreachable!()

src/counter/into_counter.rs

@@ -4,8 +4,8 @@ use crate::counter::Counter;
 ///
 /// # Examples
 ///
-/// This trait is implemented for unsigned integers over the
-/// [`Items`](crate::counter::Items) counter:
+/// This trait is implemented for unsigned integers over
+/// [`ItemsCount`](crate::counter::ItemsCount):
 ///
 /// ```
 /// #[divan::bench]

src/counter/mod.rs

@@ -3,19 +3,19 @@
 //! # Examples
 //!
 //! The following example measures throughput of converting
-//! [`&[i32]`](prim@slice) into [`Vec<i32>`](Vec) by providing [`Bytes`] via
+//! [`&[i32]`](prim@slice) into [`Vec<i32>`](Vec) by providing [`BytesCount`] via
 //! [`Bencher::counter`](crate::Bencher::counter):
 //!
 //! ```
-//! use divan::counter::Bytes;
+//! use divan::counter::BytesCount;
 //!
 //! #[divan::bench]
 //! fn slice_into_vec(bencher: divan::Bencher) {
 //!     let ints: &[i32] = &[
 //!         // ...
 //!     ];
 //!
-//!     let bytes = Bytes::of_slice(ints);
+//!     let bytes = BytesCount::of_slice(ints);
 //!
 //!     bencher
 //!         .counter(bytes)
@@ -54,7 +54,7 @@ pub trait Counter: Sized + Any + Sealed {}
 
 /// Process N bytes.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
-pub struct Bytes {
+pub struct BytesCount {
     count: MaxCountUInt,
 }
 
@@ -64,25 +64,25 @@ pub struct Bytes {
 /// implementations, since the number of code points is a common baseline
 /// reference.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
-pub struct Chars {
+pub struct CharsCount {
     count: MaxCountUInt,
 }
 
 /// Process N items.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
-pub struct Items {
+pub struct ItemsCount {
     count: MaxCountUInt,
 }
 
-impl Sealed for Bytes {}
-impl Sealed for Chars {}
-impl Sealed for Items {}
+impl Sealed for BytesCount {}
+impl Sealed for CharsCount {}
+impl Sealed for ItemsCount {}
 
-impl Counter for Bytes {}
-impl Counter for Chars {}
-impl Counter for Items {}
+impl Counter for BytesCount {}
+impl Counter for CharsCount {}
+impl Counter for ItemsCount {}
 
-impl Bytes {
+impl BytesCount {
     /// Count N bytes.
     #[inline]
     pub fn new<N: CountUInt>(count: N) -> Self {
@@ -106,7 +106,7 @@ impl Bytes {
 
     /// Counts the bytes of a [`&str`].
     ///
-    /// This is like [`Bytes::of_val`] with the convenience of behaving as
+    /// This is like [`BytesCount::of_val`] with the convenience of behaving as
     /// expected for [`&String`](String) and other types that convert to
     /// [`&str`].
     ///
@@ -118,7 +118,7 @@ impl Bytes {
 
     /// Counts the bytes of a [slice](prim@slice).
     ///
-    /// This is like [`Bytes::of_val`] with the convenience of behaving as
+    /// This is like [`BytesCount::of_val`] with the convenience of behaving as
     /// expected for [`&Vec<T>`](Vec) and other types that convert to
     /// [`&[T]`](prim@slice).
     #[inline]
@@ -127,7 +127,7 @@ impl Bytes {
     }
 }
 
-impl Chars {
+impl CharsCount {
     /// Count N [`char`s](char).
     #[inline]
     pub fn new<N: CountUInt>(count: N) -> Self {
@@ -141,15 +141,15 @@ impl Chars {
     }
 }
 
-impl Items {
+impl ItemsCount {
     /// Count N items.
     #[inline]
     pub fn new<N: CountUInt>(count: N) -> Self {
         Self { count: count.into_max_uint() }
     }
 }
 
-/// The numerical base for [`Bytes`] in benchmark outputs.
+/// The numerical base for [`BytesCount`] in benchmark outputs.
 ///
 /// See [`Divan::bytes_format`](crate::Divan::bytes_format) for more info.
 #[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord)]

src/counter/uint.rs

@@ -1,6 +1,6 @@
 use std::any::Any;
 
-use crate::counter::{IntoCounter, Items};
+use crate::counter::{IntoCounter, ItemsCount};
 
 /// The largest unsigned integer usable by counters provided by this crate.
 ///
@@ -29,11 +29,11 @@ macro_rules! impl_uint {
         })+
 
         $(impl IntoCounter for $i {
-            type Counter = Items;
+            type Counter = ItemsCount;
 
             #[inline]
-            fn into_counter(self) -> Items {
-                Items::new(self)
+            fn into_counter(self) -> ItemsCount {
+                ItemsCount::new(self)
             }
         })+
     };

src/divan.rs

@@ -452,8 +452,8 @@ impl Divan {
         self
     }
 
-    /// Determines how [`Bytes`](crate::counter::Bytes) is scaled in benchmark
-    /// outputs.
+    /// Determines how [`BytesCount`](crate::counter::BytesCount) is scaled in
+    /// benchmark outputs.
     ///
     /// This option is equivalent to the `--bytes-format` CLI argument.
     #[inline]