Convert documentation to intra doc links

Author: okaneco

palette/src/alpha/mod.rs

@@ -13,7 +13,7 @@ mod alpha;
 /// channel of a color type. The color type itself doesn't need to store the
 /// transparency value as it can be transformed into or wrapped in a type that
 /// has a representation of transparency. This would typically be done by
-/// wrapping it in an [`Alpha`](struct.Alpha.html) instance.
+/// wrapping it in an [`Alpha`](crate::Alpha) instance.
 ///
 /// # Deriving
 /// The trait is trivial enough to be automatically derived. If the color type

palette/src/blend/mod.rs

@@ -3,7 +3,7 @@
 //! Palette offers both OpenGL style blending equations, as well as most of the
 //! SVG composition operators (also common in photo manipulation software). The
 //! composition operators are all implemented in the
-//! [`Blend`](trait.Blend.html) trait, and ready to use with any appropriate
+//! [`Blend`](crate::Blend) trait, and ready to use with any appropriate
 //! color type:
 //!
 //! ```
@@ -15,7 +15,7 @@
 //! ```
 //!
 //! Blending equations can be defined using the
-//! [`Equations`](struct.Equations.html) type, which is then passed to the
+//! [`Equations`](crate::blend::Equations) type, which is then passed to the
 //! `blend` function, from the `Blend` trait:
 //!
 //! ```
@@ -32,7 +32,7 @@
 //! let c = a.blend(b, blend_mode);
 //! ```
 //!
-//! Note that blending will use [premultiplied alpha](struct.PreAlpha.html),
+//! Note that blending will use [premultiplied alpha](crate::blend::PreAlpha),
 //! which may result in loss of some color information in some cases. One such
 //! case is that a completely transparent resultant color will become black.
 

palette/src/convert.rs

@@ -6,7 +6,7 @@
 //! The default minimum requirement is to implement `FromColorUnclamped<Xyz>`, but it can
 //! also be customized to make use of generics and have other manual implementations.
 //!
-//! It is also recommended to derive or implement [`WithAlpha`](../trait.WithAlpha.html),
+//! It is also recommended to derive or implement [`WithAlpha`](crate::WithAlpha),
 //! to be able to convert between all `Alpha` wrapped color types.
 //!
 //! ## Configuration Attributes
@@ -319,7 +319,7 @@ impl<T> Display for OutOfBounds<T> {
 ///
 /// `U: IntoColor<T>` is implemented for every type `T: FromColor<U>`.
 ///
-/// See [`FromColor`](trait.FromColor.html) for more details.
+/// See [`FromColor`](crate::convert::FromColor) for more details.
 pub trait IntoColor<T>: Sized {
     /// Convert into T with values clamped to the color defined bounds
     ///
@@ -336,7 +336,7 @@ pub trait IntoColor<T>: Sized {
 ///
 /// `U: IntoColorUnclamped<T>` is implemented for every type `T: FromColorUnclamped<U>`.
 ///
-/// See [`FromColorUnclamped`](trait.FromColorUnclamped.html) for more details.
+/// See [`FromColorUnclamped`](crate::convert::FromColorUnclamped) for more details.
 pub trait IntoColorUnclamped<T>: Sized {
     /// Convert into T. The resulting color might be invalid in its color space
     ///
@@ -354,7 +354,7 @@ pub trait IntoColorUnclamped<T>: Sized {
 ///
 /// `U: TryIntoColor<T>` is implemented for every type `T: TryFromColor<U>`.
 ///
-/// See [`TryFromColor`](trait.TryFromColor.html) for more details.
+/// See [`TryFromColor`](crate::convert::TryFromColor) for more details.
 pub trait TryIntoColor<T>: Sized {
     /// Convert into T, returning ok if the color is inside of its defined
     /// range, otherwise an `OutOfBounds` error is returned which contains
@@ -379,8 +379,8 @@ pub trait TryIntoColor<T>: Sized {
 ///
 /// `U: FromColor<T>` is implemented for every type `U: FromColorUnclamped<T> + Limited`.
 ///
-/// See [`FromColorUnclamped`](trait.FromColorUnclamped.html) for a lossless version of this trait.
-/// See [`TryFromColor`](trait.TryFromColor.html) for a trait that gives an error when the result
+/// See [`FromColorUnclamped`](crate::convert::FromColorUnclamped) for a lossless version of this trait.
+/// See [`TryFromColor`](crate::convert::TryFromColor) for a trait that gives an error when the result
 /// is out of bounds.
 ///
 /// # The Difference Between FromColor and From
@@ -398,7 +398,7 @@ pub trait TryIntoColor<T>: Sized {
 /// traits, while `From` and `Into` would not be possible to blanket implement in the same way.
 /// This also reduces the work that needs to be done by macros.
 ///
-/// See the [`convert`](index.html) module for how to implement `FromColorUnclamped` for
+/// See the [`convert`](crate::convert) module for how to implement `FromColorUnclamped` for
 /// custom colors.
 pub trait FromColor<T>: Sized {
     /// Convert from T with values clamped to the color defined bounds.
@@ -414,11 +414,11 @@ pub trait FromColor<T>: Sized {
 
 /// A trait for unchecked conversion of one color from another.
 ///
-/// See [`FromColor`](trait.FromColor.html) for a lossy version of this trait.
-/// See [`TryFromColor`](trait.TryFromColor.html) for a trait that gives an error when the result
+/// See [`FromColor`](crate::convert::FromColor) for a lossy version of this trait.
+/// See [`TryFromColor`](crate::convert::TryFromColor) for a trait that gives an error when the result
 /// is out of bounds.
 ///
-/// See the [`convert`](index.html) module for how to implement `FromColorUnclamped` for
+/// See the [`convert`](crate::convert) module for how to implement `FromColorUnclamped` for
 /// custom colors.
 pub trait FromColorUnclamped<T>: Sized {
     /// Convert from T. The resulting color might be invalid in its color space.
@@ -437,10 +437,10 @@ pub trait FromColorUnclamped<T>: Sized {
 ///
 /// `U: TryFromColor<T>` is implemented for every type `U: FromColorUnclamped<T> + Limited`.
 ///
-/// See [`FromColor`](trait.FromColor.html) for a lossy version of this trait.
-/// See [`FromColorUnclamped`](trait.FromColorUnclamped.html) for a lossless version.
+/// See [`FromColor`](crate::convert::FromColor) for a lossy version of this trait.
+/// See [`FromColorUnclamped`](crate::convert::FromColorUnclamped) for a lossless version.
 ///
-/// See the [`convert`](index.html) module for how to implement `FromColorUnclamped` for
+/// See the [`convert`](crate::convert) module for how to implement `FromColorUnclamped` for
 /// custom colors.
 pub trait TryFromColor<T>: Sized {
     /// Convert from T, returning ok if the color is inside of its defined

palette/src/hsl.rs

@@ -21,19 +21,19 @@ use crate::{
 };
 
 /// Linear HSL with an alpha component. See the [`Hsla` implementation in
-/// `Alpha`](struct.Alpha.html#Hsla).
+/// `Alpha`](crate::Alpha#Hsla).
 pub type Hsla<S = Srgb, T = f32> = Alpha<Hsl<S, T>, T>;
 
 /// HSL color space.
 ///
 /// The HSL color space can be seen as a cylindrical version of
-/// [RGB](rgb/struct.Rgb.html), where the `hue` is the angle around the color
+/// [RGB](crate::rgb::Rgb), where the `hue` is the angle around the color
 /// cylinder, the `saturation` is the distance from the center, and the
 /// `lightness` is the height from the bottom. Its composition makes it
 /// especially good for operations like changing green to red, making a color
 /// more gray, or making it darker.
 ///
-/// See [HSV](struct.Hsv.html) for a very similar color space, with brightness
+/// See [HSV](crate::Hsv) for a very similar color space, with brightness
 /// instead of lightness.
 #[derive(Debug, PartialEq, Pixel, FromColorUnclamped, WithAlpha)]
 #[cfg_attr(feature = "serializing", derive(Serialize, Deserialize))]
@@ -158,7 +158,7 @@ where
     }
 }
 
-///<span id="Hsla"></span>[`Hsla`](type.Hsla.html) implementations.
+///<span id="Hsla"></span>[`Hsla`](crate::Hsla) implementations.
 impl<T, A> Alpha<Hsl<Srgb, T>, A>
 where
     T: FloatComponent,
@@ -173,7 +173,7 @@ where
     }
 }
 
-///<span id="Hsla"></span>[`Hsla`](type.Hsla.html) implementations.
+///<span id="Hsla"></span>[`Hsla`](crate::Hsla) implementations.
 impl<S, T, A> Alpha<Hsl<S, T>, A>
 where
     T: FloatComponent,

palette/src/hsv.rs

@@ -21,13 +21,13 @@ use crate::{
 };
 
 /// Linear HSV with an alpha component. See the [`Hsva` implementation in
-/// `Alpha`](struct.Alpha.html#Hsva).
+/// `Alpha`](crate::Alpha#Hsva).
 pub type Hsva<S = Srgb, T = f32> = Alpha<Hsv<S, T>, T>;
 
 /// HSV color space.
 ///
-/// HSV is a cylindrical version of [RGB](rgb/struct.Rgb.html) and it's very
-/// similar to [HSL](struct.Hsl.html). The difference is that the `value`
+/// HSV is a cylindrical version of [RGB](crate::rgb::Rgb) and it's very
+/// similar to [HSL](crate::Hsl). The difference is that the `value`
 /// component in HSV determines the _brightness_ of the color, and not the
 /// _lightness_. The difference is that, for example, red (100% R, 0% G, 0% B)
 /// and white (100% R, 100% G, 100% B) has the same brightness (or value), but
@@ -155,7 +155,7 @@ where
     }
 }
 
-///<span id="Hsva"></span>[`Hsva`](type.Hsva.html) implementations.
+///<span id="Hsva"></span>[`Hsva`](crate::Hsva) implementations.
 impl<T, A> Alpha<Hsv<Srgb, T>, A>
 where
     T: FloatComponent,
@@ -170,7 +170,7 @@ where
     }
 }
 
-///<span id="Hsva"></span>[`Hsva`](type.Hsva.html) implementations.
+///<span id="Hsva"></span>[`Hsva`](crate::Hsva) implementations.
 impl<S, T, A> Alpha<Hsv<S, T>, A>
 where
     T: FloatComponent,

palette/src/hwb.rs

@@ -21,13 +21,13 @@ use crate::{
 };
 
 /// Linear HWB with an alpha component. See the [`Hwba` implementation in
-/// `Alpha`](struct.Alpha.html#Hwba).
+/// `Alpha`](crate::Alpha#Hwba).
 pub type Hwba<S = Srgb, T = f32> = Alpha<Hwb<S, T>, T>;
 
 /// HWB color space.
 ///
-/// HWB is a cylindrical version of [RGB](rgb/struct.Rgb.html) and it's very
-/// closely related to [HSV](struct.Hsv.html). It describes colors with a
+/// HWB is a cylindrical version of [RGB](crate::rgb::Rgb) and it's very
+/// closely related to [HSV](crate::Hsv). It describes colors with a
 /// starting hue, then a degree of whiteness and blackness to mix into that
 /// base hue.
 ///
@@ -161,7 +161,7 @@ where
     }
 }
 
-///<span id="Hwba"></span>[`Hwba`](type.Hwba.html) implementations.
+///<span id="Hwba"></span>[`Hwba`](crate::Hwba) implementations.
 impl<T, A> Alpha<Hwb<Srgb, T>, A>
 where
     T: FloatComponent,
@@ -176,7 +176,7 @@ where
     }
 }
 
-///<span id="Hwba"></span>[`Hwba`](type.Hwba.html) implementations.
+///<span id="Hwba"></span>[`Hwba`](crate::Hwba) implementations.
 impl<S, T, A> Alpha<Hwb<S, T>, A>
 where
     T: FloatComponent,

palette/src/lab.rs

@@ -19,7 +19,7 @@ use crate::{
 };
 
 /// CIE L\*a\*b\* (CIELAB) with an alpha component. See the [`Laba`
-/// implementation in `Alpha`](struct.Alpha.html#Laba).
+/// implementation in `Alpha`](crate::Alpha#Laba).
 pub type Laba<Wp, T = f32> = Alpha<Lab<Wp, T>, T>;
 
 /// The CIE L\*a\*b\* (CIELAB) color space.
@@ -152,7 +152,7 @@ where
     }
 }
 
-///<span id="Laba"></span>[`Laba`](type.Laba.html) implementations.
+///<span id="Laba"></span>[`Laba`](crate::Laba) implementations.
 impl<T, A> Alpha<Lab<D65, T>, A>
 where
     T: FloatComponent,
@@ -167,7 +167,7 @@ where
     }
 }
 
-///<span id="Laba"></span>[`Laba`](type.Laba.html) implementations.
+///<span id="Laba"></span>[`Laba`](crate::Laba) implementations.
 impl<Wp, T, A> Alpha<Lab<Wp, T>, A>
 where
     T: FloatComponent,

palette/src/lch.rs

@@ -19,14 +19,14 @@ use crate::{
 };
 
 /// CIE L\*C\*h° with an alpha component. See the [`Lcha` implementation in
-/// `Alpha`](struct.Alpha.html#Lcha).
+/// `Alpha`](crate::Alpha#Lcha).
 pub type Lcha<Wp, T = f32> = Alpha<Lch<Wp, T>, T>;
 
-/// CIE L\*C\*h°, a polar version of [CIE L\*a\*b\*](struct.Lab.html).
+/// CIE L\*C\*h°, a polar version of [CIE L\*a\*b\*](crate::Lab).
 ///
 /// L\*C\*h° shares its range and perceptual uniformity with L\*a\*b\*, but
-/// it's a cylindrical color space, like [HSL](struct.Hsl.html) and
-/// [HSV](struct.Hsv.html). This gives it the same ability to directly change
+/// it's a cylindrical color space, like [HSL](crate::Hsl) and
+/// [HSV](crate::Hsv). This gives it the same ability to directly change
 /// the hue and colorfulness of a color, while preserving other visual aspects.
 #[derive(Debug, PartialEq, Pixel, FromColorUnclamped, WithAlpha)]
 #[cfg_attr(feature = "serializing", derive(Serialize, Deserialize))]
@@ -151,7 +151,7 @@ where
     }
 }
 
-///<span id="Lcha"></span>[`Lcha`](type.Lcha.html) implementations.
+///<span id="Lcha"></span>[`Lcha`](crate::Lcha) implementations.
 impl<T, A> Alpha<Lch<D65, T>, A>
 where
     T: FloatComponent,
@@ -166,7 +166,7 @@ where
     }
 }
 
-///<span id="Lcha"></span>[`Lcha`](type.Lcha.html) implementations.
+///<span id="Lcha"></span>[`Lcha`](crate::Lcha) implementations.
 impl<Wp, T, A> Alpha<Lch<Wp, T>, A>
 where
     T: FloatComponent,

palette/src/lib.rs

@@ -13,7 +13,7 @@
 //! to perform on colors (addition, subtraction, multiplication, linear interpolation,
 //! etc.) will work unexpectedly when performed in such a non-linear color space. As
 //! such, the compression has to be reverted to restore linearity and make sure that
-//! many operations on the colors are accurate. 
+//! many operations on the colors are accurate.
 //!
 //! For example, this does not work:
 //!
@@ -96,7 +96,7 @@
 //! also many cases where it becomes a dead weight, if it's always stored
 //! together with the color, but not used. Palette has therefore adopted a
 //! structure where the transparency component (alpha) is attachable using the
-//! [`Alpha`](struct.Alpha.html) type, instead of having copies of each color
+//! [`Alpha`](crate::Alpha) type, instead of having copies of each color
 //! space.
 //!
 //! This approach comes with the extra benefit of allowing operations to
@@ -184,7 +184,7 @@
 //! # Working with Raw Data
 //!
 //! Oftentimes, pixel data is stored in a raw buffer such as a `[u8; 3]`. The
-//! [`Pixel`](encoding/pixel/trait.Pixel.html) trait allows for easy interoperation between
+//! [`Pixel`](crate::encoding::pixel::Pixel) trait allows for easy interoperation between
 //! Palette colors and other crates or systems. `from_raw` can be used to
 //! convert into a Palette color, `into_format` converts from  `Srgb<u8>` to
 //! `Srgb<f32>`, and finally `into_raw` to convert from a Palette color back to

palette/src/luma/luma.rs

@@ -23,15 +23,15 @@ use crate::{
 };
 
 /// Luminance with an alpha component. See the [`Lumaa` implementation
-/// in `Alpha`](struct.Alpha.html#Lumaa).
+/// in `Alpha`](crate::Alpha#Lumaa).
 pub type Lumaa<S = Srgb, T = f32> = Alpha<Luma<S, T>, T>;
 
 /// Luminance.
 ///
 /// Luma is a purely gray scale color space, which is included more for
 /// completeness than anything else, and represents how bright a color is
 /// perceived to be. It's basically the `Y` component of [CIE
-/// XYZ](struct.Xyz.html). The lack of any form of hue representation limits
+/// XYZ](crate::Xyz). The lack of any form of hue representation limits
 /// the set of operations that can be performed on it.
 #[derive(Debug, PartialEq, Pixel, FromColorUnclamped, WithAlpha)]
 #[cfg_attr(feature = "serializing", derive(Serialize, Deserialize))]
@@ -166,7 +166,7 @@ where
     }
 }
 
-///<span id="Lumaa"></span>[`Lumaa`](type.Lumaa.html) implementations.
+///<span id="Lumaa"></span>[`Lumaa`](crate::luma::Lumaa) implementations.
 impl<S, T, A> Alpha<Luma<S, T>, A>
 where
     T: Component,
@@ -212,7 +212,7 @@ where
     }
 }
 
-///<span id="Lumaa"></span>[`Lumaa`](type.Lumaa.html) implementations.
+///<span id="Lumaa"></span>[`Lumaa`](crate::luma::Lumaa) implementations.
 impl<S, T, A> Alpha<Luma<S, T>, A>
 where
     T: FloatComponent,