Use _ in _u8 suffix for clarity

Author: kornelski

README.md

@@ -20,7 +20,7 @@ However, Rust is so strongly typed that _your_ `Rgb` struct is not compatible wi
 use rgb::{Rgb, Rgba, Argb, Bgr, Bgra, Abgr, Grb}; // and more
 use rgb::prelude::*; // traits with convenience methods
 
-let rgb_pixel = Rgb { r: 0u8, g: 100, b: 255 };
+let rgb_pixel = Rgb { r: 0_u8, g: 100, b: 255 };
 let wider_pixel = rgb_pixel.map(u16::from);
 
 println!("{rgb_pixel}"); // prints rgb(0, 100, 255)
@@ -38,7 +38,7 @@ We defer to the `bytemuck` crate to have safe zero-cost conversions between type
 [bvec]: https://docs.rs/bytemuck/latest/bytemuck/allocation/fn.cast_vec.html
 
 ```rust,ignore
-let pixels: Vec<u8> = vec![0u8; 3 * size];
+let pixels: Vec<u8> = vec![0_u8; 3 * size];
 let rgb_pixels: Vec<Rgb<u8>> = rgb::bytemuck::allocation::cast_vec(pixels);
 
 for rgb_pixel in &rgb_pixels {

src/formats/gray_alpha.rs

@@ -36,7 +36,7 @@ impl<T, A> Deref for GrayAlpha_v08<T, A> {
 
 #[test]
 fn swizzle() {
-    let g = GrayAlpha_v08(10u8, 20u8);
+    let g = GrayAlpha_v08(10_u8, 20_u8);
     assert_eq!(10, g.v);
     assert_eq!(20, g.a);
 }

src/legacy/alt.rs

@@ -218,7 +218,7 @@ fn gray() {
     assert_eq!(rgb.g, 1);
     assert_eq!(rgb.b, 1);
 
-    let rgba: crate::RGBA<_> = Gray(1u8).into();
+    let rgba: crate::RGBA<_> = Gray(1_u8).into();
     assert_eq!(rgba.r, 1);
     assert_eq!(rgba.g, 1);
     assert_eq!(rgba.b, 1);
@@ -241,8 +241,8 @@ fn gray() {
     assert_eq!(g2.with_alpha(13), GrayAlpha(3, 13));
     assert_eq!(g2.map_alpha(|x| x + 3), GrayAlpha(3, 5));
 
-    assert_eq!((&[Gray(1u16), Gray(2)][..]).as_slice(), &[1, 2]);
-    assert_eq!((&[GrayAlpha(1u16, 2), GrayAlpha(3, 4)][..]).as_slice(), &[1, 2, 3, 4]);
+    assert_eq!((&[Gray(1_u16), Gray(2)][..]).as_slice(), &[1, 2]);
+    assert_eq!((&[GrayAlpha(1_u16, 2), GrayAlpha(3, 4)][..]).as_slice(), &[1, 2, 3, 4]);
 
     let rgba: crate::RGBA<_> = ga.into();
     assert_eq!(rgba.r, 1);

src/legacy/internal/ops.rs

@@ -201,7 +201,7 @@ mod test {
 
     #[test]
     fn test_mult_assign() {
-        let mut green_rgb = RGB::new(0u16, 255, 0);
+        let mut green_rgb = RGB::new(0_u16, 255, 0);
         green_rgb *= 1;
         assert_eq!(RGB::new(0, 255, 0), green_rgb);
         green_rgb *= 2;
@@ -211,7 +211,7 @@ mod test {
         rgb *= RGB::new(1.,3.,5.);
         assert_eq!(rgb, RGB::new(0.5,4.5,12.5));
 
-        let mut green_rgba = RGBA::new(0u16, 255, 0, 0);
+        let mut green_rgba = RGBA::new(0_u16, 255, 0, 0);
         green_rgba *= 1;
         assert_eq!(RGBA::new(0, 255, 0, 0), green_rgba);
         green_rgba *= 2;
@@ -222,10 +222,11 @@ mod test {
     fn sum() {
         use crate::*;
 
-        let s1 = [RGB::new(1u8,1,1), RGB::new(2,3,4)].iter().copied().sum::<RGB<u8>>();
-        let s2 = [RGB::new(1u16,1,1), RGB::new(2,3,4)].iter().copied().sum::<RGB<u16>>();
-        let s3 = [RGBA::new_alpha(1u16,1,1,Wrapping(1u16)), RGBA::new_alpha(2,3,4,Wrapping(5))].iter().copied().sum::<RGBA<u16, Wrapping<u16>>>();
-        let s4 = [RGBA::new_alpha(1u16,1,1,1u16), RGBA::new_alpha(2,3,4,5)].iter().copied().sum::<RGBA<u16, u16>>();
+        let s1 = [RGB::new(1_u8, 1, 1), RGB::new(2, 3, 4)].iter().copied().sum::<RGB<u8>>();
+        let s2 = [RGB::new(1_u16, 1, 1), RGB::new(2, 3, 4)].iter().copied().sum::<RGB<u16>>();
+        let s3 = [RGBA::new_alpha(1_u16, 1, 1, Wrapping(1_u16)), RGBA::new_alpha(2, 3, 4, Wrapping(5))]
+            .iter().copied().sum::<RGBA<u16, Wrapping<u16>>>();
+        let s4 = [RGBA::new_alpha(1_u16, 1, 1, 1_u16), RGBA::new_alpha(2, 3, 4, 5)].iter().copied().sum::<RGBA<u16, u16>>();
         assert_eq!(s1, RGB::new(3, 4, 5));
         assert_eq!(s2, RGB::new(3, 4, 5));
         assert_eq!(s3, RGBA::new_alpha(3, 4, 5, Wrapping(6)));

src/legacy/internal/rgb.rs

@@ -167,8 +167,8 @@ mod rgb_test {
             RGB::new(250, 251, 252).with_alpha(253)
         );
 
-        assert_eq!(RGB { r: 1u8, g: 2, b: 3 }, RGB::new(1u8, 2, 3));
-        assert!(RGB { r: 1u8, g: 1, b: 2 } < RGB::new(2, 1, 1));
+        assert_eq!(RGB { r: 1_u8, g: 2, b: 3 }, RGB::new(1_u8, 2, 3));
+        assert!(RGB { r: 1_u8, g: 1, b: 2 } < RGB::new(2, 1, 1));
 
         let mut h = std::collections::HashSet::new();
         h.insert(px);
@@ -178,11 +178,11 @@ mod rgb_test {
         #[cfg(feature = "as-bytes")]
         {
             use crate::ComponentBytes;
-            let v = vec![RGB::new(1u8, 2, 3), RGB::new(4, 5, 6)];
+            let v = vec![RGB::new(1_u8, 2, 3), RGB::new(4, 5, 6)];
             assert_eq!(&[1, 2, 3, 4, 5, 6], v.as_bytes());
         }
 
-        assert_eq!(RGB::new(0u8, 0, 0), Default::default());
+        assert_eq!(RGB::new(0_u8, 0, 0), Default::default());
     }
 
     #[test]

src/legacy/internal/rgba.rs

@@ -345,10 +345,10 @@ fn rgba_test() {
     assert_eq!(neg, neg.as_slice().iter().copied().collect());
     assert!(neg < Rgba::new(0,0,0,0));
 
-    let neg = Rgba::new(1u8,2,3,4).map_rgb(|c| -i16::from(c));
+    let neg = Rgba::new(1_u8, 2, 3, 4).map_rgb(|c| -i16::from(c));
     assert_eq!(-1i16, neg.r);
     assert_eq!(4i16, neg.a);
-    let neg = Rgba::new(1u8,2,3,4).map_c(|c| -i16::from(c));
+    let neg = Rgba::new(1_u8, 2, 3, 4).map_c(|c| -i16::from(c));
     assert_eq!(-1i16, neg.r);
     assert_eq!(4u8, neg.a);
 
@@ -362,8 +362,8 @@ fn rgba_test() {
 
     #[cfg(feature = "as-bytes")]
     {
-        let v = [Rgba::new(1u8,2,3,4), Rgba::new(5,6,7,8)];
-        assert_eq!(&[1,2,3,4,5,6,7,8], v.as_bytes());
+        let v = [Rgba::new(1_u8, 2, 3, 4), Rgba::new(5, 6, 7, 8)];
+        assert_eq!(&[1, 2, 3, 4, 5, 6, 7, 8], v.as_bytes());
     }
 }
 
@@ -398,10 +398,10 @@ fn bgra_test() {
     assert_eq!(&[-3, -2, -1, -1000], neg.as_slice());
     assert!(neg < Bgra::new(0, 0, 0, 0));
 
-    let neg = Bgra::new(1u8, 2u8, 3u8, 4u8).map_rgb(|c| -i16::from(c));
+    let neg = Bgra::new(1_u8, 2u8, 3u8, 4u8).map_rgb(|c| -i16::from(c));
     assert_eq!(-1i16, neg.r);
     assert_eq!(4i16, neg.a);
-    let neg = Bgra::new(1u8, 2u8, 3u8, 4u8).map_c(|c| -i16::from(c));
+    let neg = Bgra::new(1_u8, 2u8, 3u8, 4u8).map_c(|c| -i16::from(c));
     assert_eq!(-1i16, neg.r);
     assert_eq!(4u8, neg.a);
 

src/legacy/mod.rs

@@ -25,7 +25,7 @@ pub type RGBA<T, A = T> = crate::Rgba<T, A>;
 fn rgb_works() {
     use crate::*;
 
-    let rgb = Rgb{r:0u8,g:128,b:255}.clone();
+    let rgb = Rgb { r: 0_u8, g: 128, b: 255 }.clone();
     assert_eq!(rgb.b, 255);
 
     assert_eq!(rgb, rgb.iter().map(|ch| ch).collect());
@@ -37,7 +37,7 @@ fn rgb_works() {
         assert_eq!(255, [rgb].as_bytes()[2]);
     }
 
-    let rgb = RGB16{r:0u16,g:0x7F7F,b:65535};
+    let rgb = RGB16 { r: 0_u16, g: 0x7F7F, b: 65535 };
     assert_eq!(rgb.b, 65535);
     assert_eq!(rgb.as_slice()[1], 0x7F7F);
 
@@ -73,7 +73,7 @@ fn into() {
 #[test]
 #[allow(deprecated)]
 fn rgba_works() {
-    let rgba = RGBA{r:0u8,g:128,b:255,a:33}.clone();
+    let rgba = RGBA { r: 0_u8, g: 128, b: 255, a: 33 }.clone();
     assert_eq!(rgba.b, 255);
     assert_eq!(rgba.a, 33);
 
@@ -134,7 +134,7 @@ fn bytes() {
     let mut rgba2 = [rgba];
     assert_eq!(rgba2[..].as_mut_slice().as_rgba_mut(), &mut [rgba]);
 
-    let mut foo = vec![0u8; 8];
-    foo.as_rgba_mut()[1] = RGBA::new(1,2,3,4);
-    assert_eq!(&[0u8,0,0,0,1,2,3,4], &foo[..]);
+    let mut foo = vec![0_u8; 8];
+    foo.as_rgba_mut()[1] = RGBA::new(1, 2, 3, 4);
+    assert_eq!(&[0_u8, 0, 0, 0, 1, 2, 3, 4], &foo[..]);
 }

src/pixel_traits/het_pixel.rs

@@ -241,8 +241,8 @@ pub trait HetPixel: Copy {
     ///     u16::from(alpha) * 10
     /// };
     ///
-    /// assert_eq!(rgb.map_alpha(f), Rgb {r: 0, g: 10, b: 100});
-    /// assert_eq!(rgba.map_alpha(f), Rgba {r: 0, g: 10, b: 100, a: 500});
+    /// assert_eq!(rgb.map_alpha(f), Rgb { r: 0_u8, g: 10, b: 100 });
+    /// assert_eq!(rgba.map_alpha(f), Rgba { r: 0_u8, g: 10, b: 100, a: 500_u16 });
     /// ```
     fn map_alpha<U>(
         &self,

src/pixel_traits/pixel.rs

@@ -148,19 +148,18 @@ pub trait Pixel:
     /// let rgb = Rgb { r: 0_u8, g: 10, b: 100 };
     /// let rgba = Rgba { r: 0_u8, g: 10, b: 100, a: 50 };
     ///
-    /// let f = |color: u8| {
-    ///     u16::from(color) * 10
-    /// };
+    /// let widen = |b: u8| u16::from(b) << 8 | u16::from(b);
     ///
-    /// assert_eq!(rgb.map(f), Rgb { r: 0, g: 100, b: 1000 });
-    /// assert_eq!(rgba.map(f), Rgba { r: 0, g: 100, b: 1000, a: 500 });
+    /// assert_eq!(rgb.map(widen), Rgb { r: 0, g: 100, b: 1000 });
+    /// assert_eq!(rgba.map(widen), Rgba { r: 0, g: 100, b: 1000, a: 500 });
     /// ```
     fn map<U>(&self, f: impl FnMut(Self::Component) -> U) -> Self::SelfType<U, U> where U: Copy;
 
     /// Maps each of the pixel's components with a function `f` to the same component type.
     ///
-    /// See [`Pixel::map()`] if you want to map the components to a
-    /// different type.
+    /// Use [`Pixel::map()`] if you want to map the components to a
+    /// different type. `map()` can also be used to keep the same component type,
+    /// but due to limitations of Rust's type system,`map_same()` may be required in generic contexts.
     ///
     /// # Examples
     ///
@@ -170,12 +169,10 @@ pub trait Pixel:
     /// let rgb = Rgb { r: 0_u8, g: 10, b: 100 };
     /// let rgba = Rgba { r: 0_u8, g: 10, b: 100, a: 50 };
     ///
-    /// let f = |color: u8| {
-    ///     color / 2
-    /// };
+    /// let halved = |color: u8| color / 2;
     ///
-    /// assert_eq!(rgb.map_same(f), Rgb { r: 0, g: 5, b: 50 });
-    /// assert_eq!(rgba.map_same(f), Rgba { r: 0, g: 5, b: 50, a: 25 });
+    /// assert_eq!(rgb.map_same(halved), Rgb { r: 0, g: 5, b: 50 });
+    /// assert_eq!(rgba.map_same(halved), Rgba { r: 0, g: 5, b: 50, a: 25 });
     /// ```
     fn map_same(&self, f: impl FnMut(Self::Component) -> Self::Component) -> Self;
 }
@@ -299,19 +296,19 @@ with_alpha!(GrayAlpha_v08, 2, [0, 1]);
 
 #[test]
 fn as_refs() {
-    let mut r = Rgba::new(1u8,2,3,4u8);
-    assert_eq!(&[1,2,3,4], r.as_array());
-    assert_eq!(&[1,2,3,4], AsRef::<[u8; 4]>::as_ref(&r));
-    assert_eq!(&[1,2,3,4], r.as_ref());
-    assert_eq!([1,2,3,4], *r.as_array_mut());
-    assert_eq!([1,2,3,4], *AsMut::<[u8; 4]>::as_mut(&mut r));
-    assert_eq!([1,2,3,4], *r.as_mut());
-
-    let mut r = GrayA::new(1u8,4u8);
-    assert_eq!(&[1,4], r.as_array());
-    assert_eq!(&[1,4], AsRef::<[u8; 2]>::as_ref(&r));
-    assert_eq!(&[1,4], r.as_ref());
-    assert_eq!([1,4], *r.as_array_mut());
-    assert_eq!([1,4], *AsMut::<[u8; 2]>::as_mut(&mut r));
-    assert_eq!([1,4], *r.as_mut());
+    let mut r = Rgba::new(1_u8, 2, 3, 4u8);
+    assert_eq!(&[1, 2, 3, 4], r.as_array());
+    assert_eq!(&[1, 2, 3, 4], AsRef::<[u8; 4]>::as_ref(&r));
+    assert_eq!(&[1, 2, 3, 4], r.as_ref());
+    assert_eq!([1, 2, 3, 4], *r.as_array_mut());
+    assert_eq!([1, 2, 3, 4], *AsMut::<[u8; 4]>::as_mut(&mut r));
+    assert_eq!([1, 2, 3, 4], *r.as_mut());
+
+    let mut r = GrayA::new(1_u8, 4u8);
+    assert_eq!(&[1, 4], r.as_array());
+    assert_eq!(&[1, 4], AsRef::<[u8; 2]>::as_ref(&r));
+    assert_eq!(&[1, 4], r.as_ref());
+    assert_eq!([1, 4], *r.as_array_mut());
+    assert_eq!([1, 4], *AsMut::<[u8; 2]>::as_mut(&mut r));
+    assert_eq!([1, 4], *r.as_mut());
 }