Struct cosmic::cosmic_theme::palette::Alpha

#[repr(C)]
pub struct Alpha<C, T> {
    pub color: C,
    pub alpha: T,
}

An alpha component wrapper for colors, for adding transparency.

Instead of having separate types for “RGB with alpha”, “HSV with alpha”, and so on, Palette uses this wrapper type to attach the alpha component. The memory representation is the same as if alpha was the last member/property of color, which is just as space efficient. The perk of having a wrapper is that the alpha can easily be added to or separated form any color.

Creating Transparent Values

The color types in Palette have transparent type aliases, such as Srgba for Srgb or Hsla for Hsl. These aliases implement new and other useful methods. Here’s the same example as for Rgb, but with transparency:

use palette::Srgba;

let rgba_u8 = Srgba::new(171u8, 193, 35, 128);
let rgab_f32 = Srgba::new(0.3f32, 0.8, 0.1, 0.5);

// `new` is also `const`:
const RGBA_U8: Srgba<u8> = Srgba::new(171, 193, 35, 128);

// Conversion methods from the color type are usually available for transparent
// values too. For example `into_format` for changing the number format:
let rgb_u8_from_f32 = Srgba::new(0.3f32, 0.8, 0.1, 0.5).into_format::<u8, u8>();

// Hexadecimal is also supported for RGBA, with or without the #:
let rgb_from_hex1: Srgba<u8> = "#f034e65a".parse().unwrap();
let rgb_from_hex2: Srgba<u8> = "f034e65a".parse().unwrap();
assert_eq!(rgb_from_hex1, rgb_from_hex2);

// This includes the shorthand format:
let rgb_from_short_hex: Srgba<u8> = "f3ea".parse().unwrap();
let rgb_from_long_hex: Srgba<u8> = "ff33eeaa".parse().unwrap();
assert_eq!(rgb_from_short_hex, rgb_from_long_hex);

// It's also possible to convert from (and to) arrays, tuples and `u32` values:
let rgb_from_array = Srgba::from([171u8, 193, 35, 128]);
let rgb_from_tuple = Srgba::from((171u8, 193, 35, 128));
let rgb_from_u32 = Srgba::from(0x607F005A);

Opaque values can be made transparent using the WithAlpha trait, in addition to simply wrapping them in Alpha. WithAlpha is also useful in generic code, since it’s implemented for both opaque and transparent types.

use palette::{WithAlpha, Srgb};

let rgb = Srgb::new(171u8, 193, 35);
let rgba = rgb.with_alpha(128u8);
assert_eq!(rgba.alpha, 128);

You may have noticed the u8 in rgb.with_alpha(128u8). That’s because Alpha allows the transparency component to have a different type than the color components. It would be just as valid to write rgb.with_alpha(0.5f32), for example.

Accessing Color Components

To help with the nesting, Alpha implements Deref and DerefMut. This use of the traits is a bit unconventional, since Alpha isn’t a smart pointer. It turned out to be a quite successful experiment that stuck around.

use palette::Srgba;

let rgba = Srgba::new(171u8, 193, 35, 128);
let red = rgba.red; // Accesses `rgba.color.red`.
let alpha = rgba.alpha; // Accesses `rgba.alpha`.
let rgb = rgba.color; // Accesses `rgba.color`;

The main drawback is in generic code:

use palette::Srgba;

fn get_red<T>(rgba: Srgba<T>) -> T {
    rgba.red // Error: cannot move out of dereference of `Alpha<Rgb<_, T>, T>`
}

red has to be accessed through color:

use palette::Srgba;

fn get_red<T>(rgba: Srgba<T>) -> T {
    rgba.color.red
}

Fields

color: C

The color.

alpha: T

The transparency component. 0.0 (or 0u8) is fully transparent and 1.0 (or 255u8) is fully opaque.

Implementations

impl<C, A> Alpha<C, A>

pub fn iter<'a>(&'a self) -> <&'a Alpha<C, A> as IntoIterator>::IntoIter

where &'a Alpha<C, A>: IntoIterator,

Return an iterator over the colors in the wrapped collections.

pub fn iter_mut<'a>( &'a mut self, ) -> <&'a mut Alpha<C, A> as IntoIterator>::IntoIter

where &'a mut Alpha<C, A>: IntoIterator,

Return an iterator that allows modifying the colors in the wrapped collections.

impl<C> Alpha<C, <C as Premultiply>::Scalar>

where C: Premultiply,

pub fn premultiply(self) -> PreAlpha<C>

Alpha mask the color by its transparency.

impl<C, T> Alpha<C, T>

where T: Stimulus,

pub fn min_alpha() -> T

Return the alpha value minimum.

pub fn max_alpha() -> T

Return the alpha value maximum.

impl<T, A> Alpha<Cam16<T>, A>

Cam16a implementations.

pub fn from_xyz<WpParam>( color: Alpha<Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>, A>, parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>, ) -> Alpha<Cam16<T>, A>

where Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>: IntoCam16Unclamped<WpParam, Cam16<T>, Scalar = <T as FromScalar>::Scalar>, T: FromScalar, WpParam: WhitePointParameter<<T as FromScalar>::Scalar>,

Derive CIE CAM16 attributes with transparency for the provided color, under the provided viewing conditions.

use palette::{Srgba, IntoColor, cam16::{Cam16a, Parameters}};

// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);

let rgba = Srgba::new(0.3f32, 0.8, 0.1, 0.9);
let cam16a = Cam16a::from_xyz(rgba.into_color(), example_parameters);

It’s also possible to “pre-bake” the parameters, to avoid recalculate some of the derived values when converting multiple color value.

use palette::{Srgba, IntoColor, cam16::{Cam16a, Parameters}};

// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);

let baked_parameters = example_parameters.bake();

let rgba = Srgba::new(0.3f32, 0.8, 0.1, 0.9);
let cam16a = Cam16a::from_xyz(rgba.into_color(), baked_parameters);

pub fn into_xyz<WpParam>( self, parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>, ) -> Alpha<Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, A>

where Cam16<T>: Cam16IntoUnclamped<WpParam, Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, Scalar = <T as FromScalar>::Scalar>, WpParam: WhitePointParameter<T>, T: FromScalar,

Construct an XYZ color with transparency, that matches these CIE CAM16 attributes, under the provided viewing conditions.

This assumes that all of the correlated attributes are consistent, as only some of them are actually used. You may want to use one of the partial CAM16 representations for more control over which set of attributes that should be.

use palette::{Srgba, FromColor, cam16::{Cam16a, Parameters}};

// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);

let cam16a = get_cam16a_value();
let rgba = Srgba::from_color(cam16a.into_xyz(example_parameters));

It’s also possible to “pre-bake” the parameters, to avoid recalculate some of the derived values when converting multiple color value.

use palette::{Srgba, FromColor, cam16::{Cam16a, Parameters}};

// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);

let baked_parameters = example_parameters.bake();

let cam16a = get_cam16a_value();
let rgba = Srgba::from_color(cam16a.into_xyz(baked_parameters));

impl<T, A> Alpha<Cam16Jch<T>, A>

“Cam16Jcha implementations.

pub fn new<H>( lightness: T, chroma: T, hue: H, alpha: A, ) -> Alpha<Cam16Jch<T>, A>

where H: Into<Cam16Hue<T>>,

Create a partial CIE CAM16 color with transparency.

pub const fn new_const( lightness: T, chroma: T, hue: Cam16Hue<T>, alpha: A, ) -> Alpha<Cam16Jch<T>, A>

Create a partial CIE CAM16 color with transparency. This is the same as Cam16Jch::new without the generic hue type. It’s temporary until const fn supports traits.

pub fn into_components(self) -> (T, T, Cam16Hue<T>, A)

Convert to a (lightness, chroma, hue, alpha) tuple.

pub fn from_components<H>(_: (T, T, H, A)) -> Alpha<Cam16Jch<T>, A>

where H: Into<Cam16Hue<T>>,

Convert from a (lightness, chroma, hue, alpha) tuple.

pub fn from_xyz<WpParam>( color: Alpha<Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>, A>, parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>, ) -> Alpha<Cam16Jch<T>, A>

where Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>: IntoCam16Unclamped<WpParam, Cam16Jch<T>, Scalar = <T as FromScalar>::Scalar>, T: FromScalar, WpParam: WhitePointParameter<<T as FromScalar>::Scalar>,

Derive partial CIE CAM16 attributes with transparency, for the provided color, under the provided viewing conditions.

use palette::{Srgba, IntoColor, cam16::{Cam16Jcha, Parameters}};

// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);

let rgba = Srgba::new(0.3f32, 0.8, 0.1, 0.9);
let partial = Cam16Jcha::from_xyz(rgba.into_color(), example_parameters);

It’s also possible to “pre-bake” the parameters, to avoid recalculate some of the derived values when converting multiple color value.

use palette::{Srgba, IntoColor, cam16::{Cam16Jcha, Parameters}};

// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);

let baked_parameters = example_parameters.bake();

let rgba = Srgba::new(0.3f32, 0.8, 0.1, 0.9);
let partial = Cam16Jcha::from_xyz(rgba.into_color(), baked_parameters);

pub fn into_xyz<WpParam>( self, parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>, ) -> Alpha<Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, A>

where Cam16Jch<T>: Cam16IntoUnclamped<WpParam, Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, Scalar = <T as FromScalar>::Scalar>, WpParam: WhitePointParameter<T>, T: FromScalar,

Construct an XYZ color with transparency, from these CIE CAM16 attributes, under the provided viewing conditions.

use palette::{Srgba, FromColor, cam16::{Cam16Jcha, Parameters}};

// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);

let partial = Cam16Jcha::new(50.0f32, 80.0, 120.0, 0.9);
let rgba = Srgba::from_color(partial.into_xyz(example_parameters));

It’s also possible to “pre-bake” the parameters, to avoid recalculate some of the derived values when converting multiple color value.

use palette::{Srgba, FromColor, cam16::{Cam16Jcha, Parameters}};

// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);

let baked_parameters = example_parameters.bake();

let partial = Cam16Jcha::new(50.0f32, 80.0, 120.0, 0.9);
let rgba = Srgba::from_color(partial.into_xyz(baked_parameters));

pub fn from_full(full: Alpha<Cam16<T>, A>) -> Alpha<Cam16Jch<T>, A>

Create a partial set of CIE CAM16 attributes with transparency.

It’s also possible to use Cam16Jcha::from or Cam16a::into.

pub fn into_full<WpParam>( self, parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>, ) -> Alpha<Cam16<T>, A>

where Cam16Jch<T>: IntoCam16Unclamped<WpParam, Cam16<T>, Scalar = <T as FromScalar>::Scalar>, WpParam: WhitePointParameter<T>, T: FromScalar,

Reconstruct a full set of CIE CAM16 attributes with transparency, using the original viewing conditions.

use palette::{Srgba, IntoColor, cam16::{Cam16a, Cam16Jcha, Parameters}};
use approx::assert_relative_eq;

// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);

// Optional, but saves some work:
let baked_parameters = example_parameters.bake();

let rgba = Srgba::new(0.3f64, 0.8, 0.1, 0.9);
let cam16a = Cam16a::from_xyz(rgba.into_color(), baked_parameters);
let partial = Cam16Jcha::from(cam16a);
let reconstructed = partial.into_full(baked_parameters);

assert_relative_eq!(cam16a, reconstructed, epsilon = 0.0000000000001);

impl<T, A> Alpha<Cam16Jch<&T>, &A>

pub fn copied(&self) -> Alpha<Cam16Jch<T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Cam16Jch<T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<T, A> Alpha<Cam16Jch<&mut T>, &mut A>

pub fn set(&mut self, value: Alpha<Cam16Jch<T>, A>)

Update this color with new values.

pub fn as_refs(&self) -> Alpha<Cam16Jch<&T>, &A>

Borrow this color’s components as shared references.

pub fn copied(&self) -> Alpha<Cam16Jch<T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Cam16Jch<T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<Ct, Ca> Alpha<Cam16Jch<Ct>, Ca>

pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Cam16Jch<&'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsRef<[T]>, Ca: AsRef<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, with references to the components at index. See slice::get for details.

pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Cam16Jch<&'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsMut<[T]>, Ca: AsMut<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, that allows modifying the components at index. See slice::get_mut for details.

impl<T, A> Alpha<Cam16Jch<Vec<T>>, Vec<A>>

pub fn with_capacity(capacity: usize) -> Alpha<Cam16Jch<Vec<T>>, Vec<A>>

Create a struct of vectors with a minimum capacity. See Vec::with_capacity for details.

pub fn push(&mut self, value: Alpha<Cam16Jch<T>, A>)

Push an additional color’s components onto the component vectors. See Vec::push for details.

pub fn pop(&mut self) -> Option<Alpha<Cam16Jch<T>, A>>

Pop a color’s components from the component vectors. See Vec::pop for details.

pub fn clear(&mut self)

Clear the component vectors. See Vec::clear for details.

pub fn drain<R>(&mut self, range: R) -> Iter<Iter<Drain<'_, T>>, Drain<'_, A>>

where R: RangeBounds<usize> + Clone,

Return an iterator that moves colors out of the specified range.

impl<T, A> Alpha<Cam16Jmh<T>, A>

“Cam16Jmha implementations.

pub fn new<H>( lightness: T, colorfulness: T, hue: H, alpha: A, ) -> Alpha<Cam16Jmh<T>, A>

where H: Into<Cam16Hue<T>>,

Create a partial CIE CAM16 color with transparency.

pub const fn new_const( lightness: T, colorfulness: T, hue: Cam16Hue<T>, alpha: A, ) -> Alpha<Cam16Jmh<T>, A>

Create a partial CIE CAM16 color with transparency. This is the same as Cam16Jmh::new without the generic hue type. It’s temporary until const fn supports traits.

pub fn into_components(self) -> (T, T, Cam16Hue<T>, A)

Convert to a (lightness, colorfulness, hue, alpha) tuple.

pub fn from_components<H>(_: (T, T, H, A)) -> Alpha<Cam16Jmh<T>, A>

where H: Into<Cam16Hue<T>>,

Convert from a (lightness, colorfulness, hue, alpha) tuple.

pub fn from_xyz<WpParam>( color: Alpha<Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>, A>, parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>, ) -> Alpha<Cam16Jmh<T>, A>

where Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>: IntoCam16Unclamped<WpParam, Cam16Jmh<T>, Scalar = <T as FromScalar>::Scalar>, T: FromScalar, WpParam: WhitePointParameter<<T as FromScalar>::Scalar>,

Derive partial CIE CAM16 attributes with transparency, for the provided color, under the provided viewing conditions.

use palette::{Srgba, IntoColor, cam16::{Cam16Jmha, Parameters}};

// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);

let rgba = Srgba::new(0.3f32, 0.8, 0.1, 0.9);
let partial = Cam16Jmha::from_xyz(rgba.into_color(), example_parameters);

It’s also possible to “pre-bake” the parameters, to avoid recalculate some of the derived values when converting multiple color value.

use palette::{Srgba, IntoColor, cam16::{Cam16Jmha, Parameters}};

// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);

let baked_parameters = example_parameters.bake();

let rgba = Srgba::new(0.3f32, 0.8, 0.1, 0.9);
let partial = Cam16Jmha::from_xyz(rgba.into_color(), baked_parameters);

pub fn into_xyz<WpParam>( self, parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>, ) -> Alpha<Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, A>

where Cam16Jmh<T>: Cam16IntoUnclamped<WpParam, Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, Scalar = <T as FromScalar>::Scalar>, WpParam: WhitePointParameter<T>, T: FromScalar,

Construct an XYZ color with transparency, from these CIE CAM16 attributes, under the provided viewing conditions.

use palette::{Srgba, FromColor, cam16::{Cam16Jmha, Parameters}};

// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);

let partial = Cam16Jmha::new(50.0f32, 80.0, 120.0, 0.9);
let rgba = Srgba::from_color(partial.into_xyz(example_parameters));

It’s also possible to “pre-bake” the parameters, to avoid recalculate some of the derived values when converting multiple color value.

use palette::{Srgba, FromColor, cam16::{Cam16Jmha, Parameters}};

// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);

let baked_parameters = example_parameters.bake();

let partial = Cam16Jmha::new(50.0f32, 80.0, 120.0, 0.9);
let rgba = Srgba::from_color(partial.into_xyz(baked_parameters));

pub fn from_full(full: Alpha<Cam16<T>, A>) -> Alpha<Cam16Jmh<T>, A>

Create a partial set of CIE CAM16 attributes with transparency.

It’s also possible to use Cam16Jmha::from or Cam16a::into.

pub fn into_full<WpParam>( self, parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>, ) -> Alpha<Cam16<T>, A>

where Cam16Jmh<T>: IntoCam16Unclamped<WpParam, Cam16<T>, Scalar = <T as FromScalar>::Scalar>, WpParam: WhitePointParameter<T>, T: FromScalar,

Reconstruct a full set of CIE CAM16 attributes with transparency, using the original viewing conditions.

use palette::{Srgba, IntoColor, cam16::{Cam16a, Cam16Jmha, Parameters}};
use approx::assert_relative_eq;

// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);

// Optional, but saves some work:
let baked_parameters = example_parameters.bake();

let rgba = Srgba::new(0.3f64, 0.8, 0.1, 0.9);
let cam16a = Cam16a::from_xyz(rgba.into_color(), baked_parameters);
let partial = Cam16Jmha::from(cam16a);
let reconstructed = partial.into_full(baked_parameters);

assert_relative_eq!(cam16a, reconstructed, epsilon = 0.0000000000001);

impl<T, A> Alpha<Cam16Jmh<&T>, &A>

pub fn copied(&self) -> Alpha<Cam16Jmh<T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Cam16Jmh<T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<T, A> Alpha<Cam16Jmh<&mut T>, &mut A>

pub fn set(&mut self, value: Alpha<Cam16Jmh<T>, A>)

Update this color with new values.

pub fn as_refs(&self) -> Alpha<Cam16Jmh<&T>, &A>

Borrow this color’s components as shared references.

pub fn copied(&self) -> Alpha<Cam16Jmh<T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Cam16Jmh<T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<Ct, Ca> Alpha<Cam16Jmh<Ct>, Ca>

pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Cam16Jmh<&'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsRef<[T]>, Ca: AsRef<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, with references to the components at index. See slice::get for details.

pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Cam16Jmh<&'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsMut<[T]>, Ca: AsMut<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, that allows modifying the components at index. See slice::get_mut for details.

impl<T, A> Alpha<Cam16Jmh<Vec<T>>, Vec<A>>

pub fn with_capacity(capacity: usize) -> Alpha<Cam16Jmh<Vec<T>>, Vec<A>>

Create a struct of vectors with a minimum capacity. See Vec::with_capacity for details.

pub fn push(&mut self, value: Alpha<Cam16Jmh<T>, A>)

Push an additional color’s components onto the component vectors. See Vec::push for details.

pub fn pop(&mut self) -> Option<Alpha<Cam16Jmh<T>, A>>

Pop a color’s components from the component vectors. See Vec::pop for details.

pub fn clear(&mut self)

Clear the component vectors. See Vec::clear for details.

pub fn drain<R>(&mut self, range: R) -> Iter<Iter<Drain<'_, T>>, Drain<'_, A>>

where R: RangeBounds<usize> + Clone,

Return an iterator that moves colors out of the specified range.

impl<T, A> Alpha<Cam16Jsh<T>, A>

“Cam16Jsha implementations.

pub fn new<H>( lightness: T, saturation: T, hue: H, alpha: A, ) -> Alpha<Cam16Jsh<T>, A>

where H: Into<Cam16Hue<T>>,

Create a partial CIE CAM16 color with transparency.

pub const fn new_const( lightness: T, saturation: T, hue: Cam16Hue<T>, alpha: A, ) -> Alpha<Cam16Jsh<T>, A>

Create a partial CIE CAM16 color with transparency. This is the same as Cam16Jsh::new without the generic hue type. It’s temporary until const fn supports traits.

pub fn into_components(self) -> (T, T, Cam16Hue<T>, A)

Convert to a (lightness, saturation, hue, alpha) tuple.

pub fn from_components<H>(_: (T, T, H, A)) -> Alpha<Cam16Jsh<T>, A>

where H: Into<Cam16Hue<T>>,

Convert from a (lightness, saturation, hue, alpha) tuple.

pub fn from_xyz<WpParam>( color: Alpha<Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>, A>, parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>, ) -> Alpha<Cam16Jsh<T>, A>

where Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>: IntoCam16Unclamped<WpParam, Cam16Jsh<T>, Scalar = <T as FromScalar>::Scalar>, T: FromScalar, WpParam: WhitePointParameter<<T as FromScalar>::Scalar>,

Derive partial CIE CAM16 attributes with transparency, for the provided color, under the provided viewing conditions.

use palette::{Srgba, IntoColor, cam16::{Cam16Jsha, Parameters}};

// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);

let rgba = Srgba::new(0.3f32, 0.8, 0.1, 0.9);
let partial = Cam16Jsha::from_xyz(rgba.into_color(), example_parameters);

It’s also possible to “pre-bake” the parameters, to avoid recalculate some of the derived values when converting multiple color value.

use palette::{Srgba, IntoColor, cam16::{Cam16Jsha, Parameters}};

// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);

let baked_parameters = example_parameters.bake();

let rgba = Srgba::new(0.3f32, 0.8, 0.1, 0.9);
let partial = Cam16Jsha::from_xyz(rgba.into_color(), baked_parameters);

pub fn into_xyz<WpParam>( self, parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>, ) -> Alpha<Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, A>

where Cam16Jsh<T>: Cam16IntoUnclamped<WpParam, Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, Scalar = <T as FromScalar>::Scalar>, WpParam: WhitePointParameter<T>, T: FromScalar,

Construct an XYZ color with transparency, from these CIE CAM16 attributes, under the provided viewing conditions.

use palette::{Srgba, FromColor, cam16::{Cam16Jsha, Parameters}};

// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);

let partial = Cam16Jsha::new(50.0f32, 80.0, 120.0, 0.9);
let rgba = Srgba::from_color(partial.into_xyz(example_parameters));

It’s also possible to “pre-bake” the parameters, to avoid recalculate some of the derived values when converting multiple color value.

use palette::{Srgba, FromColor, cam16::{Cam16Jsha, Parameters}};

// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);

let baked_parameters = example_parameters.bake();

let partial = Cam16Jsha::new(50.0f32, 80.0, 120.0, 0.9);
let rgba = Srgba::from_color(partial.into_xyz(baked_parameters));

pub fn from_full(full: Alpha<Cam16<T>, A>) -> Alpha<Cam16Jsh<T>, A>

Create a partial set of CIE CAM16 attributes with transparency.

It’s also possible to use Cam16Jsha::from or Cam16a::into.

pub fn into_full<WpParam>( self, parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>, ) -> Alpha<Cam16<T>, A>

where Cam16Jsh<T>: IntoCam16Unclamped<WpParam, Cam16<T>, Scalar = <T as FromScalar>::Scalar>, WpParam: WhitePointParameter<T>, T: FromScalar,

Reconstruct a full set of CIE CAM16 attributes with transparency, using the original viewing conditions.

use palette::{Srgba, IntoColor, cam16::{Cam16a, Cam16Jsha, Parameters}};
use approx::assert_relative_eq;

// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);

// Optional, but saves some work:
let baked_parameters = example_parameters.bake();

let rgba = Srgba::new(0.3f64, 0.8, 0.1, 0.9);
let cam16a = Cam16a::from_xyz(rgba.into_color(), baked_parameters);
let partial = Cam16Jsha::from(cam16a);
let reconstructed = partial.into_full(baked_parameters);

assert_relative_eq!(cam16a, reconstructed, epsilon = 0.0000000000001);

impl<T, A> Alpha<Cam16Jsh<&T>, &A>

pub fn copied(&self) -> Alpha<Cam16Jsh<T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Cam16Jsh<T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<T, A> Alpha<Cam16Jsh<&mut T>, &mut A>

pub fn set(&mut self, value: Alpha<Cam16Jsh<T>, A>)

Update this color with new values.

pub fn as_refs(&self) -> Alpha<Cam16Jsh<&T>, &A>

Borrow this color’s components as shared references.

pub fn copied(&self) -> Alpha<Cam16Jsh<T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Cam16Jsh<T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<Ct, Ca> Alpha<Cam16Jsh<Ct>, Ca>

pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Cam16Jsh<&'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsRef<[T]>, Ca: AsRef<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, with references to the components at index. See slice::get for details.

pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Cam16Jsh<&'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsMut<[T]>, Ca: AsMut<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, that allows modifying the components at index. See slice::get_mut for details.

impl<T, A> Alpha<Cam16Jsh<Vec<T>>, Vec<A>>

pub fn with_capacity(capacity: usize) -> Alpha<Cam16Jsh<Vec<T>>, Vec<A>>

Create a struct of vectors with a minimum capacity. See Vec::with_capacity for details.

pub fn push(&mut self, value: Alpha<Cam16Jsh<T>, A>)

Push an additional color’s components onto the component vectors. See Vec::push for details.

pub fn pop(&mut self) -> Option<Alpha<Cam16Jsh<T>, A>>

Pop a color’s components from the component vectors. See Vec::pop for details.

pub fn clear(&mut self)

Clear the component vectors. See Vec::clear for details.

pub fn drain<R>(&mut self, range: R) -> Iter<Iter<Drain<'_, T>>, Drain<'_, A>>

where R: RangeBounds<usize> + Clone,

Return an iterator that moves colors out of the specified range.

impl<T, A> Alpha<Cam16Qch<T>, A>

“Cam16Qcha implementations.

pub fn new<H>( brightness: T, chroma: T, hue: H, alpha: A, ) -> Alpha<Cam16Qch<T>, A>

where H: Into<Cam16Hue<T>>,

Create a partial CIE CAM16 color with transparency.

pub const fn new_const( brightness: T, chroma: T, hue: Cam16Hue<T>, alpha: A, ) -> Alpha<Cam16Qch<T>, A>

Create a partial CIE CAM16 color with transparency. This is the same as Cam16Qch::new without the generic hue type. It’s temporary until const fn supports traits.

pub fn into_components(self) -> (T, T, Cam16Hue<T>, A)

Convert to a (brightness, chroma, hue, alpha) tuple.

pub fn from_components<H>(_: (T, T, H, A)) -> Alpha<Cam16Qch<T>, A>

where H: Into<Cam16Hue<T>>,

Convert from a (brightness, chroma, hue, alpha) tuple.

pub fn from_xyz<WpParam>( color: Alpha<Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>, A>, parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>, ) -> Alpha<Cam16Qch<T>, A>

where Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>: IntoCam16Unclamped<WpParam, Cam16Qch<T>, Scalar = <T as FromScalar>::Scalar>, T: FromScalar, WpParam: WhitePointParameter<<T as FromScalar>::Scalar>,

Derive partial CIE CAM16 attributes with transparency, for the provided color, under the provided viewing conditions.

use palette::{Srgba, IntoColor, cam16::{Cam16Qcha, Parameters}};

// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);

let rgba = Srgba::new(0.3f32, 0.8, 0.1, 0.9);
let partial = Cam16Qcha::from_xyz(rgba.into_color(), example_parameters);

It’s also possible to “pre-bake” the parameters, to avoid recalculate some of the derived values when converting multiple color value.

use palette::{Srgba, IntoColor, cam16::{Cam16Qcha, Parameters}};

// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);

let baked_parameters = example_parameters.bake();

let rgba = Srgba::new(0.3f32, 0.8, 0.1, 0.9);
let partial = Cam16Qcha::from_xyz(rgba.into_color(), baked_parameters);

pub fn into_xyz<WpParam>( self, parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>, ) -> Alpha<Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, A>

where Cam16Qch<T>: Cam16IntoUnclamped<WpParam, Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, Scalar = <T as FromScalar>::Scalar>, WpParam: WhitePointParameter<T>, T: FromScalar,

Construct an XYZ color with transparency, from these CIE CAM16 attributes, under the provided viewing conditions.

use palette::{Srgba, FromColor, cam16::{Cam16Qcha, Parameters}};

// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);

let partial = Cam16Qcha::new(50.0f32, 80.0, 120.0, 0.9);
let rgba = Srgba::from_color(partial.into_xyz(example_parameters));

It’s also possible to “pre-bake” the parameters, to avoid recalculate some of the derived values when converting multiple color value.

use palette::{Srgba, FromColor, cam16::{Cam16Qcha, Parameters}};

// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);

let baked_parameters = example_parameters.bake();

let partial = Cam16Qcha::new(50.0f32, 80.0, 120.0, 0.9);
let rgba = Srgba::from_color(partial.into_xyz(baked_parameters));

pub fn from_full(full: Alpha<Cam16<T>, A>) -> Alpha<Cam16Qch<T>, A>

Create a partial set of CIE CAM16 attributes with transparency.

It’s also possible to use Cam16Qcha::from or Cam16a::into.

pub fn into_full<WpParam>( self, parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>, ) -> Alpha<Cam16<T>, A>

where Cam16Qch<T>: IntoCam16Unclamped<WpParam, Cam16<T>, Scalar = <T as FromScalar>::Scalar>, WpParam: WhitePointParameter<T>, T: FromScalar,

Reconstruct a full set of CIE CAM16 attributes with transparency, using the original viewing conditions.

use palette::{Srgba, IntoColor, cam16::{Cam16a, Cam16Qcha, Parameters}};
use approx::assert_relative_eq;

// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);

// Optional, but saves some work:
let baked_parameters = example_parameters.bake();

let rgba = Srgba::new(0.3f64, 0.8, 0.1, 0.9);
let cam16a = Cam16a::from_xyz(rgba.into_color(), baked_parameters);
let partial = Cam16Qcha::from(cam16a);
let reconstructed = partial.into_full(baked_parameters);

assert_relative_eq!(cam16a, reconstructed, epsilon = 0.0000000000001);

impl<T, A> Alpha<Cam16Qch<&T>, &A>

pub fn copied(&self) -> Alpha<Cam16Qch<T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Cam16Qch<T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<T, A> Alpha<Cam16Qch<&mut T>, &mut A>

pub fn set(&mut self, value: Alpha<Cam16Qch<T>, A>)

Update this color with new values.

pub fn as_refs(&self) -> Alpha<Cam16Qch<&T>, &A>

Borrow this color’s components as shared references.

pub fn copied(&self) -> Alpha<Cam16Qch<T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Cam16Qch<T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<Ct, Ca> Alpha<Cam16Qch<Ct>, Ca>

pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Cam16Qch<&'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsRef<[T]>, Ca: AsRef<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, with references to the components at index. See slice::get for details.

pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Cam16Qch<&'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsMut<[T]>, Ca: AsMut<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, that allows modifying the components at index. See slice::get_mut for details.

impl<T, A> Alpha<Cam16Qch<Vec<T>>, Vec<A>>

pub fn with_capacity(capacity: usize) -> Alpha<Cam16Qch<Vec<T>>, Vec<A>>

Create a struct of vectors with a minimum capacity. See Vec::with_capacity for details.

pub fn push(&mut self, value: Alpha<Cam16Qch<T>, A>)

Push an additional color’s components onto the component vectors. See Vec::push for details.

pub fn pop(&mut self) -> Option<Alpha<Cam16Qch<T>, A>>

Pop a color’s components from the component vectors. See Vec::pop for details.

pub fn clear(&mut self)

Clear the component vectors. See Vec::clear for details.

pub fn drain<R>(&mut self, range: R) -> Iter<Iter<Drain<'_, T>>, Drain<'_, A>>

where R: RangeBounds<usize> + Clone,

Return an iterator that moves colors out of the specified range.

impl<T, A> Alpha<Cam16Qmh<T>, A>

“Cam16Qmha implementations.

pub fn new<H>( brightness: T, colorfulness: T, hue: H, alpha: A, ) -> Alpha<Cam16Qmh<T>, A>

where H: Into<Cam16Hue<T>>,

Create a partial CIE CAM16 color with transparency.

pub const fn new_const( brightness: T, colorfulness: T, hue: Cam16Hue<T>, alpha: A, ) -> Alpha<Cam16Qmh<T>, A>

Create a partial CIE CAM16 color with transparency. This is the same as Cam16Qmh::new without the generic hue type. It’s temporary until const fn supports traits.

pub fn into_components(self) -> (T, T, Cam16Hue<T>, A)

Convert to a (brightness, colorfulness, hue, alpha) tuple.

pub fn from_components<H>(_: (T, T, H, A)) -> Alpha<Cam16Qmh<T>, A>

where H: Into<Cam16Hue<T>>,

Convert from a (brightness, colorfulness, hue, alpha) tuple.

pub fn from_xyz<WpParam>( color: Alpha<Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>, A>, parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>, ) -> Alpha<Cam16Qmh<T>, A>

where Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>: IntoCam16Unclamped<WpParam, Cam16Qmh<T>, Scalar = <T as FromScalar>::Scalar>, T: FromScalar, WpParam: WhitePointParameter<<T as FromScalar>::Scalar>,

Derive partial CIE CAM16 attributes with transparency, for the provided color, under the provided viewing conditions.

use palette::{Srgba, IntoColor, cam16::{Cam16Qmha, Parameters}};

// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);

let rgba = Srgba::new(0.3f32, 0.8, 0.1, 0.9);
let partial = Cam16Qmha::from_xyz(rgba.into_color(), example_parameters);

It’s also possible to “pre-bake” the parameters, to avoid recalculate some of the derived values when converting multiple color value.

use palette::{Srgba, IntoColor, cam16::{Cam16Qmha, Parameters}};

// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);

let baked_parameters = example_parameters.bake();

let rgba = Srgba::new(0.3f32, 0.8, 0.1, 0.9);
let partial = Cam16Qmha::from_xyz(rgba.into_color(), baked_parameters);

pub fn into_xyz<WpParam>( self, parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>, ) -> Alpha<Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, A>

where Cam16Qmh<T>: Cam16IntoUnclamped<WpParam, Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, Scalar = <T as FromScalar>::Scalar>, WpParam: WhitePointParameter<T>, T: FromScalar,

Construct an XYZ color with transparency, from these CIE CAM16 attributes, under the provided viewing conditions.

use palette::{Srgba, FromColor, cam16::{Cam16Qmha, Parameters}};

// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);

let partial = Cam16Qmha::new(50.0f32, 80.0, 120.0, 0.9);
let rgba = Srgba::from_color(partial.into_xyz(example_parameters));

It’s also possible to “pre-bake” the parameters, to avoid recalculate some of the derived values when converting multiple color value.

use palette::{Srgba, FromColor, cam16::{Cam16Qmha, Parameters}};

// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);

let baked_parameters = example_parameters.bake();

let partial = Cam16Qmha::new(50.0f32, 80.0, 120.0, 0.9);
let rgba = Srgba::from_color(partial.into_xyz(baked_parameters));

pub fn from_full(full: Alpha<Cam16<T>, A>) -> Alpha<Cam16Qmh<T>, A>

Create a partial set of CIE CAM16 attributes with transparency.

It’s also possible to use Cam16Qmha::from or Cam16a::into.

pub fn into_full<WpParam>( self, parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>, ) -> Alpha<Cam16<T>, A>

where Cam16Qmh<T>: IntoCam16Unclamped<WpParam, Cam16<T>, Scalar = <T as FromScalar>::Scalar>, WpParam: WhitePointParameter<T>, T: FromScalar,

Reconstruct a full set of CIE CAM16 attributes with transparency, using the original viewing conditions.

use palette::{Srgba, IntoColor, cam16::{Cam16a, Cam16Qmha, Parameters}};
use approx::assert_relative_eq;

// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);

// Optional, but saves some work:
let baked_parameters = example_parameters.bake();

let rgba = Srgba::new(0.3f64, 0.8, 0.1, 0.9);
let cam16a = Cam16a::from_xyz(rgba.into_color(), baked_parameters);
let partial = Cam16Qmha::from(cam16a);
let reconstructed = partial.into_full(baked_parameters);

assert_relative_eq!(cam16a, reconstructed, epsilon = 0.0000000000001);

impl<T, A> Alpha<Cam16Qmh<&T>, &A>

pub fn copied(&self) -> Alpha<Cam16Qmh<T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Cam16Qmh<T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<T, A> Alpha<Cam16Qmh<&mut T>, &mut A>

pub fn set(&mut self, value: Alpha<Cam16Qmh<T>, A>)

Update this color with new values.

pub fn as_refs(&self) -> Alpha<Cam16Qmh<&T>, &A>

Borrow this color’s components as shared references.

pub fn copied(&self) -> Alpha<Cam16Qmh<T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Cam16Qmh<T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<Ct, Ca> Alpha<Cam16Qmh<Ct>, Ca>

pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Cam16Qmh<&'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsRef<[T]>, Ca: AsRef<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, with references to the components at index. See slice::get for details.

pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Cam16Qmh<&'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsMut<[T]>, Ca: AsMut<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, that allows modifying the components at index. See slice::get_mut for details.

impl<T, A> Alpha<Cam16Qmh<Vec<T>>, Vec<A>>

pub fn with_capacity(capacity: usize) -> Alpha<Cam16Qmh<Vec<T>>, Vec<A>>

Create a struct of vectors with a minimum capacity. See Vec::with_capacity for details.

pub fn push(&mut self, value: Alpha<Cam16Qmh<T>, A>)

Push an additional color’s components onto the component vectors. See Vec::push for details.

pub fn pop(&mut self) -> Option<Alpha<Cam16Qmh<T>, A>>

Pop a color’s components from the component vectors. See Vec::pop for details.

pub fn clear(&mut self)

Clear the component vectors. See Vec::clear for details.

pub fn drain<R>(&mut self, range: R) -> Iter<Iter<Drain<'_, T>>, Drain<'_, A>>

where R: RangeBounds<usize> + Clone,

Return an iterator that moves colors out of the specified range.

impl<T, A> Alpha<Cam16Qsh<T>, A>

“Cam16Qsha implementations.

pub fn new<H>( brightness: T, saturation: T, hue: H, alpha: A, ) -> Alpha<Cam16Qsh<T>, A>

where H: Into<Cam16Hue<T>>,

Create a partial CIE CAM16 color with transparency.

pub const fn new_const( brightness: T, saturation: T, hue: Cam16Hue<T>, alpha: A, ) -> Alpha<Cam16Qsh<T>, A>

Create a partial CIE CAM16 color with transparency. This is the same as Cam16Qsh::new without the generic hue type. It’s temporary until const fn supports traits.

pub fn into_components(self) -> (T, T, Cam16Hue<T>, A)

Convert to a (brightness, saturation, hue, alpha) tuple.

pub fn from_components<H>(_: (T, T, H, A)) -> Alpha<Cam16Qsh<T>, A>

where H: Into<Cam16Hue<T>>,

Convert from a (brightness, saturation, hue, alpha) tuple.

pub fn from_xyz<WpParam>( color: Alpha<Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>, A>, parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>, ) -> Alpha<Cam16Qsh<T>, A>

where Xyz<<WpParam as WhitePointParameter<<T as FromScalar>::Scalar>>::StaticWp, T>: IntoCam16Unclamped<WpParam, Cam16Qsh<T>, Scalar = <T as FromScalar>::Scalar>, T: FromScalar, WpParam: WhitePointParameter<<T as FromScalar>::Scalar>,

Derive partial CIE CAM16 attributes with transparency, for the provided color, under the provided viewing conditions.

use palette::{Srgba, IntoColor, cam16::{Cam16Qsha, Parameters}};

// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);

let rgba = Srgba::new(0.3f32, 0.8, 0.1, 0.9);
let partial = Cam16Qsha::from_xyz(rgba.into_color(), example_parameters);

It’s also possible to “pre-bake” the parameters, to avoid recalculate some of the derived values when converting multiple color value.

use palette::{Srgba, IntoColor, cam16::{Cam16Qsha, Parameters}};

// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);

let baked_parameters = example_parameters.bake();

let rgba = Srgba::new(0.3f32, 0.8, 0.1, 0.9);
let partial = Cam16Qsha::from_xyz(rgba.into_color(), baked_parameters);

pub fn into_xyz<WpParam>( self, parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>, ) -> Alpha<Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, A>

where Cam16Qsh<T>: Cam16IntoUnclamped<WpParam, Xyz<<WpParam as WhitePointParameter<T>>::StaticWp, T>, Scalar = <T as FromScalar>::Scalar>, WpParam: WhitePointParameter<T>, T: FromScalar,

Construct an XYZ color with transparency, from these CIE CAM16 attributes, under the provided viewing conditions.

use palette::{Srgba, FromColor, cam16::{Cam16Qsha, Parameters}};

// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);

let partial = Cam16Qsha::new(50.0f32, 80.0, 120.0, 0.9);
let rgba = Srgba::from_color(partial.into_xyz(example_parameters));

It’s also possible to “pre-bake” the parameters, to avoid recalculate some of the derived values when converting multiple color value.

use palette::{Srgba, FromColor, cam16::{Cam16Qsha, Parameters}};

// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);

let baked_parameters = example_parameters.bake();

let partial = Cam16Qsha::new(50.0f32, 80.0, 120.0, 0.9);
let rgba = Srgba::from_color(partial.into_xyz(baked_parameters));

pub fn from_full(full: Alpha<Cam16<T>, A>) -> Alpha<Cam16Qsh<T>, A>

Create a partial set of CIE CAM16 attributes with transparency.

It’s also possible to use Cam16Qsha::from or Cam16a::into.

pub fn into_full<WpParam>( self, parameters: impl Into<BakedParameters<WpParam, <T as FromScalar>::Scalar>>, ) -> Alpha<Cam16<T>, A>

where Cam16Qsh<T>: IntoCam16Unclamped<WpParam, Cam16<T>, Scalar = <T as FromScalar>::Scalar>, WpParam: WhitePointParameter<T>, T: FromScalar,

Reconstruct a full set of CIE CAM16 attributes with transparency, using the original viewing conditions.

use palette::{Srgba, IntoColor, cam16::{Cam16a, Cam16Qsha, Parameters}};
use approx::assert_relative_eq;

// Customize these according to the viewing conditions:
let mut example_parameters = Parameters::default_static_wp(40.0);

// Optional, but saves some work:
let baked_parameters = example_parameters.bake();

let rgba = Srgba::new(0.3f64, 0.8, 0.1, 0.9);
let cam16a = Cam16a::from_xyz(rgba.into_color(), baked_parameters);
let partial = Cam16Qsha::from(cam16a);
let reconstructed = partial.into_full(baked_parameters);

assert_relative_eq!(cam16a, reconstructed, epsilon = 0.0000000000001);

impl<T, A> Alpha<Cam16Qsh<&T>, &A>

pub fn copied(&self) -> Alpha<Cam16Qsh<T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Cam16Qsh<T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<T, A> Alpha<Cam16Qsh<&mut T>, &mut A>

pub fn set(&mut self, value: Alpha<Cam16Qsh<T>, A>)

Update this color with new values.

pub fn as_refs(&self) -> Alpha<Cam16Qsh<&T>, &A>

Borrow this color’s components as shared references.

pub fn copied(&self) -> Alpha<Cam16Qsh<T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Cam16Qsh<T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<Ct, Ca> Alpha<Cam16Qsh<Ct>, Ca>

pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Cam16Qsh<&'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsRef<[T]>, Ca: AsRef<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, with references to the components at index. See slice::get for details.

pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Cam16Qsh<&'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsMut<[T]>, Ca: AsMut<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, that allows modifying the components at index. See slice::get_mut for details.

impl<T, A> Alpha<Cam16Qsh<Vec<T>>, Vec<A>>

pub fn with_capacity(capacity: usize) -> Alpha<Cam16Qsh<Vec<T>>, Vec<A>>

Create a struct of vectors with a minimum capacity. See Vec::with_capacity for details.

pub fn push(&mut self, value: Alpha<Cam16Qsh<T>, A>)

Push an additional color’s components onto the component vectors. See Vec::push for details.

pub fn pop(&mut self) -> Option<Alpha<Cam16Qsh<T>, A>>

Pop a color’s components from the component vectors. See Vec::pop for details.

pub fn clear(&mut self)

Clear the component vectors. See Vec::clear for details.

pub fn drain<R>(&mut self, range: R) -> Iter<Iter<Drain<'_, T>>, Drain<'_, A>>

where R: RangeBounds<usize> + Clone,

Return an iterator that moves colors out of the specified range.

impl<T, A> Alpha<Cam16UcsJab<T>, A>

Cam16UcsJaba implementations.

pub const fn new(lightness: T, a: T, b: T, alpha: A) -> Alpha<Cam16UcsJab<T>, A>

Create a CAM16-UCS J’ a’ b’ color with transparency.

pub fn into_components(self) -> (T, T, T, A)

Convert to a (J', a', b', a) tuple.

pub fn from_components(_: (T, T, T, A)) -> Alpha<Cam16UcsJab<T>, A>

Convert from a (J', a', b', a) tuple.

impl<T, A> Alpha<Cam16UcsJab<&T>, &A>

pub fn copied(&self) -> Alpha<Cam16UcsJab<T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Cam16UcsJab<T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<T, A> Alpha<Cam16UcsJab<&mut T>, &mut A>

pub fn set(&mut self, value: Alpha<Cam16UcsJab<T>, A>)

Update this color with new values.

pub fn as_refs(&self) -> Alpha<Cam16UcsJab<&T>, &A>

Borrow this color’s components as shared references.

pub fn copied(&self) -> Alpha<Cam16UcsJab<T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Cam16UcsJab<T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<Ct, Ca> Alpha<Cam16UcsJab<Ct>, Ca>

pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Cam16UcsJab<&'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsRef<[T]>, Ca: AsRef<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, with references to the components at index. See slice::get for details.

pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Cam16UcsJab<&'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsMut<[T]>, Ca: AsMut<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, that allows modifying the components at index. See slice::get_mut for details.

impl<T, A> Alpha<Cam16UcsJab<Vec<T>>, Vec<A>>

pub fn with_capacity(capacity: usize) -> Alpha<Cam16UcsJab<Vec<T>>, Vec<A>>

Create a struct of vectors with a minimum capacity. See Vec::with_capacity for details.

pub fn push(&mut self, value: Alpha<Cam16UcsJab<T>, A>)

Push an additional color’s components onto the component vectors. See Vec::push for details.

pub fn pop(&mut self) -> Option<Alpha<Cam16UcsJab<T>, A>>

Pop a color’s components from the component vectors. See Vec::pop for details.

pub fn clear(&mut self)

Clear the component vectors. See Vec::clear for details.

pub fn drain<R>(&mut self, range: R) -> Iter<Iter<Drain<'_, T>>, Drain<'_, A>>

where R: RangeBounds<usize> + Clone,

Return an iterator that moves colors out of the specified range.

impl<T, A> Alpha<Cam16UcsJmh<T>, A>

Cam16UcsJmha implementations.

pub fn new<H>( lightness: T, colorfulness: T, hue: H, alpha: A, ) -> Alpha<Cam16UcsJmh<T>, A>

where H: Into<Cam16Hue<T>>,

Create a CAM16-UCS J’ M’ h’ color with transparency.

pub const fn new_const( lightness: T, colorfulness: T, hue: Cam16Hue<T>, alpha: A, ) -> Alpha<Cam16UcsJmh<T>, A>

Create a CAM16-UCS J’ M’ h’ color with transparency. This is the same as Cam16UcsJmha::new without the generic hue type. It’s temporary until const fn supports traits.

pub fn into_components(self) -> (T, T, Cam16Hue<T>, A)

Convert to a (J', M', h', a) tuple.

pub fn from_components<H>(_: (T, T, H, A)) -> Alpha<Cam16UcsJmh<T>, A>

where H: Into<Cam16Hue<T>>,

Convert from a (J', M', h', a) tuple.

impl<T, A> Alpha<Cam16UcsJmh<&T>, &A>

pub fn copied(&self) -> Alpha<Cam16UcsJmh<T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Cam16UcsJmh<T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<T, A> Alpha<Cam16UcsJmh<&mut T>, &mut A>

pub fn set(&mut self, value: Alpha<Cam16UcsJmh<T>, A>)

Update this color with new values.

pub fn as_refs(&self) -> Alpha<Cam16UcsJmh<&T>, &A>

Borrow this color’s components as shared references.

pub fn copied(&self) -> Alpha<Cam16UcsJmh<T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Cam16UcsJmh<T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<Ct, Ca> Alpha<Cam16UcsJmh<Ct>, Ca>

pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Cam16UcsJmh<&'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsRef<[T]>, Ca: AsRef<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, with references to the components at index. See slice::get for details.

pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Cam16UcsJmh<&'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsMut<[T]>, Ca: AsMut<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, that allows modifying the components at index. See slice::get_mut for details.

impl<T, A> Alpha<Cam16UcsJmh<Vec<T>>, Vec<A>>

pub fn with_capacity(capacity: usize) -> Alpha<Cam16UcsJmh<Vec<T>>, Vec<A>>

Create a struct of vectors with a minimum capacity. See Vec::with_capacity for details.

pub fn push(&mut self, value: Alpha<Cam16UcsJmh<T>, A>)

Push an additional color’s components onto the component vectors. See Vec::push for details.

pub fn pop(&mut self) -> Option<Alpha<Cam16UcsJmh<T>, A>>

Pop a color’s components from the component vectors. See Vec::pop for details.

pub fn clear(&mut self)

Clear the component vectors. See Vec::clear for details.

pub fn drain<R>(&mut self, range: R) -> Iter<Iter<Drain<'_, T>>, Drain<'_, A>>

where R: RangeBounds<usize> + Clone,

Return an iterator that moves colors out of the specified range.

impl<T, A> Alpha<Hsl<Srgb, T>, A>

Hsla implementations.

pub fn new_srgb<H>( hue: H, saturation: T, lightness: T, alpha: A, ) -> Alpha<Hsl<Srgb, T>, A>

where H: Into<RgbHue<T>>,

Create an sRGB HSL color with transparency. This method can be used instead of Hsla::new to help type inference.

pub const fn new_srgb_const( hue: RgbHue<T>, saturation: T, lightness: T, alpha: A, ) -> Alpha<Hsl<Srgb, T>, A>

Create an sRGB HSL color with transparency. This is the same as Hsla::new_srgb without the generic hue type. It’s temporary until const fn supports traits.

impl<S, T, A> Alpha<Hsl<S, T>, A>

Hsla implementations.

pub fn new<H>( hue: H, saturation: T, lightness: T, alpha: A, ) -> Alpha<Hsl<S, T>, A>

where H: Into<RgbHue<T>>,

Create an HSL color with transparency.

pub const fn new_const( hue: RgbHue<T>, saturation: T, lightness: T, alpha: A, ) -> Alpha<Hsl<S, T>, A>

Create an HSL color with transparency. This is the same as Hsla::new without the generic hue type. It’s temporary until const fn supports traits.

pub fn into_format<U, B>(self) -> Alpha<Hsl<S, U>, B>

where U: FromStimulus<T> + FromAngle<T>, B: FromStimulus<A>,

Convert into another component type.

pub fn from_format<U, B>(color: Alpha<Hsl<S, U>, B>) -> Alpha<Hsl<S, T>, A>

where T: FromStimulus<U> + FromAngle<U>, A: FromStimulus<B>,

Convert from another component type.

pub fn into_components(self) -> (RgbHue<T>, T, T, A)

Convert to a (hue, saturation, lightness, alpha) tuple.

pub fn from_components<H>(_: (H, T, T, A)) -> Alpha<Hsl<S, T>, A>

where H: Into<RgbHue<T>>,

Convert from a (hue, saturation, lightness, alpha) tuple.

impl<S, T, A> Alpha<Hsl<S, &T>, &A>

pub fn copied(&self) -> Alpha<Hsl<S, T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Hsl<S, T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<S, T, A> Alpha<Hsl<S, &mut T>, &mut A>

pub fn set(&mut self, value: Alpha<Hsl<S, T>, A>)

Update this color with new values.

pub fn as_refs(&self) -> Alpha<Hsl<S, &T>, &A>

Borrow this color’s components as shared references.

pub fn copied(&self) -> Alpha<Hsl<S, T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Hsl<S, T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<S, Ct, Ca> Alpha<Hsl<S, Ct>, Ca>

pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Hsl<S, &'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsRef<[T]>, Ca: AsRef<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, with references to the components at index. See slice::get for details.

pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Hsl<S, &'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsMut<[T]>, Ca: AsMut<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, that allows modifying the components at index. See slice::get_mut for details.

impl<S, T, A> Alpha<Hsl<S, Vec<T>>, Vec<A>>

pub fn with_capacity(capacity: usize) -> Alpha<Hsl<S, Vec<T>>, Vec<A>>

Create a struct of vectors with a minimum capacity. See Vec::with_capacity for details.

pub fn push(&mut self, value: Alpha<Hsl<S, T>, A>)

Push an additional color’s components onto the component vectors. See Vec::push for details.

pub fn pop(&mut self) -> Option<Alpha<Hsl<S, T>, A>>

Pop a color’s components from the component vectors. See Vec::pop for details.

pub fn clear(&mut self)

Clear the component vectors. See Vec::clear for details.

pub fn drain<R>( &mut self, range: R, ) -> Iter<Iter<Drain<'_, T>, S>, Drain<'_, A>>

where R: RangeBounds<usize> + Clone,

Return an iterator that moves colors out of the specified range.

impl<Wp, T, A> Alpha<Hsluv<Wp, T>, A>

Hsluva implementations.

pub fn new<H>(hue: H, saturation: T, l: T, alpha: A) -> Alpha<Hsluv<Wp, T>, A>

where H: Into<LuvHue<T>>,

Create an HSLuv color with transparency.

pub const fn new_const( hue: LuvHue<T>, saturation: T, l: T, alpha: A, ) -> Alpha<Hsluv<Wp, T>, A>

Create an HSLuv color with transparency. This is the same as Hsluva::new without the generic hue type. It’s temporary until const fn supports traits.

pub fn into_components(self) -> (LuvHue<T>, T, T, A)

Convert to a (hue, saturation, l, alpha) tuple.

pub fn from_components<H>(_: (H, T, T, A)) -> Alpha<Hsluv<Wp, T>, A>

where H: Into<LuvHue<T>>,

Convert from a (hue, saturation, l, alpha) tuple.

impl<Wp, T, A> Alpha<Hsluv<Wp, &T>, &A>

pub fn copied(&self) -> Alpha<Hsluv<Wp, T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Hsluv<Wp, T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<Wp, T, A> Alpha<Hsluv<Wp, &mut T>, &mut A>

pub fn set(&mut self, value: Alpha<Hsluv<Wp, T>, A>)

Update this color with new values.

pub fn as_refs(&self) -> Alpha<Hsluv<Wp, &T>, &A>

Borrow this color’s components as shared references.

pub fn copied(&self) -> Alpha<Hsluv<Wp, T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Hsluv<Wp, T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<Wp, Ct, Ca> Alpha<Hsluv<Wp, Ct>, Ca>

pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Hsluv<Wp, &'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsRef<[T]>, Ca: AsRef<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, with references to the components at index. See slice::get for details.

pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Hsluv<Wp, &'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsMut<[T]>, Ca: AsMut<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, that allows modifying the components at index. See slice::get_mut for details.

impl<Wp, T, A> Alpha<Hsluv<Wp, Vec<T>>, Vec<A>>

pub fn with_capacity(capacity: usize) -> Alpha<Hsluv<Wp, Vec<T>>, Vec<A>>

Create a struct of vectors with a minimum capacity. See Vec::with_capacity for details.

pub fn push(&mut self, value: Alpha<Hsluv<Wp, T>, A>)

Push an additional color’s components onto the component vectors. See Vec::push for details.

pub fn pop(&mut self) -> Option<Alpha<Hsluv<Wp, T>, A>>

Pop a color’s components from the component vectors. See Vec::pop for details.

pub fn clear(&mut self)

Clear the component vectors. See Vec::clear for details.

pub fn drain<R>( &mut self, range: R, ) -> Iter<Iter<Drain<'_, T>, Wp>, Drain<'_, A>>

where R: RangeBounds<usize> + Clone,

Return an iterator that moves colors out of the specified range.

impl<T, A> Alpha<Hsv<Srgb, T>, A>

Hsva implementations.

pub fn new_srgb<H>( hue: H, saturation: T, value: T, alpha: A, ) -> Alpha<Hsv<Srgb, T>, A>

where H: Into<RgbHue<T>>,

Create an sRGB HSV color with transparency. This method can be used instead of Hsva::new to help type inference.

pub const fn new_srgb_const( hue: RgbHue<T>, saturation: T, value: T, alpha: A, ) -> Alpha<Hsv<Srgb, T>, A>

Create an sRGB HSV color with transparency. This is the same as Hsva::new_srgb without the generic hue type. It’s temporary until const fn supports traits.

impl<S, T, A> Alpha<Hsv<S, T>, A>

Hsva implementations.

pub fn new<H>(hue: H, saturation: T, value: T, alpha: A) -> Alpha<Hsv<S, T>, A>

where H: Into<RgbHue<T>>,

Create an HSV color with transparency.

pub const fn new_const( hue: RgbHue<T>, saturation: T, value: T, alpha: A, ) -> Alpha<Hsv<S, T>, A>

Create an HSV color with transparency. This is the same as Hsva::new without the generic hue type. It’s temporary until const fn supports traits.

pub fn into_format<U, B>(self) -> Alpha<Hsv<S, U>, B>

where U: FromStimulus<T> + FromAngle<T>, B: FromStimulus<A>,

Convert into another component type.

pub fn from_format<U, B>(color: Alpha<Hsv<S, U>, B>) -> Alpha<Hsv<S, T>, A>

where T: FromStimulus<U> + FromAngle<U>, A: FromStimulus<B>,

Convert from another component type.

pub fn into_components(self) -> (RgbHue<T>, T, T, A)

Convert to a (hue, saturation, value, alpha) tuple.

pub fn from_components<H>(_: (H, T, T, A)) -> Alpha<Hsv<S, T>, A>

where H: Into<RgbHue<T>>,

Convert from a (hue, saturation, value, alpha) tuple.

impl<S, T, A> Alpha<Hsv<S, &T>, &A>

pub fn copied(&self) -> Alpha<Hsv<S, T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Hsv<S, T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<S, T, A> Alpha<Hsv<S, &mut T>, &mut A>

pub fn set(&mut self, value: Alpha<Hsv<S, T>, A>)

Update this color with new values.

pub fn as_refs(&self) -> Alpha<Hsv<S, &T>, &A>

Borrow this color’s components as shared references.

pub fn copied(&self) -> Alpha<Hsv<S, T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Hsv<S, T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<S, Ct, Ca> Alpha<Hsv<S, Ct>, Ca>

pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Hsv<S, &'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsRef<[T]>, Ca: AsRef<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, with references to the components at index. See slice::get for details.

pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Hsv<S, &'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsMut<[T]>, Ca: AsMut<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, that allows modifying the components at index. See slice::get_mut for details.

impl<S, T, A> Alpha<Hsv<S, Vec<T>>, Vec<A>>

pub fn with_capacity(capacity: usize) -> Alpha<Hsv<S, Vec<T>>, Vec<A>>

Create a struct of vectors with a minimum capacity. See Vec::with_capacity for details.

pub fn push(&mut self, value: Alpha<Hsv<S, T>, A>)

Push an additional color’s components onto the component vectors. See Vec::push for details.

pub fn pop(&mut self) -> Option<Alpha<Hsv<S, T>, A>>

Pop a color’s components from the component vectors. See Vec::pop for details.

pub fn clear(&mut self)

Clear the component vectors. See Vec::clear for details.

pub fn drain<R>( &mut self, range: R, ) -> Iter<Iter<Drain<'_, T>, S>, Drain<'_, A>>

where R: RangeBounds<usize> + Clone,

Return an iterator that moves colors out of the specified range.

impl<T, A> Alpha<Hwb<Srgb, T>, A>

Hwba implementations.

pub fn new_srgb<H>( hue: H, whiteness: T, blackness: T, alpha: A, ) -> Alpha<Hwb<Srgb, T>, A>

where H: Into<RgbHue<T>>,

Create an sRGB HWB color with transparency. This method can be used instead of Hwba::new to help type inference.

pub const fn new_srgb_const( hue: RgbHue<T>, whiteness: T, blackness: T, alpha: A, ) -> Alpha<Hwb<Srgb, T>, A>

Create an sRGB HWB color with transparency. This is the same as Hwba::new_srgb without the generic hue type. It’s temporary until const fn supports traits.

impl<S, T, A> Alpha<Hwb<S, T>, A>

Hwba implementations.

pub fn new<H>( hue: H, whiteness: T, blackness: T, alpha: A, ) -> Alpha<Hwb<S, T>, A>

where H: Into<RgbHue<T>>,

Create an HWB color with transparency.

pub const fn new_const( hue: RgbHue<T>, whiteness: T, blackness: T, alpha: A, ) -> Alpha<Hwb<S, T>, A>

Create an HWB color with transparency. This is the same as Hwba::new without the generic hue type. It’s temporary until const fn supports traits.

pub fn into_format<U, B>(self) -> Alpha<Hwb<S, U>, B>

where U: FromStimulus<T> + FromAngle<T>, B: FromStimulus<A>,

Convert into another component type.

pub fn from_format<U, B>(color: Alpha<Hwb<S, U>, B>) -> Alpha<Hwb<S, T>, A>

where T: FromStimulus<U> + FromAngle<U>, A: FromStimulus<B>,

Convert from another component type.

pub fn into_components(self) -> (RgbHue<T>, T, T, A)

Convert to a (hue, whiteness, blackness, alpha) tuple.

pub fn from_components<H>(_: (H, T, T, A)) -> Alpha<Hwb<S, T>, A>

where H: Into<RgbHue<T>>,

Convert from a (hue, whiteness, blackness, alpha) tuple.

impl<S, T, A> Alpha<Hwb<S, &T>, &A>

pub fn copied(&self) -> Alpha<Hwb<S, T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Hwb<S, T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<S, T, A> Alpha<Hwb<S, &mut T>, &mut A>

pub fn set(&mut self, value: Alpha<Hwb<S, T>, A>)

Update this color with new values.

pub fn as_refs(&self) -> Alpha<Hwb<S, &T>, &A>

Borrow this color’s components as shared references.

pub fn copied(&self) -> Alpha<Hwb<S, T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Hwb<S, T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<S, Ct, Ca> Alpha<Hwb<S, Ct>, Ca>

pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Hwb<S, &'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsRef<[T]>, Ca: AsRef<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, with references to the components at index. See slice::get for details.

pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Hwb<S, &'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsMut<[T]>, Ca: AsMut<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, that allows modifying the components at index. See slice::get_mut for details.

impl<S, T, A> Alpha<Hwb<S, Vec<T>>, Vec<A>>

pub fn with_capacity(capacity: usize) -> Alpha<Hwb<S, Vec<T>>, Vec<A>>

Create a struct of vectors with a minimum capacity. See Vec::with_capacity for details.

pub fn push(&mut self, value: Alpha<Hwb<S, T>, A>)

Push an additional color’s components onto the component vectors. See Vec::push for details.

pub fn pop(&mut self) -> Option<Alpha<Hwb<S, T>, A>>

Pop a color’s components from the component vectors. See Vec::pop for details.

pub fn clear(&mut self)

Clear the component vectors. See Vec::clear for details.

pub fn drain<R>( &mut self, range: R, ) -> Iter<Iter<Drain<'_, T>, S>, Drain<'_, A>>

where R: RangeBounds<usize> + Clone,

Return an iterator that moves colors out of the specified range.

impl<Wp, T, A> Alpha<Lab<Wp, T>, A>

Laba implementations.

pub const fn new(l: T, a: T, b: T, alpha: A) -> Alpha<Lab<Wp, T>, A>

Create a CIE L*a*b* with transparency.

pub fn into_components(self) -> (T, T, T, A)

Convert to a (L\*, a\*, b\*, alpha) tuple.

pub fn from_components(_: (T, T, T, A)) -> Alpha<Lab<Wp, T>, A>

Convert from a (L\*, a\*, b\*, alpha) tuple.

impl<Wp, T, A> Alpha<Lab<Wp, &T>, &A>

pub fn copied(&self) -> Alpha<Lab<Wp, T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Lab<Wp, T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<Wp, T, A> Alpha<Lab<Wp, &mut T>, &mut A>

pub fn set(&mut self, value: Alpha<Lab<Wp, T>, A>)

Update this color with new values.

pub fn as_refs(&self) -> Alpha<Lab<Wp, &T>, &A>

Borrow this color’s components as shared references.

pub fn copied(&self) -> Alpha<Lab<Wp, T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Lab<Wp, T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<Wp, Ct, Ca> Alpha<Lab<Wp, Ct>, Ca>

pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Lab<Wp, &'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsRef<[T]>, Ca: AsRef<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, with references to the components at index. See slice::get for details.

pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Lab<Wp, &'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsMut<[T]>, Ca: AsMut<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, that allows modifying the components at index. See slice::get_mut for details.

impl<Wp, T, A> Alpha<Lab<Wp, Vec<T>>, Vec<A>>

pub fn with_capacity(capacity: usize) -> Alpha<Lab<Wp, Vec<T>>, Vec<A>>

Create a struct of vectors with a minimum capacity. See Vec::with_capacity for details.

pub fn push(&mut self, value: Alpha<Lab<Wp, T>, A>)

Push an additional color’s components onto the component vectors. See Vec::push for details.

pub fn pop(&mut self) -> Option<Alpha<Lab<Wp, T>, A>>

Pop a color’s components from the component vectors. See Vec::pop for details.

pub fn clear(&mut self)

Clear the component vectors. See Vec::clear for details.

pub fn drain<R>( &mut self, range: R, ) -> Iter<Iter<Drain<'_, T>, Wp>, Drain<'_, A>>

where R: RangeBounds<usize> + Clone,

Return an iterator that moves colors out of the specified range.

impl<Wp, T, A> Alpha<Lch<Wp, T>, A>

Lcha implementations.

pub fn new<H>(l: T, chroma: T, hue: H, alpha: A) -> Alpha<Lch<Wp, T>, A>

where H: Into<LabHue<T>>,

Create a CIE L*C*h° color with transparency.

pub const fn new_const( l: T, chroma: T, hue: LabHue<T>, alpha: A, ) -> Alpha<Lch<Wp, T>, A>

Create a CIE L*C*h° color with transparency. This is the same as Lcha::new without the generic hue type. It’s temporary until const fn supports traits.

pub fn into_components(self) -> (T, T, LabHue<T>, A)

Convert to a (L\*, C\*, h°, alpha) tuple.

pub fn from_components<H>(_: (T, T, H, A)) -> Alpha<Lch<Wp, T>, A>

where H: Into<LabHue<T>>,

Convert from a (L\*, C\*, h°, alpha) tuple.

impl<Wp, T, A> Alpha<Lch<Wp, &T>, &A>

pub fn copied(&self) -> Alpha<Lch<Wp, T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Lch<Wp, T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<Wp, T, A> Alpha<Lch<Wp, &mut T>, &mut A>

pub fn set(&mut self, value: Alpha<Lch<Wp, T>, A>)

Update this color with new values.

pub fn as_refs(&self) -> Alpha<Lch<Wp, &T>, &A>

Borrow this color’s components as shared references.

pub fn copied(&self) -> Alpha<Lch<Wp, T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Lch<Wp, T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<Wp, Ct, Ca> Alpha<Lch<Wp, Ct>, Ca>

pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Lch<Wp, &'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsRef<[T]>, Ca: AsRef<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, with references to the components at index. See slice::get for details.

pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Lch<Wp, &'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsMut<[T]>, Ca: AsMut<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, that allows modifying the components at index. See slice::get_mut for details.

impl<Wp, T, A> Alpha<Lch<Wp, Vec<T>>, Vec<A>>

pub fn with_capacity(capacity: usize) -> Alpha<Lch<Wp, Vec<T>>, Vec<A>>

Create a struct of vectors with a minimum capacity. See Vec::with_capacity for details.

pub fn push(&mut self, value: Alpha<Lch<Wp, T>, A>)

Push an additional color’s components onto the component vectors. See Vec::push for details.

pub fn pop(&mut self) -> Option<Alpha<Lch<Wp, T>, A>>

Pop a color’s components from the component vectors. See Vec::pop for details.

pub fn clear(&mut self)

Clear the component vectors. See Vec::clear for details.

pub fn drain<R>( &mut self, range: R, ) -> Iter<Iter<Drain<'_, T>, Wp>, Drain<'_, A>>

where R: RangeBounds<usize> + Clone,

Return an iterator that moves colors out of the specified range.

impl<Wp, T, A> Alpha<Lchuv<Wp, T>, A>

Lchuva implementations.

pub fn new<H>(l: T, chroma: T, hue: H, alpha: A) -> Alpha<Lchuv<Wp, T>, A>

where H: Into<LuvHue<T>>,

Create a CIE L*C*uv h°uv color with transparency.

pub const fn new_const( l: T, chroma: T, hue: LuvHue<T>, alpha: A, ) -> Alpha<Lchuv<Wp, T>, A>

Create a CIE L*C*uv h°uv color with transparency. This is the same as Lchuva::new without the generic hue type. It’s temporary until const fn supports traits.

pub fn into_components(self) -> (T, T, LuvHue<T>, A)

Convert to a (L\*, C\*uv, h°uv, alpha) tuple.

pub fn from_components<H>(_: (T, T, H, A)) -> Alpha<Lchuv<Wp, T>, A>

where H: Into<LuvHue<T>>,

Convert from a (L\*, C\*uv, h°uv, alpha) tuple.

impl<Wp, T, A> Alpha<Lchuv<Wp, &T>, &A>

pub fn copied(&self) -> Alpha<Lchuv<Wp, T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Lchuv<Wp, T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<Wp, T, A> Alpha<Lchuv<Wp, &mut T>, &mut A>

pub fn set(&mut self, value: Alpha<Lchuv<Wp, T>, A>)

Update this color with new values.

pub fn as_refs(&self) -> Alpha<Lchuv<Wp, &T>, &A>

Borrow this color’s components as shared references.

pub fn copied(&self) -> Alpha<Lchuv<Wp, T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Lchuv<Wp, T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<Wp, Ct, Ca> Alpha<Lchuv<Wp, Ct>, Ca>

pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Lchuv<Wp, &'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsRef<[T]>, Ca: AsRef<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, with references to the components at index. See slice::get for details.

pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Lchuv<Wp, &'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsMut<[T]>, Ca: AsMut<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, that allows modifying the components at index. See slice::get_mut for details.

impl<Wp, T, A> Alpha<Lchuv<Wp, Vec<T>>, Vec<A>>

pub fn with_capacity(capacity: usize) -> Alpha<Lchuv<Wp, Vec<T>>, Vec<A>>

Create a struct of vectors with a minimum capacity. See Vec::with_capacity for details.

pub fn push(&mut self, value: Alpha<Lchuv<Wp, T>, A>)

Push an additional color’s components onto the component vectors. See Vec::push for details.

pub fn pop(&mut self) -> Option<Alpha<Lchuv<Wp, T>, A>>

Pop a color’s components from the component vectors. See Vec::pop for details.

pub fn clear(&mut self)

Clear the component vectors. See Vec::clear for details.

pub fn drain<R>( &mut self, range: R, ) -> Iter<Iter<Drain<'_, T>, Wp>, Drain<'_, A>>

where R: RangeBounds<usize> + Clone,

Return an iterator that moves colors out of the specified range.

impl<S, T, A> Alpha<Luma<S, T>, A>

Lumaa implementations.

pub const fn new(luma: T, alpha: A) -> Alpha<Luma<S, T>, A>

Create a luminance color with transparency.

pub fn into_format<U, B>(self) -> Alpha<Luma<S, U>, B>

where U: FromStimulus<T>, B: FromStimulus<A>,

Convert into another component type.

pub fn from_format<U, B>(color: Alpha<Luma<S, U>, B>) -> Alpha<Luma<S, T>, A>

where T: FromStimulus<U>, A: FromStimulus<B>,

Convert from another component type.

pub fn into_components(self) -> (T, A)

Convert to a (luma, alpha) tuple.

pub fn from_components(_: (T, A)) -> Alpha<Luma<S, T>, A>

Convert from a (luma, alpha) tuple.

impl<S> Alpha<Luma<S, u8>, u8>

pub fn into_u16<O>(self) -> u16

where O: ComponentOrder<Alpha<Luma<S, u8>, u8>, u16>,

Convert to a packed u16 with with a specific component order.

use palette::{luma, SrgbLumaa};

let integer = SrgbLumaa::new(96u8, 255).into_u16::<luma::channels::Al>();
assert_eq!(0xFF60, integer);

It’s also possible to use From and Into, which defaults to the 0xLLAA component order:

use palette::SrgbLumaa;

let integer = u16::from(SrgbLumaa::new(96u8, 255));
assert_eq!(0x60FF, integer);

See Packed for more details.

pub fn from_u16<O>(color: u16) -> Alpha<Luma<S, u8>, u8>

where O: ComponentOrder<Alpha<Luma<S, u8>, u8>, u16>,

Convert from a packed u16 with a specific component order.

use palette::{luma, SrgbLumaa};

let luma = SrgbLumaa::from_u16::<luma::channels::Al>(0xFF60);
assert_eq!(SrgbLumaa::new(96u8, 255), luma);

It’s also possible to use From and Into, which defaults to the 0xLLAA component order:

use palette::SrgbLumaa;

let luma = SrgbLumaa::from(0x60FF);
assert_eq!(SrgbLumaa::new(96u8, 255), luma);

See Packed for more details.

impl<S, T, A> Alpha<Luma<S, T>, A>

where S: LumaStandard,

pub fn into_linear<U, B>( self, ) -> Alpha<Luma<Linear<<S as LumaStandard>::WhitePoint>, U>, B>

where <S as LumaStandard>::TransferFn: IntoLinear<U, T>, B: FromStimulus<A>,

Convert the color to linear luminance with transparency.

Some transfer functions allow the component type to be converted at the same time. This is usually offered with increased performance, compared to using into_format.

use palette::{SrgbLumaa, LinLumaa};

let linear: LinLumaa<_, f32> = SrgbLumaa::new(96u8, 38).into_linear();

See the transfer function types in the encoding module for details and performance characteristics.

pub fn from_linear<U, B>( color: Alpha<Luma<Linear<<S as LumaStandard>::WhitePoint>, U>, B>, ) -> Alpha<Luma<S, T>, A>

where <S as LumaStandard>::TransferFn: FromLinear<U, T>, A: FromStimulus<B>,

Convert linear luminance to non-linear luminance with transparency.

Some transfer functions allow the component type to be converted at the same time. This is usually offered with increased performance, compared to using into_format.

use palette::{SrgbLumaa, LinLumaa};

let encoded = SrgbLumaa::<u8>::from_linear(LinLumaa::new(0.95f32, 0.75));

See the transfer function types in the encoding module for details and performance characteristics.

impl<Wp, T, A> Alpha<Luma<Linear<Wp>, T>, A>

pub fn into_encoding<U, B, St>(self) -> Alpha<Luma<St, U>, B>

where St: LumaStandard<WhitePoint = Wp>, <St as LumaStandard>::TransferFn: FromLinear<T, U>, B: FromStimulus<A>,

Convert a linear color to a different encoding with transparency.

Some transfer functions allow the component type to be converted at the same time. This is usually offered with increased performance, compared to using into_format.

use palette::{SrgbLumaa, LinLumaa};

let encoded: SrgbLumaa<u8> = LinLumaa::new(0.95f32, 0.75).into_encoding();

See the transfer function types in the encoding module for details and performance characteristics.

pub fn from_encoding<U, B, St>( color: Alpha<Luma<St, U>, B>, ) -> Alpha<Luma<Linear<Wp>, T>, A>

where St: LumaStandard<WhitePoint = Wp>, <St as LumaStandard>::TransferFn: IntoLinear<T, U>, A: FromStimulus<B>,

Convert to linear luminance from a different encoding with transparency.

Some transfer functions allow the component type to be converted at the same time. This is usually offered with increased performance, compared to using into_format.

use palette::{SrgbLumaa, LinLumaa};

let linear = LinLumaa::<_, f32>::from_encoding(SrgbLumaa::new(96u8, 38));

See the transfer function types in the encoding module for details and performance characteristics.

impl<S, T, A> Alpha<Luma<S, &T>, &A>

pub fn copied(&self) -> Alpha<Luma<S, T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Luma<S, T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<S, T, A> Alpha<Luma<S, &mut T>, &mut A>

pub fn set(&mut self, value: Alpha<Luma<S, T>, A>)

Update this color with new values.

pub fn as_refs(&self) -> Alpha<Luma<S, &T>, &A>

Borrow this color’s components as shared references.

pub fn copied(&self) -> Alpha<Luma<S, T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Luma<S, T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<S, Ct, Ca> Alpha<Luma<S, Ct>, Ca>

pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Luma<S, &'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsRef<[T]>, Ca: AsRef<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, with references to the components at index. See slice::get for details.

pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Luma<S, &'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsMut<[T]>, Ca: AsMut<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, that allows modifying the components at index. See slice::get_mut for details.

impl<S, T, A> Alpha<Luma<S, Vec<T>>, Vec<A>>

pub fn with_capacity(capacity: usize) -> Alpha<Luma<S, Vec<T>>, Vec<A>>

Create a struct of vectors with a minimum capacity. See Vec::with_capacity for details.

pub fn push(&mut self, value: Alpha<Luma<S, T>, A>)

Push an additional color’s components onto the component vectors. See Vec::push for details.

pub fn pop(&mut self) -> Option<Alpha<Luma<S, T>, A>>

Pop a color’s components from the component vectors. See Vec::pop for details.

pub fn clear(&mut self)

Clear the component vectors. See Vec::clear for details.

pub fn drain<R>( &mut self, range: R, ) -> Iter<Iter<Drain<'_, T>, S>, Drain<'_, A>>

where R: RangeBounds<usize> + Clone,

Return an iterator that moves colors out of the specified range.

impl<Wp, T, A> Alpha<Luv<Wp, T>, A>

Luva implementations.

pub const fn new(l: T, u: T, v: T, alpha: A) -> Alpha<Luv<Wp, T>, A>

Create a CIE L*u*v* color with transparency.

pub fn into_components(self) -> (T, T, T, A)

Convert to u (L\*, u\*, v\*, alpha) tuple.

pub fn from_components(_: (T, T, T, A)) -> Alpha<Luv<Wp, T>, A>

Convert from u (L\*, u\*, v\*, alpha) tuple.

impl<Wp, T, A> Alpha<Luv<Wp, &T>, &A>

pub fn copied(&self) -> Alpha<Luv<Wp, T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Luv<Wp, T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<Wp, T, A> Alpha<Luv<Wp, &mut T>, &mut A>

pub fn set(&mut self, value: Alpha<Luv<Wp, T>, A>)

Update this color with new values.

pub fn as_refs(&self) -> Alpha<Luv<Wp, &T>, &A>

Borrow this color’s components as shared references.

pub fn copied(&self) -> Alpha<Luv<Wp, T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Luv<Wp, T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<Wp, Ct, Ca> Alpha<Luv<Wp, Ct>, Ca>

pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Luv<Wp, &'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsRef<[T]>, Ca: AsRef<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, with references to the components at index. See slice::get for details.

pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Luv<Wp, &'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsMut<[T]>, Ca: AsMut<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, that allows modifying the components at index. See slice::get_mut for details.

impl<Wp, T, A> Alpha<Luv<Wp, Vec<T>>, Vec<A>>

pub fn with_capacity(capacity: usize) -> Alpha<Luv<Wp, Vec<T>>, Vec<A>>

Create a struct of vectors with a minimum capacity. See Vec::with_capacity for details.

pub fn push(&mut self, value: Alpha<Luv<Wp, T>, A>)

Push an additional color’s components onto the component vectors. See Vec::push for details.

pub fn pop(&mut self) -> Option<Alpha<Luv<Wp, T>, A>>

Pop a color’s components from the component vectors. See Vec::pop for details.

pub fn clear(&mut self)

Clear the component vectors. See Vec::clear for details.

pub fn drain<R>( &mut self, range: R, ) -> Iter<Iter<Drain<'_, T>, Wp>, Drain<'_, A>>

where R: RangeBounds<usize> + Clone,

Return an iterator that moves colors out of the specified range.

impl<T, A> Alpha<Okhsl<T>, A>

Okhsla implementations.

pub fn new<H>( hue: H, saturation: T, lightness: T, alpha: A, ) -> Alpha<Okhsl<T>, A>

where H: Into<OklabHue<T>>,

Create an Okhsl color with transparency.

pub const fn new_const( hue: OklabHue<T>, saturation: T, lightness: T, alpha: A, ) -> Alpha<Okhsl<T>, A>

Create an Okhsla color. This is the same as Okhsla::new without the generic hue type. It’s temporary until const fn supports traits.

pub fn into_format<U, B>(self) -> Alpha<Okhsl<U>, B>

where U: FromStimulus<T> + FromAngle<T>, B: FromStimulus<A>,

Convert into another component type.

pub fn from_format<U, B>(color: Alpha<Okhsl<U>, B>) -> Alpha<Okhsl<T>, A>

where T: FromStimulus<U> + FromAngle<U>, A: FromStimulus<B>,

Convert from another component type.

pub fn into_components(self) -> (OklabHue<T>, T, T, A)

Convert to a (hue, saturation, lightness, alpha) tuple.

pub fn from_components<H>(_: (H, T, T, A)) -> Alpha<Okhsl<T>, A>

where H: Into<OklabHue<T>>,

Convert from a (hue, saturation, lightness, alpha) tuple.

impl<T, A> Alpha<Okhsl<&T>, &A>

pub fn copied(&self) -> Alpha<Okhsl<T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Okhsl<T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<T, A> Alpha<Okhsl<&mut T>, &mut A>

pub fn set(&mut self, value: Alpha<Okhsl<T>, A>)

Update this color with new values.

pub fn as_refs(&self) -> Alpha<Okhsl<&T>, &A>

Borrow this color’s components as shared references.

pub fn copied(&self) -> Alpha<Okhsl<T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Okhsl<T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<Ct, Ca> Alpha<Okhsl<Ct>, Ca>

pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Okhsl<&'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsRef<[T]>, Ca: AsRef<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, with references to the components at index. See slice::get for details.

pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Okhsl<&'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsMut<[T]>, Ca: AsMut<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, that allows modifying the components at index. See slice::get_mut for details.

impl<T, A> Alpha<Okhsl<Vec<T>>, Vec<A>>

pub fn with_capacity(capacity: usize) -> Alpha<Okhsl<Vec<T>>, Vec<A>>

Create a struct of vectors with a minimum capacity. See Vec::with_capacity for details.

pub fn push(&mut self, value: Alpha<Okhsl<T>, A>)

Push an additional color’s components onto the component vectors. See Vec::push for details.

pub fn pop(&mut self) -> Option<Alpha<Okhsl<T>, A>>

Pop a color’s components from the component vectors. See Vec::pop for details.

pub fn clear(&mut self)

Clear the component vectors. See Vec::clear for details.

pub fn drain<R>(&mut self, range: R) -> Iter<Iter<Drain<'_, T>>, Drain<'_, A>>

where R: RangeBounds<usize> + Clone,

Return an iterator that moves colors out of the specified range.

impl<T, A> Alpha<Okhsv<T>, A>

Hsva implementations.

pub fn new<H>(hue: H, saturation: T, value: T, alpha: A) -> Alpha<Okhsv<T>, A>

where H: Into<OklabHue<T>>,

Create an Okhsv color with transparency.

pub const fn new_const( hue: OklabHue<T>, saturation: T, value: T, alpha: A, ) -> Alpha<Okhsv<T>, A>

Create an Okhsva color. This is the same as Okhsva::new without the generic hue type. It’s temporary until const fn supports traits.

pub fn into_format<U, B>(self) -> Alpha<Okhsv<U>, B>

where U: FromStimulus<T> + FromAngle<T>, B: FromStimulus<A>,

Convert into another component type.

pub fn from_format<U, B>(color: Alpha<Okhsv<U>, B>) -> Alpha<Okhsv<T>, A>

where T: FromStimulus<U> + FromAngle<U>, A: FromStimulus<B>, U: Zero + MinMax,

Convert from another component type.

pub fn into_components(self) -> (OklabHue<T>, T, T, A)

Convert to a (hue, saturation, value, alpha) tuple.

pub fn from_components<H>(_: (H, T, T, A)) -> Alpha<Okhsv<T>, A>

where H: Into<OklabHue<T>>,

Convert from a (hue, saturation, value, alpha) tuple.

impl<T, A> Alpha<Okhsv<&T>, &A>

pub fn copied(&self) -> Alpha<Okhsv<T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Okhsv<T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<T, A> Alpha<Okhsv<&mut T>, &mut A>

pub fn set(&mut self, value: Alpha<Okhsv<T>, A>)

Update this color with new values.

pub fn as_refs(&self) -> Alpha<Okhsv<&T>, &A>

Borrow this color’s components as shared references.

pub fn copied(&self) -> Alpha<Okhsv<T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Okhsv<T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<Ct, Ca> Alpha<Okhsv<Ct>, Ca>

pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Okhsv<&'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsRef<[T]>, Ca: AsRef<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, with references to the components at index. See slice::get for details.

pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Okhsv<&'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsMut<[T]>, Ca: AsMut<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, that allows modifying the components at index. See slice::get_mut for details.

impl<T, A> Alpha<Okhsv<Vec<T>>, Vec<A>>

pub fn with_capacity(capacity: usize) -> Alpha<Okhsv<Vec<T>>, Vec<A>>

Create a struct of vectors with a minimum capacity. See Vec::with_capacity for details.

pub fn push(&mut self, value: Alpha<Okhsv<T>, A>)

Push an additional color’s components onto the component vectors. See Vec::push for details.

pub fn pop(&mut self) -> Option<Alpha<Okhsv<T>, A>>

Pop a color’s components from the component vectors. See Vec::pop for details.

pub fn clear(&mut self)

Clear the component vectors. See Vec::clear for details.

pub fn drain<R>(&mut self, range: R) -> Iter<Iter<Drain<'_, T>>, Drain<'_, A>>

where R: RangeBounds<usize> + Clone,

Return an iterator that moves colors out of the specified range.

impl<T, A> Alpha<Okhwb<T>, A>

Okhwba implementations.

pub fn new<H>( hue: H, whiteness: T, blackness: T, alpha: A, ) -> Alpha<Okhwb<T>, A>

where H: Into<OklabHue<T>>,

Create an Okhwb color with transparency.

pub const fn new_const( hue: OklabHue<T>, whiteness: T, blackness: T, alpha: A, ) -> Alpha<Okhwb<T>, A>

Create an Okhwba color. This is the same as Okhwba::new without the generic hue type. It’s temporary until const fn supports traits.

pub fn into_format<U, B>(self) -> Alpha<Okhwb<U>, B>

where U: FromStimulus<T> + FromAngle<T>, B: FromStimulus<A>,

Convert into another component type.

pub fn from_format<U, B>(color: Alpha<Okhwb<U>, B>) -> Alpha<Okhwb<T>, A>

where T: FromStimulus<U> + FromAngle<U>, A: FromStimulus<B>,

Convert from another component type.

pub fn into_components(self) -> (OklabHue<T>, T, T, A)

Convert to a (hue, whiteness, blackness, alpha) tuple.

pub fn from_components<H>(_: (H, T, T, A)) -> Alpha<Okhwb<T>, A>

where H: Into<OklabHue<T>>,

Convert from a (hue, whiteness, blackness, alpha) tuple.

impl<T, A> Alpha<Okhwb<&T>, &A>

pub fn copied(&self) -> Alpha<Okhwb<T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Okhwb<T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<T, A> Alpha<Okhwb<&mut T>, &mut A>

pub fn set(&mut self, value: Alpha<Okhwb<T>, A>)

Update this color with new values.

pub fn as_refs(&self) -> Alpha<Okhwb<&T>, &A>

Borrow this color’s components as shared references.

pub fn copied(&self) -> Alpha<Okhwb<T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Okhwb<T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<Ct, Ca> Alpha<Okhwb<Ct>, Ca>

pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Okhwb<&'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsRef<[T]>, Ca: AsRef<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, with references to the components at index. See slice::get for details.

pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Okhwb<&'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsMut<[T]>, Ca: AsMut<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, that allows modifying the components at index. See slice::get_mut for details.

impl<T, A> Alpha<Okhwb<Vec<T>>, Vec<A>>

pub fn with_capacity(capacity: usize) -> Alpha<Okhwb<Vec<T>>, Vec<A>>

Create a struct of vectors with a minimum capacity. See Vec::with_capacity for details.

pub fn push(&mut self, value: Alpha<Okhwb<T>, A>)

Push an additional color’s components onto the component vectors. See Vec::push for details.

pub fn pop(&mut self) -> Option<Alpha<Okhwb<T>, A>>

Pop a color’s components from the component vectors. See Vec::pop for details.

pub fn clear(&mut self)

Clear the component vectors. See Vec::clear for details.

pub fn drain<R>(&mut self, range: R) -> Iter<Iter<Drain<'_, T>>, Drain<'_, A>>

where R: RangeBounds<usize> + Clone,

Return an iterator that moves colors out of the specified range.

impl<T, A> Alpha<Oklab<T>, A>

Oklaba implementations.

pub const fn new(l: T, a: T, b: T, alpha: A) -> Alpha<Oklab<T>, A>

Create an Oklab color with transparency.

pub fn into_components(self) -> (T, T, T, A)

Convert to a (L, a, b, alpha) tuple.

pub fn from_components(_: (T, T, T, A)) -> Alpha<Oklab<T>, A>

Convert from a (L, a, b, alpha) tuple.

impl<T, A> Alpha<Oklab<&T>, &A>

pub fn copied(&self) -> Alpha<Oklab<T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Oklab<T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<T, A> Alpha<Oklab<&mut T>, &mut A>

pub fn set(&mut self, value: Alpha<Oklab<T>, A>)

Update this color with new values.

pub fn as_refs(&self) -> Alpha<Oklab<&T>, &A>

Borrow this color’s components as shared references.

pub fn copied(&self) -> Alpha<Oklab<T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Oklab<T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<Ct, Ca> Alpha<Oklab<Ct>, Ca>

pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Oklab<&'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsRef<[T]>, Ca: AsRef<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, with references to the components at index. See slice::get for details.

pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Oklab<&'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsMut<[T]>, Ca: AsMut<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, that allows modifying the components at index. See slice::get_mut for details.

impl<T, A> Alpha<Oklab<Vec<T>>, Vec<A>>

pub fn with_capacity(capacity: usize) -> Alpha<Oklab<Vec<T>>, Vec<A>>

Create a struct of vectors with a minimum capacity. See Vec::with_capacity for details.

pub fn push(&mut self, value: Alpha<Oklab<T>, A>)

Push an additional color’s components onto the component vectors. See Vec::push for details.

pub fn pop(&mut self) -> Option<Alpha<Oklab<T>, A>>

Pop a color’s components from the component vectors. See Vec::pop for details.

pub fn clear(&mut self)

Clear the component vectors. See Vec::clear for details.

pub fn drain<R>(&mut self, range: R) -> Iter<Iter<Drain<'_, T>>, Drain<'_, A>>

where R: RangeBounds<usize> + Clone,

Return an iterator that moves colors out of the specified range.

impl<T, A> Alpha<Oklch<T>, A>

Oklcha implementations.

pub fn new<H>(l: T, chroma: T, hue: H, alpha: A) -> Alpha<Oklch<T>, A>

where H: Into<OklabHue<T>>,

Create an Oklch color with transparency.

pub const fn new_const( l: T, chroma: T, hue: OklabHue<T>, alpha: A, ) -> Alpha<Oklch<T>, A>

Create an Oklcha color. This is the same as Oklcha::new without the generic hue type. It’s temporary until const fn supports traits.

pub fn into_components(self) -> (T, T, OklabHue<T>, A)

Convert to a (L, C, h, alpha) tuple.

pub fn from_components<H>(_: (T, T, H, A)) -> Alpha<Oklch<T>, A>

where H: Into<OklabHue<T>>,

Convert from a (L, C, h, alpha) tuple.

impl<T, A> Alpha<Oklch<&T>, &A>

pub fn copied(&self) -> Alpha<Oklch<T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Oklch<T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<T, A> Alpha<Oklch<&mut T>, &mut A>

pub fn set(&mut self, value: Alpha<Oklch<T>, A>)

Update this color with new values.

pub fn as_refs(&self) -> Alpha<Oklch<&T>, &A>

Borrow this color’s components as shared references.

pub fn copied(&self) -> Alpha<Oklch<T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Oklch<T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<Ct, Ca> Alpha<Oklch<Ct>, Ca>

pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Oklch<&'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsRef<[T]>, Ca: AsRef<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, with references to the components at index. See slice::get for details.

pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Oklch<&'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsMut<[T]>, Ca: AsMut<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, that allows modifying the components at index. See slice::get_mut for details.

impl<T, A> Alpha<Oklch<Vec<T>>, Vec<A>>

pub fn with_capacity(capacity: usize) -> Alpha<Oklch<Vec<T>>, Vec<A>>

Create a struct of vectors with a minimum capacity. See Vec::with_capacity for details.

pub fn push(&mut self, value: Alpha<Oklch<T>, A>)

Push an additional color’s components onto the component vectors. See Vec::push for details.

pub fn pop(&mut self) -> Option<Alpha<Oklch<T>, A>>

Pop a color’s components from the component vectors. See Vec::pop for details.

pub fn clear(&mut self)

Clear the component vectors. See Vec::clear for details.

pub fn drain<R>(&mut self, range: R) -> Iter<Iter<Drain<'_, T>>, Drain<'_, A>>

where R: RangeBounds<usize> + Clone,

Return an iterator that moves colors out of the specified range.

impl<S, T, A> Alpha<Rgb<S, T>, A>

Rgba implementations.

pub const fn new(red: T, green: T, blue: T, alpha: A) -> Alpha<Rgb<S, T>, A>

Non-linear RGB.

pub fn into_format<U, B>(self) -> Alpha<Rgb<S, U>, B>

where U: FromStimulus<T>, B: FromStimulus<A>,

Convert the RGBA components into other number types.

use palette::Srgba;

let rgba_u8: Srgba<u8> = Srgba::new(0.3, 0.7, 0.2, 0.5).into_format();

See also into_linear and into_encoding for a faster option if you need to change between linear and non-linear encoding at the same time.

pub fn from_format<U, B>(color: Alpha<Rgb<S, U>, B>) -> Alpha<Rgb<S, T>, A>

where T: FromStimulus<U>, A: FromStimulus<B>,

Convert the RGBA components from other number types.

use palette::Srgba;

let rgba_u8 = Srgba::<u8>::from_format(Srgba::new(0.3, 0.7, 0.2, 0.5));

See also from_linear and from_encoding for a faster option if you need to change between linear and non-linear encoding at the same time.

pub fn into_components(self) -> (T, T, T, A)

Convert to a (red, green, blue, alpha) tuple.

pub fn from_components(_: (T, T, T, A)) -> Alpha<Rgb<S, T>, A>

Convert from a (red, green, blue, alpha) tuple.

impl<S> Alpha<Rgb<S, u8>, u8>

pub fn into_u32<O>(self) -> u32

where O: ComponentOrder<Alpha<Rgb<S, u8>, u8>, u32>,

Convert to a packed u32 with with specifiable component order.

use palette::{rgb, Srgba};

let integer = Srgba::new(96u8, 127, 0, 255).into_u32::<rgb::channels::Argb>();
assert_eq!(0xFF607F00, integer);

It’s also possible to use From and Into, which defaults to the 0xRRGGBBAA component order:

use palette::Srgba;

let integer = u32::from(Srgba::new(96u8, 127, 0, 255));
assert_eq!(0x607F00FF, integer);

See Packed for more details.

pub fn from_u32<O>(color: u32) -> Alpha<Rgb<S, u8>, u8>

where O: ComponentOrder<Alpha<Rgb<S, u8>, u8>, u32>,

Convert from a packed u32 with specifiable component order.

use palette::{rgb, Srgba};

let rgba = Srgba::from_u32::<rgb::channels::Argb>(0xFF607F00);
assert_eq!(Srgba::new(96u8, 127, 0, 255), rgba);

It’s also possible to use From and Into, which defaults to the 0xRRGGBBAA component order:

use palette::Srgba;

let rgba = Srgba::from(0x607F00FF);
assert_eq!(Srgba::new(96u8, 127, 0, 255), rgba);

See Packed for more details.

impl<S, T, A> Alpha<Rgb<S, T>, A>

where S: RgbStandard,

pub fn into_linear<U, B>( self, ) -> Alpha<Rgb<Linear<<S as RgbStandard>::Space>, U>, B>

where <S as RgbStandard>::TransferFn: IntoLinear<U, T>, B: FromStimulus<A>,

Convert the color to linear RGB with transparency.

Some transfer functions allow the component type to be converted at the same time. This is usually offered with increased performance, compared to using into_format.

use palette::{Srgba, LinSrgba};

let linear: LinSrgba<f32> = Srgba::new(96u8, 127, 0, 38).into_linear();

See the transfer function types in the encoding module for details and performance characteristics.

pub fn from_linear<U, B>( color: Alpha<Rgb<Linear<<S as RgbStandard>::Space>, U>, B>, ) -> Alpha<Rgb<S, T>, A>

where <S as RgbStandard>::TransferFn: FromLinear<U, T>, A: FromStimulus<B>,

Convert linear RGB to non-linear RGB with transparency.

Some transfer functions allow the component type to be converted at the same time. This is usually offered with increased performance, compared to using into_format.

use palette::{Srgba, LinSrgba};

let encoded = Srgba::<u8>::from_linear(LinSrgba::new(0.95f32, 0.90, 0.30, 0.75));

See the transfer function types in the encoding module for details and performance characteristics.

impl<S, T, A> Alpha<Rgb<Linear<S>, T>, A>

where S: RgbSpace,

pub fn into_encoding<U, B, St>(self) -> Alpha<Rgb<St, U>, B>

where St: RgbStandard<Space = S>, <St as RgbStandard>::TransferFn: FromLinear<T, U>, B: FromStimulus<A>,

Convert a linear color to a different encoding with transparency.

Some transfer functions allow the component type to be converted at the same time. This is usually offered with increased performance, compared to using into_format.

use palette::{Srgba, LinSrgba};

let encoded: Srgba<u8> = LinSrgba::new(0.95f32, 0.90, 0.30, 0.75).into_encoding();

See the transfer function types in the encoding module for details and performance characteristics.

pub fn from_encoding<U, B, St>( color: Alpha<Rgb<St, U>, B>, ) -> Alpha<Rgb<Linear<S>, T>, A>

where St: RgbStandard<Space = S>, <St as RgbStandard>::TransferFn: IntoLinear<T, U>, A: FromStimulus<B>,

Convert RGB from a different encoding to linear with transparency.

Some transfer functions allow the component type to be converted at the same time. This is usually offered with increased performance, compared to using into_format.

use palette::{Srgba, LinSrgba};

let linear = LinSrgba::<f32>::from_encoding(Srgba::new(96u8, 127, 0, 38));

See the transfer function types in the encoding module for details and performance characteristics.

impl<S, T, A> Alpha<Rgb<S, &T>, &A>

pub fn copied(&self) -> Alpha<Rgb<S, T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Rgb<S, T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<S, T, A> Alpha<Rgb<S, &mut T>, &mut A>

pub fn set(&mut self, value: Alpha<Rgb<S, T>, A>)

Update this color with new values.

pub fn as_refs(&self) -> Alpha<Rgb<S, &T>, &A>

Borrow this color’s components as shared references.

pub fn copied(&self) -> Alpha<Rgb<S, T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Rgb<S, T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<S, Ct, Ca> Alpha<Rgb<S, Ct>, Ca>

pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Rgb<S, &'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsRef<[T]>, Ca: AsRef<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, with references to the components at index. See slice::get for details.

pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Rgb<S, &'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsMut<[T]>, Ca: AsMut<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, that allows modifying the components at index. See slice::get_mut for details.

impl<S, T, A> Alpha<Rgb<S, Vec<T>>, Vec<A>>

pub fn with_capacity(capacity: usize) -> Alpha<Rgb<S, Vec<T>>, Vec<A>>

Create a struct of vectors with a minimum capacity. See Vec::with_capacity for details.

pub fn push(&mut self, value: Alpha<Rgb<S, T>, A>)

Push an additional color’s components onto the component vectors. See Vec::push for details.

pub fn pop(&mut self) -> Option<Alpha<Rgb<S, T>, A>>

Pop a color’s components from the component vectors. See Vec::pop for details.

pub fn clear(&mut self)

Clear the component vectors. See Vec::clear for details.

pub fn drain<R>( &mut self, range: R, ) -> Iter<Iter<Drain<'_, T>, S>, Drain<'_, A>>

where R: RangeBounds<usize> + Clone,

Return an iterator that moves colors out of the specified range.

impl<Wp, T, A> Alpha<Xyz<Wp, T>, A>

Xyza implementations.

pub const fn new(x: T, y: T, z: T, alpha: A) -> Alpha<Xyz<Wp, T>, A>

Create a CIE XYZ color with transparency.

pub fn into_components(self) -> (T, T, T, A)

Convert to a (X, Y, Z, alpha) tuple.

pub fn from_components(_: (T, T, T, A)) -> Alpha<Xyz<Wp, T>, A>

Convert from a (X, Y, Z, alpha) tuple.

pub fn with_white_point<NewWp>(self) -> Alpha<Xyz<NewWp, T>, A>

Changes the reference white point without changing the color value.

This function doesn’t change the numerical values, and thus the color it represents in an absolute sense. However, the appearance of the color may not be the same when observed with the new white point. The effect would be similar to taking a photo with an incorrect white balance.

See chromatic_adaptation for operations that can change the white point while preserving the color’s appearance.

impl<Wp, T, A> Alpha<Xyz<Wp, &T>, &A>

pub fn copied(&self) -> Alpha<Xyz<Wp, T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Xyz<Wp, T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<Wp, T, A> Alpha<Xyz<Wp, &mut T>, &mut A>

pub fn set(&mut self, value: Alpha<Xyz<Wp, T>, A>)

Update this color with new values.

pub fn as_refs(&self) -> Alpha<Xyz<Wp, &T>, &A>

Borrow this color’s components as shared references.

pub fn copied(&self) -> Alpha<Xyz<Wp, T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Xyz<Wp, T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<Wp, Ct, Ca> Alpha<Xyz<Wp, Ct>, Ca>

pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Xyz<Wp, &'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsRef<[T]>, Ca: AsRef<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, with references to the components at index. See slice::get for details.

pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Xyz<Wp, &'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsMut<[T]>, Ca: AsMut<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, that allows modifying the components at index. See slice::get_mut for details.

impl<Wp, T, A> Alpha<Xyz<Wp, Vec<T>>, Vec<A>>

pub fn with_capacity(capacity: usize) -> Alpha<Xyz<Wp, Vec<T>>, Vec<A>>

Create a struct of vectors with a minimum capacity. See Vec::with_capacity for details.

pub fn push(&mut self, value: Alpha<Xyz<Wp, T>, A>)

Push an additional color’s components onto the component vectors. See Vec::push for details.

pub fn pop(&mut self) -> Option<Alpha<Xyz<Wp, T>, A>>

Pop a color’s components from the component vectors. See Vec::pop for details.

pub fn clear(&mut self)

Clear the component vectors. See Vec::clear for details.

pub fn drain<R>( &mut self, range: R, ) -> Iter<Iter<Drain<'_, T>, Wp>, Drain<'_, A>>

where R: RangeBounds<usize> + Clone,

Return an iterator that moves colors out of the specified range.

impl<Wp, T, A> Alpha<Yxy<Wp, T>, A>

Yxya implementations.

pub const fn new(x: T, y: T, luma: T, alpha: A) -> Alpha<Yxy<Wp, T>, A>

Create a CIE Yxy color with transparency.

pub fn into_components(self) -> (T, T, T, A)

Convert to a (x, y, luma), a.k.a. (x, y, Y) tuple.

pub fn from_components(_: (T, T, T, A)) -> Alpha<Yxy<Wp, T>, A>

Convert from a (x, y, luma), a.k.a. (x, y, Y) tuple.

pub fn with_white_point<NewWp>(self) -> Alpha<Yxy<NewWp, T>, A>

Changes the reference white point without changing the color value.

This function doesn’t change the numerical values, and thus the color it represents in an absolute sense. However, the appearance of the color may not be the same when observed with the new white point. The effect would be similar to taking a photo with an incorrect white balance.

See chromatic_adaptation for operations that can change the white point while preserving the color’s appearance.

impl<Wp, T, A> Alpha<Yxy<Wp, &T>, &A>

pub fn copied(&self) -> Alpha<Yxy<Wp, T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Yxy<Wp, T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<Wp, T, A> Alpha<Yxy<Wp, &mut T>, &mut A>

pub fn set(&mut self, value: Alpha<Yxy<Wp, T>, A>)

Update this color with new values.

pub fn as_refs(&self) -> Alpha<Yxy<Wp, &T>, &A>

Borrow this color’s components as shared references.

pub fn copied(&self) -> Alpha<Yxy<Wp, T>, A>

where T: Copy, A: Copy,

Get an owned, copied version of this color.

pub fn cloned(&self) -> Alpha<Yxy<Wp, T>, A>

where T: Clone, A: Clone,

Get an owned, cloned version of this color.

impl<Wp, Ct, Ca> Alpha<Yxy<Wp, Ct>, Ca>

pub fn get<'a, I, T, A>( &'a self, index: I, ) -> Option<Alpha<Yxy<Wp, &'a <I as SliceIndex<[T]>>::Output>, &'a <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsRef<[T]>, Ca: AsRef<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, with references to the components at index. See slice::get for details.

pub fn get_mut<'a, I, T, A>( &'a mut self, index: I, ) -> Option<Alpha<Yxy<Wp, &'a mut <I as SliceIndex<[T]>>::Output>, &'a mut <I as SliceIndex<[A]>>::Output>>

where T: 'a, A: 'a, Ct: AsMut<[T]>, Ca: AsMut<[A]>, I: SliceIndex<[T]> + SliceIndex<[A]> + Clone,

Get a color, or slice of colors, that allows modifying the components at index. See slice::get_mut for details.

impl<Wp, T, A> Alpha<Yxy<Wp, Vec<T>>, Vec<A>>

pub fn with_capacity(capacity: usize) -> Alpha<Yxy<Wp, Vec<T>>, Vec<A>>

Create a struct of vectors with a minimum capacity. See Vec::with_capacity for details.

pub fn push(&mut self, value: Alpha<Yxy<Wp, T>, A>)

Push an additional color’s components onto the component vectors. See Vec::push for details.

pub fn pop(&mut self) -> Option<Alpha<Yxy<Wp, T>, A>>

Pop a color’s components from the component vectors. See Vec::pop for details.

pub fn clear(&mut self)

Clear the component vectors. See Vec::clear for details.

pub fn drain<R>( &mut self, range: R, ) -> Iter<Iter<Drain<'_, T>, Wp>, Drain<'_, A>>

where R: RangeBounds<usize> + Clone,

Return an iterator that moves colors out of the specified range.

Trait Implementations

impl<C, T> AbsDiffEq for Alpha<C, T>

where C: AbsDiffEq<Epsilon = <T as AbsDiffEq>::Epsilon>, T: AbsDiffEq, <T as AbsDiffEq>::Epsilon: Clone,

type Epsilon = <T as AbsDiffEq>::Epsilon

Used for specifying relative comparisons.

fn default_epsilon() -> <Alpha<C, T> as AbsDiffEq>::Epsilon

The default tolerance to use when testing values that are close together.

fn abs_diff_eq( &self, other: &Alpha<C, T>, epsilon: <T as AbsDiffEq>::Epsilon, ) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl<T, C> Add<T> for Alpha<C, T>

where T: Add + Clone, C: Add<T>,

type Output = Alpha<<C as Add<T>>::Output, <T as Add>::Output>

The resulting type after applying the + operator.

fn add(self, c: T) -> <Alpha<C, T> as Add<T>>::Output

Performs the + operation.

impl<C, T> Add for Alpha<C, T>

where C: Add, T: Add,

type Output = Alpha<<C as Add>::Output, <T as Add>::Output>

The resulting type after applying the + operator.

fn add(self, other: Alpha<C, T>) -> <Alpha<C, T> as Add>::Output

Performs the + operation.

impl<T, C> AddAssign<T> for Alpha<C, T>

where T: AddAssign + Clone, C: AddAssign<T>,

fn add_assign(&mut self, c: T)

Performs the += operation.

impl<C, T> AddAssign for Alpha<C, T>

where C: AddAssign, T: AddAssign,

fn add_assign(&mut self, other: Alpha<C, T>)

Performs the += operation.

impl<C> ArrayCast for Alpha<C, <<C as ArrayCast>::Array as ArrayExt>::Item>

where C: ArrayCast, <C as ArrayCast>::Array: NextArray,

type Array = <<C as ArrayCast>::Array as NextArray>::Next

The output type of a cast to an array.

impl<C, T, const N: usize> AsMut<[T]> for Alpha<C, T>

where Alpha<C, T>: ArrayCast<Array = [T; N]>,

fn as_mut(&mut self) -> &mut [T]

Converts this type into a mutable reference of the (usually inferred) input type.

impl<C, T, const N: usize> AsMut<[T; N]> for Alpha<C, T>

where Alpha<C, T>: ArrayCast<Array = [T; N]>,

fn as_mut(&mut self) -> &mut [T; N]

Converts this type into a mutable reference of the (usually inferred) input type.

impl<C, T, const N: usize> AsRef<[T]> for Alpha<C, T>

where Alpha<C, T>: ArrayCast<Array = [T; N]>,

fn as_ref(&self) -> &[T]

Converts this type into a shared reference of the (usually inferred) input type.

impl<C, T, const N: usize> AsRef<[T; N]> for Alpha<C, T>

where Alpha<C, T>: ArrayCast<Array = [T; N]>,

fn as_ref(&self) -> &[T; N]

Converts this type into a shared reference of the (usually inferred) input type.

impl<C, T, const N: usize> Blend for Alpha<C, T>

where C: Premultiply<Scalar = T> + StimulusColor + ArrayCast<Array = [T; N]> + Clone, T: Real + Zero + One + MinMax + Clamp + Sqrt + Abs + Arithmetics + PartialCmp + Clone, <T as HasBoolMask>::Mask: LazySelect<T>,

fn multiply(self, other: Alpha<C, T>) -> Alpha<C, T>

Multiply self with other. This uses the alpha component to regulate the effect, so it’s not just plain component wise multiplication.

fn screen(self, other: Alpha<C, T>) -> Alpha<C, T>

Make a color which is at least as light as self or other.

fn overlay(self, other: Alpha<C, T>) -> Alpha<C, T>

Multiply self or other if other is dark, or screen them if other is light. This results in an S curve.

fn darken(self, other: Alpha<C, T>) -> Alpha<C, T>

Return the darkest parts of self and other.

fn lighten(self, other: Alpha<C, T>) -> Alpha<C, T>

Return the lightest parts of self and other.

fn dodge(self, other: Alpha<C, T>) -> Alpha<C, T>

Lighten other to reflect self. Results in other if self is black.

fn burn(self, other: Alpha<C, T>) -> Alpha<C, T>

Darken other to reflect self. Results in other if self is white.

fn hard_light(self, other: Alpha<C, T>) -> Alpha<C, T>

Multiply self or other if other is dark, or screen them if self is light. This is similar to overlay, but depends on self instead of other.

fn soft_light(self, other: Alpha<C, T>) -> Alpha<C, T>

Lighten other if self is light, or darken other as if it’s burned if self is dark. The effect is increased if the components of self is further from 0.5.

fn difference(self, other: Alpha<C, T>) -> Alpha<C, T>

Return the absolute difference between self and other. It’s basically abs(self - other), but regulated by the alpha component.

fn exclusion(self, other: Alpha<C, T>) -> Alpha<C, T>

Similar to difference, but appears to result in a lower contrast. other is inverted if self is white, and preserved if self is black.

impl<C> BlendWith for Alpha<C, <C as Premultiply>::Scalar>

where C: Premultiply,

type Color = C

The base color type of Self.

fn blend_with<F>( self, destination: Alpha<C, <C as Premultiply>::Scalar>, blend_function: F, ) -> Alpha<C, <C as Premultiply>::Scalar>

where F: BlendFunction<<Alpha<C, <C as Premultiply>::Scalar> as BlendWith>::Color>,

Blend self, as the source color, with destination, using blend_function. Anything that implements BlendFunction is acceptable, including functions and closures.

impl<C, T> Clamp for Alpha<C, T>

where C: Clamp, T: Stimulus + Clamp,

fn clamp(self) -> Alpha<C, T>

Return a new color where out-of-bounds components have been changed to the nearest valid values.

impl<C, T> ClampAssign for Alpha<C, T>

where C: ClampAssign, T: Stimulus + ClampAssign,

fn clamp_assign(&mut self)

Changes out-of-bounds components to the nearest valid values.

impl<C, T> Clone for Alpha<C, T>

where C: Clone, T: Clone,

fn clone(&self) -> Alpha<C, T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T, A> Complementary for Alpha<Cam16UcsJab<T>, A>

where Cam16UcsJab<T>: Complementary,

fn complementary(self) -> Alpha<Cam16UcsJab<T>, A>

Return the complementary color of self.

impl<Wp, T, A> Complementary for Alpha<Lab<Wp, T>, A>

where Lab<Wp, T>: Complementary,

fn complementary(self) -> Alpha<Lab<Wp, T>, A>

Return the complementary color of self.

impl<Wp, T, A> Complementary for Alpha<Luv<Wp, T>, A>

where Luv<Wp, T>: Complementary,

fn complementary(self) -> Alpha<Luv<Wp, T>, A>

Return the complementary color of self.

impl<T, A> Complementary for Alpha<Oklab<T>, A>

where Oklab<T>: Complementary,

fn complementary(self) -> Alpha<Oklab<T>, A>

Return the complementary color of self.

impl<S, T> ComponentOrder<Alpha<Luma<S, T>, T>, [T; 2]> for Al

fn pack(color: Alpha<Luma<S, T>, T>) -> [T; 2]

Combine the components of a color into the packed format.

fn unpack(packed: [T; 2]) -> Alpha<Luma<S, T>, T>

Split the packed color into its separate components.

impl<S, T> ComponentOrder<Alpha<Luma<S, T>, T>, [T; 2]> for La

fn pack(color: Alpha<Luma<S, T>, T>) -> [T; 2]

Combine the components of a color into the packed format.

fn unpack(packed: [T; 2]) -> Alpha<Luma<S, T>, T>

Split the packed color into its separate components.

impl<S, T> ComponentOrder<Alpha<Rgb<S, T>, T>, [T; 4]> for Abgr

fn pack(color: Alpha<Rgb<S, T>, T>) -> [T; 4]

Combine the components of a color into the packed format.

fn unpack(packed: [T; 4]) -> Alpha<Rgb<S, T>, T>

Split the packed color into its separate components.

impl<S, T> ComponentOrder<Alpha<Rgb<S, T>, T>, [T; 4]> for Argb

fn pack(color: Alpha<Rgb<S, T>, T>) -> [T; 4]

Combine the components of a color into the packed format.

fn unpack(packed: [T; 4]) -> Alpha<Rgb<S, T>, T>

Split the packed color into its separate components.

impl<S, T> ComponentOrder<Alpha<Rgb<S, T>, T>, [T; 4]> for Bgra

fn pack(color: Alpha<Rgb<S, T>, T>) -> [T; 4]

Combine the components of a color into the packed format.

fn unpack(packed: [T; 4]) -> Alpha<Rgb<S, T>, T>

Split the packed color into its separate components.

impl<S, T> ComponentOrder<Alpha<Rgb<S, T>, T>, [T; 4]> for Rgba

fn pack(color: Alpha<Rgb<S, T>, T>) -> [T; 4]

Combine the components of a color into the packed format.

fn unpack(packed: [T; 4]) -> Alpha<Rgb<S, T>, T>

Split the packed color into its separate components.

impl<C> Compose for Alpha<C, <C as Premultiply>::Scalar>

where C: Premultiply, PreAlpha<C>: Compose,

fn over( self, other: Alpha<C, <C as Premultiply>::Scalar>, ) -> Alpha<C, <C as Premultiply>::Scalar>

Place self over other. This is the good old common alpha composition equation.

fn inside( self, other: Alpha<C, <C as Premultiply>::Scalar>, ) -> Alpha<C, <C as Premultiply>::Scalar>

Results in the parts of self that overlaps the visible parts of other.

fn outside( self, other: Alpha<C, <C as Premultiply>::Scalar>, ) -> Alpha<C, <C as Premultiply>::Scalar>

Results in the parts of self that lies outside the visible parts of other.

fn atop( self, other: Alpha<C, <C as Premultiply>::Scalar>, ) -> Alpha<C, <C as Premultiply>::Scalar>

Place self over only the visible parts of other.

fn xor( self, other: Alpha<C, <C as Premultiply>::Scalar>, ) -> Alpha<C, <C as Premultiply>::Scalar>

Results in either self or other, where they do not overlap.

fn plus( self, other: Alpha<C, <C as Premultiply>::Scalar>, ) -> Alpha<C, <C as Premultiply>::Scalar>

Add self and other. This uses the alpha component to regulate the effect, so it’s not just plain component wise addition.

impl<C, T> Debug for Alpha<C, T>

where C: Debug, T: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<C, T> Default for Alpha<C, T>

where C: Default, T: Stimulus,

fn default() -> Alpha<C, T>

Returns the “default value” for a type.

impl<C, T> DerefMut for Alpha<C, T>

fn deref_mut(&mut self) -> &mut C

Mutably dereferences the value.

impl<'de, C, T> Deserialize<'de> for Alpha<C, T>

where C: Deserialize<'de>, T: Deserialize<'de>,

fn deserialize<D>( deserializer: D, ) -> Result<Alpha<C, T>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T, C> Div<T> for Alpha<C, T>

where T: Div + Clone, C: Div<T>,

type Output = Alpha<<C as Div<T>>::Output, <T as Div>::Output>

The resulting type after applying the / operator.

fn div(self, c: T) -> <Alpha<C, T> as Div<T>>::Output

Performs the / operation.

impl<C, T> Div for Alpha<C, T>

where C: Div, T: Div,

type Output = Alpha<<C as Div>::Output, <T as Div>::Output>

The resulting type after applying the / operator.

fn div(self, other: Alpha<C, T>) -> <Alpha<C, T> as Div>::Output

Performs the / operation.

impl<T, C> DivAssign<T> for Alpha<C, T>

where T: DivAssign + Clone, C: DivAssign<T>,

fn div_assign(&mut self, c: T)

Performs the /= operation.

impl<C, T> DivAssign for Alpha<C, T>

where C: DivAssign, T: DivAssign,

fn div_assign(&mut self, other: Alpha<C, T>)

Performs the /= operation.

impl<Tc, Ta, C, A> Extend<Alpha<Tc, Ta>> for Alpha<C, A>

where C: Extend<Tc>, A: Extend<Ta>,

fn extend<T>(&mut self, iter: T)

where T: IntoIterator<Item = Alpha<Tc, Ta>>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'a, C, T, const N: usize> From<&'a [T; N]> for &'a Alpha<C, T>

where Alpha<C, T>: ArrayCast<Array = [T; N]>,

fn from(array: &'a [T; N]) -> &'a Alpha<C, T>

Converts to this type from the input type.

impl<'a, C, T, const N: usize> From<&'a Alpha<C, T>> for &'a [T]

where Alpha<C, T>: ArrayCast<Array = [T; N]>,

fn from(color: &'a Alpha<C, T>) -> &'a [T]

Converts to this type from the input type.

impl<'a, C, T, const N: usize> From<&'a mut [T; N]> for &'a mut Alpha<C, T>

where Alpha<C, T>: ArrayCast<Array = [T; N]>,

fn from(array: &'a mut [T; N]) -> &'a mut Alpha<C, T>

Converts to this type from the input type.

impl<'a, C, T, const N: usize> From<&'a mut Alpha<C, T>> for &'a mut [T]

where Alpha<C, T>: ArrayCast<Array = [T; N]>,

fn from(color: &'a mut Alpha<C, T>) -> &'a mut [T]

Converts to this type from the input type.

impl<T, V, const N: usize> From<[Alpha<Cam16<T>, T>; N]> for Alpha<Cam16<V>, V>

where [T; N]: Default, V: FromScalarArray<N, Scalar = T>,

fn from(colors: [Alpha<Cam16<T>, T>; N]) -> Alpha<Cam16<V>, V>

Converts to this type from the input type.

impl<T, V, const N: usize> From<[Alpha<Cam16Jch<T>, T>; N]> for Alpha<Cam16Jch<V>, V>

where [T; N]: Default, V: FromScalarArray<N, Scalar = T>,

fn from(colors: [Alpha<Cam16Jch<T>, T>; N]) -> Alpha<Cam16Jch<V>, V>

Converts to this type from the input type.

impl<T, V, const N: usize> From<[Alpha<Cam16Jmh<T>, T>; N]> for Alpha<Cam16Jmh<V>, V>

where [T; N]: Default, V: FromScalarArray<N, Scalar = T>,

fn from(colors: [Alpha<Cam16Jmh<T>, T>; N]) -> Alpha<Cam16Jmh<V>, V>

Converts to this type from the input type.

impl<T, V, const N: usize> From<[Alpha<Cam16Jsh<T>, T>; N]> for Alpha<Cam16Jsh<V>, V>

where [T; N]: Default, V: FromScalarArray<N, Scalar = T>,

fn from(colors: [Alpha<Cam16Jsh<T>, T>; N]) -> Alpha<Cam16Jsh<V>, V>

Converts to this type from the input type.

impl<T, V, const N: usize> From<[Alpha<Cam16Qch<T>, T>; N]> for Alpha<Cam16Qch<V>, V>

where [T; N]: Default, V: FromScalarArray<N, Scalar = T>,

fn from(colors: [Alpha<Cam16Qch<T>, T>; N]) -> Alpha<Cam16Qch<V>, V>

Converts to this type from the input type.

impl<T, V, const N: usize> From<[Alpha<Cam16Qmh<T>, T>; N]> for Alpha<Cam16Qmh<V>, V>

where [T; N]: Default, V: FromScalarArray<N, Scalar = T>,

fn from(colors: [Alpha<Cam16Qmh<T>, T>; N]) -> Alpha<Cam16Qmh<V>, V>

Converts to this type from the input type.

impl<T, V, const N: usize> From<[Alpha<Cam16Qsh<T>, T>; N]> for Alpha<Cam16Qsh<V>, V>

where [T; N]: Default, V: FromScalarArray<N, Scalar = T>,

fn from(colors: [Alpha<Cam16Qsh<T>, T>; N]) -> Alpha<Cam16Qsh<V>, V>

Converts to this type from the input type.

impl<T, V, const N: usize> From<[Alpha<Cam16UcsJab<T>, T>; N]> for Alpha<Cam16UcsJab<V>, V>

where [T; N]: Default, V: FromScalarArray<N, Scalar = T>,

fn from(colors: [Alpha<Cam16UcsJab<T>, T>; N]) -> Alpha<Cam16UcsJab<V>, V>

Converts to this type from the input type.

impl<T, V, const N: usize> From<[Alpha<Cam16UcsJmh<T>, T>; N]> for Alpha<Cam16UcsJmh<V>, V>

where [T; N]: Default, V: FromScalarArray<N, Scalar = T>,

fn from(colors: [Alpha<Cam16UcsJmh<T>, T>; N]) -> Alpha<Cam16UcsJmh<V>, V>

Converts to this type from the input type.

impl<S, T, V, const N: usize> From<[Alpha<Hsl<S, T>, T>; N]> for Alpha<Hsl<S, V>, V>

where [T; N]: Default, V: FromScalarArray<N, Scalar = T>,

fn from(colors: [Alpha<Hsl<S, T>, T>; N]) -> Alpha<Hsl<S, V>, V>

Converts to this type from the input type.

impl<Wp, T, V, const N: usize> From<[Alpha<Hsluv<Wp, T>, T>; N]> for Alpha<Hsluv<Wp, V>, V>

where [T; N]: Default, V: FromScalarArray<N, Scalar = T>,

fn from(colors: [Alpha<Hsluv<Wp, T>, T>; N]) -> Alpha<Hsluv<Wp, V>, V>

Converts to this type from the input type.

impl<S, T, V, const N: usize> From<[Alpha<Hsv<S, T>, T>; N]> for Alpha<Hsv<S, V>, V>

where [T; N]: Default, V: FromScalarArray<N, Scalar = T>,

fn from(colors: [Alpha<Hsv<S, T>, T>; N]) -> Alpha<Hsv<S, V>, V>

Converts to this type from the input type.

impl<S, T, V, const N: usize> From<[Alpha<Hwb<S, T>, T>; N]> for Alpha<Hwb<S, V>, V>

where [T; N]: Default, V: FromScalarArray<N, Scalar = T>,

fn from(colors: [Alpha<Hwb<S, T>, T>; N]) -> Alpha<Hwb<S, V>, V>

Converts to this type from the input type.

impl<Wp, T, V, const N: usize> From<[Alpha<Lab<Wp, T>, T>; N]> for Alpha<Lab<Wp, V>, V>

where [T; N]: Default, V: FromScalarArray<N, Scalar = T>,

fn from(colors: [Alpha<Lab<Wp, T>, T>; N]) -> Alpha<Lab<Wp, V>, V>

Converts to this type from the input type.

impl<Wp, T, V, const N: usize> From<[Alpha<Lch<Wp, T>, T>; N]> for Alpha<Lch<Wp, V>, V>

where [T; N]: Default, V: FromScalarArray<N, Scalar = T>,

fn from(colors: [Alpha<Lch<Wp, T>, T>; N]) -> Alpha<Lch<Wp, V>, V>

Converts to this type from the input type.

impl<Wp, T, V, const N: usize> From<[Alpha<Lchuv<Wp, T>, T>; N]> for Alpha<Lchuv<Wp, V>, V>

where [T; N]: Default, V: FromScalarArray<N, Scalar = T>,

fn from(colors: [Alpha<Lchuv<Wp, T>, T>; N]) -> Alpha<Lchuv<Wp, V>, V>

Converts to this type from the input type.

impl<S, T, V, const N: usize> From<[Alpha<Luma<S, T>, T>; N]> for Alpha<Luma<S, V>, V>

where [T; N]: Default, V: FromScalarArray<N, Scalar = T>,

fn from(colors: [Alpha<Luma<S, T>, T>; N]) -> Alpha<Luma<S, V>, V>

Converts to this type from the input type.

impl<Wp, T, V, const N: usize> From<[Alpha<Luv<Wp, T>, T>; N]> for Alpha<Luv<Wp, V>, V>

where [T; N]: Default, V: FromScalarArray<N, Scalar = T>,

fn from(colors: [Alpha<Luv<Wp, T>, T>; N]) -> Alpha<Luv<Wp, V>, V>

Converts to this type from the input type.

impl<T, V, const N: usize> From<[Alpha<Okhsl<T>, T>; N]> for Alpha<Okhsl<V>, V>

where [T; N]: Default, V: FromScalarArray<N, Scalar = T>,

fn from(colors: [Alpha<Okhsl<T>, T>; N]) -> Alpha<Okhsl<V>, V>

Converts to this type from the input type.

impl<T, V, const N: usize> From<[Alpha<Okhsv<T>, T>; N]> for Alpha<Okhsv<V>, V>

where [T; N]: Default, V: FromScalarArray<N, Scalar = T>,

fn from(colors: [Alpha<Okhsv<T>, T>; N]) -> Alpha<Okhsv<V>, V>

Converts to this type from the input type.

impl<T, V, const N: usize> From<[Alpha<Okhwb<T>, T>; N]> for Alpha<Okhwb<V>, V>

where [T; N]: Default, V: FromScalarArray<N, Scalar = T>,

fn from(colors: [Alpha<Okhwb<T>, T>; N]) -> Alpha<Okhwb<V>, V>

Converts to this type from the input type.

impl<T, V, const N: usize> From<[Alpha<Oklab<T>, T>; N]> for Alpha<Oklab<V>, V>

where [T; N]: Default, V: FromScalarArray<N, Scalar = T>,

fn from(colors: [Alpha<Oklab<T>, T>; N]) -> Alpha<Oklab<V>, V>

Converts to this type from the input type.

impl<T, V, const N: usize> From<[Alpha<Oklch<T>, T>; N]> for Alpha<Oklch<V>, V>

where [T; N]: Default, V: FromScalarArray<N, Scalar = T>,

fn from(colors: [Alpha<Oklch<T>, T>; N]) -> Alpha<Oklch<V>, V>

Converts to this type from the input type.

impl<S, T, V, const N: usize> From<[Alpha<Rgb<S, T>, T>; N]> for Alpha<Rgb<S, V>, V>

where [T; N]: Default, V: FromScalarArray<N, Scalar = T>,

fn from(colors: [Alpha<Rgb<S, T>, T>; N]) -> Alpha<Rgb<S, V>, V>

Converts to this type from the input type.

impl<Wp, T, V, const N: usize> From<[Alpha<Xyz<Wp, T>, T>; N]> for Alpha<Xyz<Wp, V>, V>

where [T; N]: Default, V: FromScalarArray<N, Scalar = T>,

fn from(colors: [Alpha<Xyz<Wp, T>, T>; N]) -> Alpha<Xyz<Wp, V>, V>

Converts to this type from the input type.

impl<Wp, T, V, const N: usize> From<[Alpha<Yxy<Wp, T>, T>; N]> for Alpha<Yxy<Wp, V>, V>

where [T; N]: Default, V: FromScalarArray<N, Scalar = T>,

fn from(colors: [Alpha<Yxy<Wp, T>, T>; N]) -> Alpha<Yxy<Wp, V>, V>

Converts to this type from the input type.

impl<C, T, const N: usize> From<[T; N]> for Alpha<C, T>

where Alpha<C, T>: ArrayCast<Array = [T; N]>,

fn from(array: [T; N]) -> Alpha<C, T>

Converts to this type from the input type.

impl<S, T, H, A> From<(H, T, T, A)> for Alpha<Hsl<S, T>, A>

where H: Into<RgbHue<T>>,

fn from(components: (H, T, T, A)) -> Alpha<Hsl<S, T>, A>

Converts to this type from the input type.

impl<Wp, T, H, A> From<(H, T, T, A)> for Alpha<Hsluv<Wp, T>, A>

where H: Into<LuvHue<T>>,

fn from(components: (H, T, T, A)) -> Alpha<Hsluv<Wp, T>, A>

Converts to this type from the input type.

impl<S, T, H, A> From<(H, T, T, A)> for Alpha<Hsv<S, T>, A>

where H: Into<RgbHue<T>>,

fn from(components: (H, T, T, A)) -> Alpha<Hsv<S, T>, A>

Converts to this type from the input type.

impl<S, T, H, A> From<(H, T, T, A)> for Alpha<Hwb<S, T>, A>

where H: Into<RgbHue<T>>,

fn from(components: (H, T, T, A)) -> Alpha<Hwb<S, T>, A>

Converts to this type from the input type.

impl<T, H, A> From<(H, T, T, A)> for Alpha<Okhsv<T>, A>

where H: Into<OklabHue<T>>,

fn from(components: (H, T, T, A)) -> Alpha<Okhsv<T>, A>

Converts to this type from the input type.

impl<S, T, A> From<(T, A)> for Alpha<Luma<S, T>, A>

fn from(components: (T, A)) -> Alpha<Luma<S, T>, A>

Converts to this type from the input type.

impl<T, H, A> From<(T, T, H, A)> for Alpha<Cam16Jch<T>, A>

where H: Into<Cam16Hue<T>>,

fn from(components: (T, T, H, A)) -> Alpha<Cam16Jch<T>, A>

Converts to this type from the input type.

impl<T, H, A> From<(T, T, H, A)> for Alpha<Cam16Jmh<T>, A>

where H: Into<Cam16Hue<T>>,

fn from(components: (T, T, H, A)) -> Alpha<Cam16Jmh<T>, A>

Converts to this type from the input type.

impl<T, H, A> From<(T, T, H, A)> for Alpha<Cam16Jsh<T>, A>

where H: Into<Cam16Hue<T>>,

fn from(components: (T, T, H, A)) -> Alpha<Cam16Jsh<T>, A>

Converts to this type from the input type.

impl<T, H, A> From<(T, T, H, A)> for Alpha<Cam16Qch<T>, A>

where H: Into<Cam16Hue<T>>,

fn from(components: (T, T, H, A)) -> Alpha<Cam16Qch<T>, A>

Converts to this type from the input type.

impl<T, H, A> From<(T, T, H, A)> for Alpha<Cam16Qmh<T>, A>

where H: Into<Cam16Hue<T>>,

fn from(components: (T, T, H, A)) -> Alpha<Cam16Qmh<T>, A>

Converts to this type from the input type.

impl<T, H, A> From<(T, T, H, A)> for Alpha<Cam16Qsh<T>, A>

where H: Into<Cam16Hue<T>>,

fn from(components: (T, T, H, A)) -> Alpha<Cam16Qsh<T>, A>

Converts to this type from the input type.

impl<T, H, A> From<(T, T, H, A)> for Alpha<Cam16UcsJmh<T>, A>

where H: Into<Cam16Hue<T>>,

fn from(components: (T, T, H, A)) -> Alpha<Cam16UcsJmh<T>, A>

Converts to this type from the input type.

impl<Wp, T, H, A> From<(T, T, H, A)> for Alpha<Lch<Wp, T>, A>

where H: Into<LabHue<T>>,

fn from(components: (T, T, H, A)) -> Alpha<Lch<Wp, T>, A>

Converts to this type from the input type.

impl<Wp, T, H, A> From<(T, T, H, A)> for Alpha<Lchuv<Wp, T>, A>

where H: Into<LuvHue<T>>,

fn from(components: (T, T, H, A)) -> Alpha<Lchuv<Wp, T>, A>

Converts to this type from the input type.

impl<T, H, A> From<(T, T, H, A)> for Alpha<Oklch<T>, A>

where H: Into<OklabHue<T>>,

fn from(components: (T, T, H, A)) -> Alpha<Oklch<T>, A>

Converts to this type from the input type.

impl<T, A> From<(T, T, T, A)> for Alpha<Cam16UcsJab<T>, A>

fn from(components: (T, T, T, A)) -> Alpha<Cam16UcsJab<T>, A>

Converts to this type from the input type.

impl<Wp, T, A> From<(T, T, T, A)> for Alpha<Lab<Wp, T>, A>

fn from(components: (T, T, T, A)) -> Alpha<Lab<Wp, T>, A>

Converts to this type from the input type.

impl<Wp, T, A> From<(T, T, T, A)> for Alpha<Luv<Wp, T>, A>

fn from(components: (T, T, T, A)) -> Alpha<Luv<Wp, T>, A>

Converts to this type from the input type.

impl<T, A> From<(T, T, T, A)> for Alpha<Oklab<T>, A>

fn from(components: (T, T, T, A)) -> Alpha<Oklab<T>, A>

Converts to this type from the input type.

impl<S, T, A> From<(T, T, T, A)> for Alpha<Rgb<S, T>, A>

fn from(components: (T, T, T, A)) -> Alpha<Rgb<S, T>, A>

Converts to this type from the input type.

impl<Wp, T, A> From<(T, T, T, A)> for Alpha<Xyz<Wp, T>, A>

fn from(components: (T, T, T, A)) -> Alpha<Xyz<Wp, T>, A>

Converts to this type from the input type.

impl<Wp, T, A> From<(T, T, T, A)> for Alpha<Yxy<Wp, T>, A>

fn from(components: (T, T, T, A)) -> Alpha<Yxy<Wp, T>, A>

Converts to this type from the input type.

impl<C> From<Alpha<C, <C as Premultiply>::Scalar>> for PreAlpha<C>

where C: Premultiply,

fn from(color: Alpha<C, <C as Premultiply>::Scalar>) -> PreAlpha<C>

Converts to this type from the input type.

impl<T, A> From<Alpha<Cam16<T>, A>> for Alpha<Cam16Jch<T>, A>

fn from(value: Alpha<Cam16<T>, A>) -> Alpha<Cam16Jch<T>, A>

Converts to this type from the input type.

impl<T, A> From<Alpha<Cam16<T>, A>> for Alpha<Cam16Jmh<T>, A>

fn from(value: Alpha<Cam16<T>, A>) -> Alpha<Cam16Jmh<T>, A>

Converts to this type from the input type.

impl<T, A> From<Alpha<Cam16<T>, A>> for Alpha<Cam16Jsh<T>, A>

fn from(value: Alpha<Cam16<T>, A>) -> Alpha<Cam16Jsh<T>, A>

Converts to this type from the input type.

impl<T, A> From<Alpha<Cam16<T>, A>> for Alpha<Cam16Qch<T>, A>

fn from(value: Alpha<Cam16<T>, A>) -> Alpha<Cam16Qch<T>, A>

Converts to this type from the input type.

impl<T, A> From<Alpha<Cam16<T>, A>> for Alpha<Cam16Qmh<T>, A>

fn from(value: Alpha<Cam16<T>, A>) -> Alpha<Cam16Qmh<T>, A>

Converts to this type from the input type.

impl<T, A> From<Alpha<Cam16<T>, A>> for Alpha<Cam16Qsh<T>, A>

fn from(value: Alpha<Cam16<T>, A>) -> Alpha<Cam16Qsh<T>, A>

Converts to this type from the input type.

impl<S, T, O, P> From<Alpha<Luma<S, T>, T>> for Packed<O, P>

where O: ComponentOrder<Alpha<Luma<S, T>, T>, P>,

fn from(color: Alpha<Luma<S, T>, T>) -> Packed<O, P>

Converts to this type from the input type.

impl<T, U> From<Alpha<Rgb<Linear<Srgb>, T>, T>> for Alpha<Rgb<Srgb, U>, U>

where U: FromStimulus<T>, Srgb: RgbStandard<Space = Srgb> + FromLinear<T, U>,

fn from(lin_srgba: Alpha<Rgb<Linear<Srgb>, T>, T>) -> Alpha<Rgb<Srgb, U>, U>

Converts to this type from the input type.

impl<S> From<Alpha<Rgb<S>, f32>> for Alpha<Rgb<S, f64>, f64>

fn from(color: Alpha<Rgb<S>, f32>) -> Alpha<Rgb<S, f64>, f64>

Converts to this type from the input type.

impl<S> From<Alpha<Rgb<S>, f32>> for Alpha<Rgb<S, u8>, u8>

fn from(color: Alpha<Rgb<S>, f32>) -> Alpha<Rgb<S, u8>, u8>

Converts to this type from the input type.

impl<S, T, O, P> From<Alpha<Rgb<S, T>, T>> for Packed<O, P>

where O: ComponentOrder<Alpha<Rgb<S, T>, T>, P>,

fn from(color: Alpha<Rgb<S, T>, T>) -> Packed<O, P>

Converts to this type from the input type.

impl<S> From<Alpha<Rgb<S, f64>, f64>> for Alpha<Rgb<S>, f32>

fn from(color: Alpha<Rgb<S, f64>, f64>) -> Alpha<Rgb<S>, f32>

Converts to this type from the input type.

impl<S> From<Alpha<Rgb<S, f64>, f64>> for Alpha<Rgb<S, u8>, u8>

fn from(color: Alpha<Rgb<S, f64>, f64>) -> Alpha<Rgb<S, u8>, u8>

Converts to this type from the input type.

impl<S> From<Alpha<Rgb<S, u8>, u8>> for Alpha<Rgb<S>, f32>

fn from(color: Alpha<Rgb<S, u8>, u8>) -> Alpha<Rgb<S>, f32>

Converts to this type from the input type.

impl<S> From<Alpha<Rgb<S, u8>, u8>> for Alpha<Rgb<S, f64>, f64>

fn from(color: Alpha<Rgb<S, u8>, u8>) -> Alpha<Rgb<S, f64>, f64>

Converts to this type from the input type.

impl<T, U> From<Alpha<Rgb<Srgb, T>, T>> for Alpha<Rgb<Linear<Srgb>, U>, U>

where U: FromStimulus<T>, Srgb: RgbStandard<Space = Srgb> + IntoLinear<U, T>,

fn from(srgba: Alpha<Rgb<Srgb, T>, T>) -> Alpha<Rgb<Linear<Srgb>, U>, U>

Converts to this type from the input type.

impl From<Alpha<Rgb, f32>> for Color

Converts from palette’s Rgba type to a Color.

fn from(rgba: Alpha<Rgb, f32>) -> Color

Converts to this type from the input type.

impl<C, T, const N: usize> From<Box<[T; N]>> for Box<Alpha<C, T>>

where Alpha<C, T>: ArrayCast<Array = [T; N]>,

fn from(array: Box<[T; N]>) -> Box<Alpha<C, T>>

Converts to this type from the input type.

impl<C, T> From<C> for Alpha<C, T>

where T: Stimulus,

fn from(color: C) -> Alpha<C, T>

Converts to this type from the input type.

impl From<Color> for Alpha<Rgb, f32>

Converts from Color to palette’s Rgba type.

fn from(c: Color) -> Alpha<Rgb, f32>

Converts to this type from the input type.

impl<S, T, O, P> From<Packed<O, P>> for Alpha<Luma<S, T>, T>

where O: ComponentOrder<Alpha<Luma<S, T>, T>, P>,

fn from(packed: Packed<O, P>) -> Alpha<Luma<S, T>, T>

Converts to this type from the input type.

impl<S, T, O, P> From<Packed<O, P>> for Alpha<Rgb<S, T>, T>

where O: ComponentOrder<Alpha<Rgb<S, T>, T>, P>,

fn from(packed: Packed<O, P>) -> Alpha<Rgb<S, T>, T>

Converts to this type from the input type.

impl<C> From<PreAlpha<C>> for Alpha<C, <C as Premultiply>::Scalar>

where C: Premultiply,

fn from(color: PreAlpha<C>) -> Alpha<C, <C as Premultiply>::Scalar>

Converts to this type from the input type.

impl<T, U> From<Rgb<Linear<Srgb>, T>> for Alpha<Rgb<Srgb, U>, U>

where U: Stimulus, Srgb: RgbStandard<Space = Srgb> + FromLinear<T, U>,

fn from(lin_srgb: Rgb<Linear<Srgb>, T>) -> Alpha<Rgb<Srgb, U>, U>

Converts to this type from the input type.

impl<T, U> From<Rgb<Srgb, T>> for Alpha<Rgb<Linear<Srgb>, U>, U>

where U: Stimulus, Srgb: RgbStandard<Space = Srgb> + IntoLinear<U, T>,

fn from(srgb: Rgb<Srgb, T>) -> Alpha<Rgb<Linear<Srgb>, U>, U>

Converts to this type from the input type.

impl<S> From<u16> for Alpha<Luma<S, u8>, u8>

fn from(color: u16) -> Alpha<Luma<S, u8>, u8>

Converts to this type from the input type.

impl<S> From<u32> for Alpha<Rgb<S, u8>, u8>

fn from(color: u32) -> Alpha<Rgb<S, u8>, u8>

Converts to this type from the input type.

impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16Jch<T>

where _C: IntoColorUnclamped<Cam16Jch<T>>,

fn from_color_unclamped(color: Alpha<_C, _A>) -> Cam16Jch<T>

Convert from T. The resulting color might be invalid in its color space.

impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16Jmh<T>

where _C: IntoColorUnclamped<Cam16Jmh<T>>,

fn from_color_unclamped(color: Alpha<_C, _A>) -> Cam16Jmh<T>

Convert from T. The resulting color might be invalid in its color space.

impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16Jsh<T>

where _C: IntoColorUnclamped<Cam16Jsh<T>>,

fn from_color_unclamped(color: Alpha<_C, _A>) -> Cam16Jsh<T>

Convert from T. The resulting color might be invalid in its color space.

impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16Qch<T>

where _C: IntoColorUnclamped<Cam16Qch<T>>,

fn from_color_unclamped(color: Alpha<_C, _A>) -> Cam16Qch<T>

Convert from T. The resulting color might be invalid in its color space.

impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16Qmh<T>

where _C: IntoColorUnclamped<Cam16Qmh<T>>,

fn from_color_unclamped(color: Alpha<_C, _A>) -> Cam16Qmh<T>

Convert from T. The resulting color might be invalid in its color space.

impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16Qsh<T>

where _C: IntoColorUnclamped<Cam16Qsh<T>>,

fn from_color_unclamped(color: Alpha<_C, _A>) -> Cam16Qsh<T>

Convert from T. The resulting color might be invalid in its color space.

impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16UcsJab<T>

where _C: IntoColorUnclamped<Cam16UcsJab<T>>,

fn from_color_unclamped(color: Alpha<_C, _A>) -> Cam16UcsJab<T>

Convert from T. The resulting color might be invalid in its color space.

impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Cam16UcsJmh<T>

where _C: IntoColorUnclamped<Cam16UcsJmh<T>>,

fn from_color_unclamped(color: Alpha<_C, _A>) -> Cam16UcsJmh<T>

Convert from T. The resulting color might be invalid in its color space.

impl<S, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Hsl<S, T>

where _C: IntoColorUnclamped<Hsl<S, T>>,

fn from_color_unclamped(color: Alpha<_C, _A>) -> Hsl<S, T>

Convert from T. The resulting color might be invalid in its color space.

impl<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Hsluv<Wp, T>

where _C: IntoColorUnclamped<Hsluv<Wp, T>>,

fn from_color_unclamped(color: Alpha<_C, _A>) -> Hsluv<Wp, T>

Convert from T. The resulting color might be invalid in its color space.

impl<S, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Hsv<S, T>

where _C: IntoColorUnclamped<Hsv<S, T>>,

fn from_color_unclamped(color: Alpha<_C, _A>) -> Hsv<S, T>

Convert from T. The resulting color might be invalid in its color space.

impl<S, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Hwb<S, T>

where _C: IntoColorUnclamped<Hwb<S, T>>,

fn from_color_unclamped(color: Alpha<_C, _A>) -> Hwb<S, T>

Convert from T. The resulting color might be invalid in its color space.

impl<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Lab<Wp, T>

where _C: IntoColorUnclamped<Lab<Wp, T>>,

fn from_color_unclamped(color: Alpha<_C, _A>) -> Lab<Wp, T>

Convert from T. The resulting color might be invalid in its color space.

impl<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Lch<Wp, T>

where _C: IntoColorUnclamped<Lch<Wp, T>>,

fn from_color_unclamped(color: Alpha<_C, _A>) -> Lch<Wp, T>

Convert from T. The resulting color might be invalid in its color space.

impl<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Lchuv<Wp, T>

where _C: IntoColorUnclamped<Lchuv<Wp, T>>,

fn from_color_unclamped(color: Alpha<_C, _A>) -> Lchuv<Wp, T>

Convert from T. The resulting color might be invalid in its color space.

impl<S, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Luma<S, T>

where _C: IntoColorUnclamped<Luma<S, T>>,

fn from_color_unclamped(color: Alpha<_C, _A>) -> Luma<S, T>

Convert from T. The resulting color might be invalid in its color space.

impl<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Luv<Wp, T>

where _C: IntoColorUnclamped<Luv<Wp, T>>,

fn from_color_unclamped(color: Alpha<_C, _A>) -> Luv<Wp, T>

Convert from T. The resulting color might be invalid in its color space.

impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Okhsl<T>

where _C: IntoColorUnclamped<Okhsl<T>>,

fn from_color_unclamped(color: Alpha<_C, _A>) -> Okhsl<T>

Convert from T. The resulting color might be invalid in its color space.

impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Okhsv<T>

where _C: IntoColorUnclamped<Okhsv<T>>,

fn from_color_unclamped(color: Alpha<_C, _A>) -> Okhsv<T>

Convert from T. The resulting color might be invalid in its color space.

impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Okhwb<T>

where _C: IntoColorUnclamped<Okhwb<T>>,

fn from_color_unclamped(color: Alpha<_C, _A>) -> Okhwb<T>

Convert from T. The resulting color might be invalid in its color space.

impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Oklab<T>

where _C: IntoColorUnclamped<Oklab<T>>,

fn from_color_unclamped(color: Alpha<_C, _A>) -> Oklab<T>

Convert from T. The resulting color might be invalid in its color space.

impl<T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Oklch<T>

where _C: IntoColorUnclamped<Oklch<T>>,

fn from_color_unclamped(color: Alpha<_C, _A>) -> Oklch<T>

Convert from T. The resulting color might be invalid in its color space.

impl<S, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Rgb<S, T>

where _C: IntoColorUnclamped<Rgb<S, T>>,

fn from_color_unclamped(color: Alpha<_C, _A>) -> Rgb<S, T>

Convert from T. The resulting color might be invalid in its color space.

impl<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Xyz<Wp, T>

where _C: IntoColorUnclamped<Xyz<Wp, T>>,

fn from_color_unclamped(color: Alpha<_C, _A>) -> Xyz<Wp, T>

Convert from T. The resulting color might be invalid in its color space.

impl<Wp, T, _C, _A> FromColorUnclamped<Alpha<_C, _A>> for Yxy<Wp, T>

where _C: IntoColorUnclamped<Yxy<Wp, T>>,

fn from_color_unclamped(color: Alpha<_C, _A>) -> Yxy<Wp, T>

Convert from T. The resulting color might be invalid in its color space.

impl<C1, C2, T> FromColorUnclamped<C1> for Alpha<C2, T>

where C1: WithAlpha<T>, <C1 as WithAlpha<T>>::Color: IntoColorUnclamped<C2>,

fn from_color_unclamped(other: C1) -> Alpha<C2, T>

Convert from T. The resulting color might be invalid in its color space.

impl<Tc, Ta, C, A> FromIterator<Alpha<Tc, Ta>> for Alpha<C, A>

where C: Extend<Tc> + FromIterator<Tc>, A: Extend<Ta> + Default,

fn from_iter<T>(iter: T) -> Alpha<C, A>

where T: IntoIterator<Item = Alpha<Tc, Ta>>,

Creates a value from an iterator.

impl<S> FromStr for Alpha<Rgb<S, u8>, u8>

fn from_str( hex: &str, ) -> Result<Alpha<Rgb<S, u8>, u8>, <Alpha<Rgb<S, u8>, u8> as FromStr>::Err>

Parses a color hex code of format ‘#ff00bbff’ or ‘#abcd’ (with or without the leading ‘#’) into a Rgba<S, u8> instance.

type Err = FromHexError

The associated error which can be returned from parsing.

impl<C, T> GetHue for Alpha<C, T>

where C: GetHue,

type Hue = <C as GetHue>::Hue

The kind of hue unit this color space uses.

fn get_hue(&self) -> <C as GetHue>::Hue

Calculate a hue if possible.

impl<C, T> HasBoolMask for Alpha<C, T>

where C: HasBoolMask, T: HasBoolMask<Mask = <C as HasBoolMask>::Mask>,

type Mask = <C as HasBoolMask>::Mask

The mask type to use for selecting Self values.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Jch<&'b [T]>, &'b [T]>

type Item = Alpha<Cam16Jch<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16Jch<&'b [T]>, &'b [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Jch<&'b mut [T]>, &'b mut [T]>

type Item = Alpha<Cam16Jch<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16Jch<&'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Cam16Jch<[T; N]>, [T; N]>

type Item = Alpha<Cam16Jch<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16Jch<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Jch<Box<[T]>>, Box<[T]>>

type Item = Alpha<Cam16Jch<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16Jch<Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Jch<Vec<T>>, Vec<T>>

type Item = Alpha<Cam16Jch<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16Jch<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Jmh<&'b [T]>, &'b [T]>

type Item = Alpha<Cam16Jmh<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16Jmh<&'b [T]>, &'b [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Jmh<&'b mut [T]>, &'b mut [T]>

type Item = Alpha<Cam16Jmh<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16Jmh<&'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Cam16Jmh<[T; N]>, [T; N]>

type Item = Alpha<Cam16Jmh<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16Jmh<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Jmh<Box<[T]>>, Box<[T]>>

type Item = Alpha<Cam16Jmh<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16Jmh<Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Jmh<Vec<T>>, Vec<T>>

type Item = Alpha<Cam16Jmh<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16Jmh<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Jsh<&'b [T]>, &'b [T]>

type Item = Alpha<Cam16Jsh<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16Jsh<&'b [T]>, &'b [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Jsh<&'b mut [T]>, &'b mut [T]>

type Item = Alpha<Cam16Jsh<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16Jsh<&'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Cam16Jsh<[T; N]>, [T; N]>

type Item = Alpha<Cam16Jsh<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16Jsh<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Jsh<Box<[T]>>, Box<[T]>>

type Item = Alpha<Cam16Jsh<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16Jsh<Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Jsh<Vec<T>>, Vec<T>>

type Item = Alpha<Cam16Jsh<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16Jsh<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qch<&'b [T]>, &'b [T]>

type Item = Alpha<Cam16Qch<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16Qch<&'b [T]>, &'b [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qch<&'b mut [T]>, &'b mut [T]>

type Item = Alpha<Cam16Qch<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16Qch<&'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Cam16Qch<[T; N]>, [T; N]>

type Item = Alpha<Cam16Qch<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16Qch<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qch<Box<[T]>>, Box<[T]>>

type Item = Alpha<Cam16Qch<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16Qch<Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qch<Vec<T>>, Vec<T>>

type Item = Alpha<Cam16Qch<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16Qch<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qmh<&'b [T]>, &'b [T]>

type Item = Alpha<Cam16Qmh<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16Qmh<&'b [T]>, &'b [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qmh<&'b mut [T]>, &'b mut [T]>

type Item = Alpha<Cam16Qmh<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16Qmh<&'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Cam16Qmh<[T; N]>, [T; N]>

type Item = Alpha<Cam16Qmh<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16Qmh<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qmh<Box<[T]>>, Box<[T]>>

type Item = Alpha<Cam16Qmh<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16Qmh<Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qmh<Vec<T>>, Vec<T>>

type Item = Alpha<Cam16Qmh<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16Qmh<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qsh<&'b [T]>, &'b [T]>

type Item = Alpha<Cam16Qsh<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16Qsh<&'b [T]>, &'b [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qsh<&'b mut [T]>, &'b mut [T]>

type Item = Alpha<Cam16Qsh<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16Qsh<&'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Cam16Qsh<[T; N]>, [T; N]>

type Item = Alpha<Cam16Qsh<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16Qsh<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qsh<Box<[T]>>, Box<[T]>>

type Item = Alpha<Cam16Qsh<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16Qsh<Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16Qsh<Vec<T>>, Vec<T>>

type Item = Alpha<Cam16Qsh<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16Qsh<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16UcsJab<&'b [T]>, &'b [T]>

type Item = Alpha<Cam16UcsJab<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16UcsJab<&'b [T]>, &'b [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16UcsJab<&'b mut [T]>, &'b mut [T]>

type Item = Alpha<Cam16UcsJab<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16UcsJab<&'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Cam16UcsJab<[T; N]>, [T; N]>

type Item = Alpha<Cam16UcsJab<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16UcsJab<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16UcsJab<Box<[T]>>, Box<[T]>>

type Item = Alpha<Cam16UcsJab<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16UcsJab<Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16UcsJab<Vec<T>>, Vec<T>>

type Item = Alpha<Cam16UcsJab<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16UcsJab<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16UcsJmh<&'b [T]>, &'b [T]>

type Item = Alpha<Cam16UcsJmh<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16UcsJmh<&'b [T]>, &'b [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16UcsJmh<&'b mut [T]>, &'b mut [T]>

type Item = Alpha<Cam16UcsJmh<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16UcsJmh<&'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Cam16UcsJmh<[T; N]>, [T; N]>

type Item = Alpha<Cam16UcsJmh<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16UcsJmh<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16UcsJmh<Box<[T]>>, Box<[T]>>

type Item = Alpha<Cam16UcsJmh<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16UcsJmh<Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Cam16UcsJmh<Vec<T>>, Vec<T>>

type Item = Alpha<Cam16UcsJmh<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Cam16UcsJmh<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Hsl<S, &'b [T]>, &'b [T]>

type Item = Alpha<Hsl<S, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, S>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Hsl<S, &'b [T]>, &'b [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Hsl<S, &'b mut [T]>, &'b mut [T]>

type Item = Alpha<Hsl<S, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, S>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Hsl<S, &'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, S, T, const N: usize> IntoIterator for &'a Alpha<Hsl<S, [T; N]>, [T; N]>

type Item = Alpha<Hsl<S, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, S>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Hsl<S, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Hsl<S, Box<[T]>>, Box<[T]>>

type Item = Alpha<Hsl<S, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, S>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Hsl<S, Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Hsl<S, Vec<T>>, Vec<T>>

type Item = Alpha<Hsl<S, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, S>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Hsl<S, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Hsluv<Wp, &'b [T]>, &'b [T]>

type Item = Alpha<Hsluv<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Hsluv<Wp, &'b [T]>, &'b [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Hsluv<Wp, &'b mut [T]>, &'b mut [T]>

type Item = Alpha<Hsluv<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Hsluv<Wp, &'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, Wp, T, const N: usize> IntoIterator for &'a Alpha<Hsluv<Wp, [T; N]>, [T; N]>

type Item = Alpha<Hsluv<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Hsluv<Wp, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Hsluv<Wp, Box<[T]>>, Box<[T]>>

type Item = Alpha<Hsluv<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Hsluv<Wp, Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Hsluv<Wp, Vec<T>>, Vec<T>>

type Item = Alpha<Hsluv<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Hsluv<Wp, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Hsv<S, &'b [T]>, &'b [T]>

type Item = Alpha<Hsv<S, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, S>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Hsv<S, &'b [T]>, &'b [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Hsv<S, &'b mut [T]>, &'b mut [T]>

type Item = Alpha<Hsv<S, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, S>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Hsv<S, &'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, S, T, const N: usize> IntoIterator for &'a Alpha<Hsv<S, [T; N]>, [T; N]>

type Item = Alpha<Hsv<S, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, S>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Hsv<S, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Hsv<S, Box<[T]>>, Box<[T]>>

type Item = Alpha<Hsv<S, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, S>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Hsv<S, Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Hsv<S, Vec<T>>, Vec<T>>

type Item = Alpha<Hsv<S, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, S>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Hsv<S, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Hwb<S, &'b [T]>, &'b [T]>

type Item = Alpha<Hwb<S, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, S>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Hwb<S, &'b [T]>, &'b [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Hwb<S, &'b mut [T]>, &'b mut [T]>

type Item = Alpha<Hwb<S, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, S>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Hwb<S, &'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, S, T, const N: usize> IntoIterator for &'a Alpha<Hwb<S, [T; N]>, [T; N]>

type Item = Alpha<Hwb<S, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, S>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Hwb<S, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Hwb<S, Box<[T]>>, Box<[T]>>

type Item = Alpha<Hwb<S, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, S>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Hwb<S, Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Hwb<S, Vec<T>>, Vec<T>>

type Item = Alpha<Hwb<S, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, S>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Hwb<S, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lab<Wp, &'b [T]>, &'b [T]>

type Item = Alpha<Lab<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Lab<Wp, &'b [T]>, &'b [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lab<Wp, &'b mut [T]>, &'b mut [T]>

type Item = Alpha<Lab<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Lab<Wp, &'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, Wp, T, const N: usize> IntoIterator for &'a Alpha<Lab<Wp, [T; N]>, [T; N]>

type Item = Alpha<Lab<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Lab<Wp, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lab<Wp, Box<[T]>>, Box<[T]>>

type Item = Alpha<Lab<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Lab<Wp, Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lab<Wp, Vec<T>>, Vec<T>>

type Item = Alpha<Lab<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Lab<Wp, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lch<Wp, &'b [T]>, &'b [T]>

type Item = Alpha<Lch<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Lch<Wp, &'b [T]>, &'b [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lch<Wp, &'b mut [T]>, &'b mut [T]>

type Item = Alpha<Lch<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Lch<Wp, &'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, Wp, T, const N: usize> IntoIterator for &'a Alpha<Lch<Wp, [T; N]>, [T; N]>

type Item = Alpha<Lch<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Lch<Wp, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lch<Wp, Box<[T]>>, Box<[T]>>

type Item = Alpha<Lch<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Lch<Wp, Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lch<Wp, Vec<T>>, Vec<T>>

type Item = Alpha<Lch<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Lch<Wp, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lchuv<Wp, &'b [T]>, &'b [T]>

type Item = Alpha<Lchuv<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Lchuv<Wp, &'b [T]>, &'b [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lchuv<Wp, &'b mut [T]>, &'b mut [T]>

type Item = Alpha<Lchuv<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Lchuv<Wp, &'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, Wp, T, const N: usize> IntoIterator for &'a Alpha<Lchuv<Wp, [T; N]>, [T; N]>

type Item = Alpha<Lchuv<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Lchuv<Wp, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lchuv<Wp, Box<[T]>>, Box<[T]>>

type Item = Alpha<Lchuv<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Lchuv<Wp, Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Lchuv<Wp, Vec<T>>, Vec<T>>

type Item = Alpha<Lchuv<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Lchuv<Wp, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Luma<S, &'b [T]>, &'b [T]>

type Item = Alpha<Luma<S, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, S>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Luma<S, &'b [T]>, &'b [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Luma<S, &'b mut [T]>, &'b mut [T]>

type Item = Alpha<Luma<S, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, S>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Luma<S, &'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, S, T, const N: usize> IntoIterator for &'a Alpha<Luma<S, [T; N]>, [T; N]>

type Item = Alpha<Luma<S, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, S>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Luma<S, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Luma<S, Box<[T]>>, Box<[T]>>

type Item = Alpha<Luma<S, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, S>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Luma<S, Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Luma<S, Vec<T>>, Vec<T>>

type Item = Alpha<Luma<S, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, S>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Luma<S, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Luv<Wp, &'b [T]>, &'b [T]>

type Item = Alpha<Luv<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Luv<Wp, &'b [T]>, &'b [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Luv<Wp, &'b mut [T]>, &'b mut [T]>

type Item = Alpha<Luv<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Luv<Wp, &'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, Wp, T, const N: usize> IntoIterator for &'a Alpha<Luv<Wp, [T; N]>, [T; N]>

type Item = Alpha<Luv<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Luv<Wp, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Luv<Wp, Box<[T]>>, Box<[T]>>

type Item = Alpha<Luv<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Luv<Wp, Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Luv<Wp, Vec<T>>, Vec<T>>

type Item = Alpha<Luv<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Luv<Wp, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhsl<&'b [T]>, &'b [T]>

type Item = Alpha<Okhsl<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Okhsl<&'b [T]>, &'b [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhsl<&'b mut [T]>, &'b mut [T]>

type Item = Alpha<Okhsl<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Okhsl<&'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Okhsl<[T; N]>, [T; N]>

type Item = Alpha<Okhsl<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Okhsl<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhsl<Box<[T]>>, Box<[T]>>

type Item = Alpha<Okhsl<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Okhsl<Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhsl<Vec<T>>, Vec<T>>

type Item = Alpha<Okhsl<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Okhsl<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhsv<&'b [T]>, &'b [T]>

type Item = Alpha<Okhsv<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Okhsv<&'b [T]>, &'b [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhsv<&'b mut [T]>, &'b mut [T]>

type Item = Alpha<Okhsv<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Okhsv<&'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Okhsv<[T; N]>, [T; N]>

type Item = Alpha<Okhsv<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Okhsv<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhsv<Box<[T]>>, Box<[T]>>

type Item = Alpha<Okhsv<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Okhsv<Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhsv<Vec<T>>, Vec<T>>

type Item = Alpha<Okhsv<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Okhsv<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhwb<&'b [T]>, &'b [T]>

type Item = Alpha<Okhwb<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Okhwb<&'b [T]>, &'b [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhwb<&'b mut [T]>, &'b mut [T]>

type Item = Alpha<Okhwb<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Okhwb<&'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Okhwb<[T; N]>, [T; N]>

type Item = Alpha<Okhwb<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Okhwb<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhwb<Box<[T]>>, Box<[T]>>

type Item = Alpha<Okhwb<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Okhwb<Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Okhwb<Vec<T>>, Vec<T>>

type Item = Alpha<Okhwb<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Okhwb<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Oklab<&'b [T]>, &'b [T]>

type Item = Alpha<Oklab<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Oklab<&'b [T]>, &'b [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Oklab<&'b mut [T]>, &'b mut [T]>

type Item = Alpha<Oklab<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Oklab<&'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Oklab<[T; N]>, [T; N]>

type Item = Alpha<Oklab<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Oklab<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Oklab<Box<[T]>>, Box<[T]>>

type Item = Alpha<Oklab<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Oklab<Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Oklab<Vec<T>>, Vec<T>>

type Item = Alpha<Oklab<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Oklab<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Oklch<&'b [T]>, &'b [T]>

type Item = Alpha<Oklch<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Oklch<&'b [T]>, &'b [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Oklch<&'b mut [T]>, &'b mut [T]>

type Item = Alpha<Oklch<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Oklch<&'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T, const N: usize> IntoIterator for &'a Alpha<Oklch<[T; N]>, [T; N]>

type Item = Alpha<Oklch<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Oklch<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Oklch<Box<[T]>>, Box<[T]>>

type Item = Alpha<Oklch<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Oklch<Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a Alpha<Oklch<Vec<T>>, Vec<T>>

type Item = Alpha<Oklch<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Oklch<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Rgb<S, &'b [T]>, &'b [T]>

type Item = Alpha<Rgb<S, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, S>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Rgb<S, &'b [T]>, &'b [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Rgb<S, &'b mut [T]>, &'b mut [T]>

type Item = Alpha<Rgb<S, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, S>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Rgb<S, &'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, S, T, const N: usize> IntoIterator for &'a Alpha<Rgb<S, [T; N]>, [T; N]>

type Item = Alpha<Rgb<S, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, S>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Rgb<S, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Rgb<S, Box<[T]>>, Box<[T]>>

type Item = Alpha<Rgb<S, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, S>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Rgb<S, Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, S, T> IntoIterator for &'a Alpha<Rgb<S, Vec<T>>, Vec<T>>

type Item = Alpha<Rgb<S, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, S>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Rgb<S, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Xyz<Wp, &'b [T]>, &'b [T]>

type Item = Alpha<Xyz<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Xyz<Wp, &'b [T]>, &'b [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Xyz<Wp, &'b mut [T]>, &'b mut [T]>

type Item = Alpha<Xyz<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Xyz<Wp, &'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, Wp, T, const N: usize> IntoIterator for &'a Alpha<Xyz<Wp, [T; N]>, [T; N]>

type Item = Alpha<Xyz<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Xyz<Wp, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Xyz<Wp, Box<[T]>>, Box<[T]>>

type Item = Alpha<Xyz<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Xyz<Wp, Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Xyz<Wp, Vec<T>>, Vec<T>>

type Item = Alpha<Xyz<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Xyz<Wp, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Yxy<Wp, &'b [T]>, &'b [T]>

type Item = Alpha<Yxy<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Yxy<Wp, &'b [T]>, &'b [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Yxy<Wp, &'b mut [T]>, &'b mut [T]>

type Item = Alpha<Yxy<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Yxy<Wp, &'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, Wp, T, const N: usize> IntoIterator for &'a Alpha<Yxy<Wp, [T; N]>, [T; N]>

type Item = Alpha<Yxy<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Yxy<Wp, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Yxy<Wp, Box<[T]>>, Box<[T]>>

type Item = Alpha<Yxy<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Yxy<Wp, Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a Alpha<Yxy<Wp, Vec<T>>, Vec<T>>

type Item = Alpha<Yxy<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a Alpha<Yxy<Wp, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Jch<&'b mut [T]>, &'b mut [T]>

type Item = Alpha<Cam16Jch<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Cam16Jch<&'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Cam16Jch<[T; N]>, [T; N]>

type Item = Alpha<Cam16Jch<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Cam16Jch<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Jch<Box<[T]>>, Box<[T]>>

type Item = Alpha<Cam16Jch<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Cam16Jch<Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Jch<Vec<T>>, Vec<T>>

type Item = Alpha<Cam16Jch<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Cam16Jch<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Jmh<&'b mut [T]>, &'b mut [T]>

type Item = Alpha<Cam16Jmh<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Cam16Jmh<&'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Cam16Jmh<[T; N]>, [T; N]>

type Item = Alpha<Cam16Jmh<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Cam16Jmh<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Jmh<Box<[T]>>, Box<[T]>>

type Item = Alpha<Cam16Jmh<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Cam16Jmh<Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Jmh<Vec<T>>, Vec<T>>

type Item = Alpha<Cam16Jmh<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Cam16Jmh<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Jsh<&'b mut [T]>, &'b mut [T]>

type Item = Alpha<Cam16Jsh<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Cam16Jsh<&'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Cam16Jsh<[T; N]>, [T; N]>

type Item = Alpha<Cam16Jsh<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Cam16Jsh<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Jsh<Box<[T]>>, Box<[T]>>

type Item = Alpha<Cam16Jsh<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Cam16Jsh<Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Jsh<Vec<T>>, Vec<T>>

type Item = Alpha<Cam16Jsh<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Cam16Jsh<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Qch<&'b mut [T]>, &'b mut [T]>

type Item = Alpha<Cam16Qch<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Cam16Qch<&'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Cam16Qch<[T; N]>, [T; N]>

type Item = Alpha<Cam16Qch<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Cam16Qch<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Qch<Box<[T]>>, Box<[T]>>

type Item = Alpha<Cam16Qch<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Cam16Qch<Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Qch<Vec<T>>, Vec<T>>

type Item = Alpha<Cam16Qch<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Cam16Qch<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Qmh<&'b mut [T]>, &'b mut [T]>

type Item = Alpha<Cam16Qmh<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Cam16Qmh<&'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Cam16Qmh<[T; N]>, [T; N]>

type Item = Alpha<Cam16Qmh<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Cam16Qmh<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Qmh<Box<[T]>>, Box<[T]>>

type Item = Alpha<Cam16Qmh<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Cam16Qmh<Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Qmh<Vec<T>>, Vec<T>>

type Item = Alpha<Cam16Qmh<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Cam16Qmh<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Qsh<&'b mut [T]>, &'b mut [T]>

type Item = Alpha<Cam16Qsh<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Cam16Qsh<&'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Cam16Qsh<[T; N]>, [T; N]>

type Item = Alpha<Cam16Qsh<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Cam16Qsh<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Qsh<Box<[T]>>, Box<[T]>>

type Item = Alpha<Cam16Qsh<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Cam16Qsh<Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16Qsh<Vec<T>>, Vec<T>>

type Item = Alpha<Cam16Qsh<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Cam16Qsh<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16UcsJab<&'b mut [T]>, &'b mut [T]>

type Item = Alpha<Cam16UcsJab<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Cam16UcsJab<&'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Cam16UcsJab<[T; N]>, [T; N]>

type Item = Alpha<Cam16UcsJab<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Cam16UcsJab<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16UcsJab<Box<[T]>>, Box<[T]>>

type Item = Alpha<Cam16UcsJab<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Cam16UcsJab<Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16UcsJab<Vec<T>>, Vec<T>>

type Item = Alpha<Cam16UcsJab<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Cam16UcsJab<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16UcsJmh<&'b mut [T]>, &'b mut [T]>

type Item = Alpha<Cam16UcsJmh<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Cam16UcsJmh<&'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Cam16UcsJmh<[T; N]>, [T; N]>

type Item = Alpha<Cam16UcsJmh<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Cam16UcsJmh<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16UcsJmh<Box<[T]>>, Box<[T]>>

type Item = Alpha<Cam16UcsJmh<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Cam16UcsJmh<Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Cam16UcsJmh<Vec<T>>, Vec<T>>

type Item = Alpha<Cam16UcsJmh<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Cam16UcsJmh<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Hsl<S, &'b mut [T]>, &'b mut [T]>

type Item = Alpha<Hsl<S, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, S>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Hsl<S, &'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, S, T, const N: usize> IntoIterator for &'a mut Alpha<Hsl<S, [T; N]>, [T; N]>

type Item = Alpha<Hsl<S, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, S>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Hsl<S, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Hsl<S, Box<[T]>>, Box<[T]>>

type Item = Alpha<Hsl<S, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, S>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Hsl<S, Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Hsl<S, Vec<T>>, Vec<T>>

type Item = Alpha<Hsl<S, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, S>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Hsl<S, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Hsluv<Wp, &'b mut [T]>, &'b mut [T]>

type Item = Alpha<Hsluv<Wp, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, Wp>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Hsluv<Wp, &'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, Wp, T, const N: usize> IntoIterator for &'a mut Alpha<Hsluv<Wp, [T; N]>, [T; N]>

type Item = Alpha<Hsluv<Wp, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, Wp>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Hsluv<Wp, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Hsluv<Wp, Box<[T]>>, Box<[T]>>

type Item = Alpha<Hsluv<Wp, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, Wp>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Hsluv<Wp, Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Hsluv<Wp, Vec<T>>, Vec<T>>

type Item = Alpha<Hsluv<Wp, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, Wp>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Hsluv<Wp, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Hsv<S, &'b mut [T]>, &'b mut [T]>

type Item = Alpha<Hsv<S, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, S>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Hsv<S, &'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, S, T, const N: usize> IntoIterator for &'a mut Alpha<Hsv<S, [T; N]>, [T; N]>

type Item = Alpha<Hsv<S, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, S>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Hsv<S, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Hsv<S, Box<[T]>>, Box<[T]>>

type Item = Alpha<Hsv<S, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, S>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Hsv<S, Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Hsv<S, Vec<T>>, Vec<T>>

type Item = Alpha<Hsv<S, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, S>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Hsv<S, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Hwb<S, &'b mut [T]>, &'b mut [T]>

type Item = Alpha<Hwb<S, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, S>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Hwb<S, &'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, S, T, const N: usize> IntoIterator for &'a mut Alpha<Hwb<S, [T; N]>, [T; N]>

type Item = Alpha<Hwb<S, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, S>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Hwb<S, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Hwb<S, Box<[T]>>, Box<[T]>>

type Item = Alpha<Hwb<S, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, S>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Hwb<S, Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Hwb<S, Vec<T>>, Vec<T>>

type Item = Alpha<Hwb<S, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, S>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Hwb<S, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Lab<Wp, &'b mut [T]>, &'b mut [T]>

type Item = Alpha<Lab<Wp, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, Wp>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Lab<Wp, &'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, Wp, T, const N: usize> IntoIterator for &'a mut Alpha<Lab<Wp, [T; N]>, [T; N]>

type Item = Alpha<Lab<Wp, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, Wp>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Lab<Wp, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Lab<Wp, Box<[T]>>, Box<[T]>>

type Item = Alpha<Lab<Wp, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, Wp>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Lab<Wp, Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Lab<Wp, Vec<T>>, Vec<T>>

type Item = Alpha<Lab<Wp, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, Wp>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Lab<Wp, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Lch<Wp, &'b mut [T]>, &'b mut [T]>

type Item = Alpha<Lch<Wp, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, Wp>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Lch<Wp, &'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, Wp, T, const N: usize> IntoIterator for &'a mut Alpha<Lch<Wp, [T; N]>, [T; N]>

type Item = Alpha<Lch<Wp, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, Wp>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Lch<Wp, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Lch<Wp, Box<[T]>>, Box<[T]>>

type Item = Alpha<Lch<Wp, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, Wp>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Lch<Wp, Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Lch<Wp, Vec<T>>, Vec<T>>

type Item = Alpha<Lch<Wp, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, Wp>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Lch<Wp, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Lchuv<Wp, &'b mut [T]>, &'b mut [T]>

type Item = Alpha<Lchuv<Wp, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, Wp>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Lchuv<Wp, &'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, Wp, T, const N: usize> IntoIterator for &'a mut Alpha<Lchuv<Wp, [T; N]>, [T; N]>

type Item = Alpha<Lchuv<Wp, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, Wp>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Lchuv<Wp, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Lchuv<Wp, Box<[T]>>, Box<[T]>>

type Item = Alpha<Lchuv<Wp, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, Wp>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Lchuv<Wp, Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Lchuv<Wp, Vec<T>>, Vec<T>>

type Item = Alpha<Lchuv<Wp, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, Wp>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Lchuv<Wp, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Luma<S, &'b mut [T]>, &'b mut [T]>

type Item = Alpha<Luma<S, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, S>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Luma<S, &'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, S, T, const N: usize> IntoIterator for &'a mut Alpha<Luma<S, [T; N]>, [T; N]>

type Item = Alpha<Luma<S, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, S>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Luma<S, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Luma<S, Box<[T]>>, Box<[T]>>

type Item = Alpha<Luma<S, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, S>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Luma<S, Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Luma<S, Vec<T>>, Vec<T>>

type Item = Alpha<Luma<S, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, S>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Luma<S, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Luv<Wp, &'b mut [T]>, &'b mut [T]>

type Item = Alpha<Luv<Wp, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, Wp>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Luv<Wp, &'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, Wp, T, const N: usize> IntoIterator for &'a mut Alpha<Luv<Wp, [T; N]>, [T; N]>

type Item = Alpha<Luv<Wp, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, Wp>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Luv<Wp, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Luv<Wp, Box<[T]>>, Box<[T]>>

type Item = Alpha<Luv<Wp, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, Wp>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Luv<Wp, Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Luv<Wp, Vec<T>>, Vec<T>>

type Item = Alpha<Luv<Wp, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, Wp>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Luv<Wp, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Okhsl<&'b mut [T]>, &'b mut [T]>

type Item = Alpha<Okhsl<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Okhsl<&'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Okhsl<[T; N]>, [T; N]>

type Item = Alpha<Okhsl<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Okhsl<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Okhsl<Box<[T]>>, Box<[T]>>

type Item = Alpha<Okhsl<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Okhsl<Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Okhsl<Vec<T>>, Vec<T>>

type Item = Alpha<Okhsl<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Okhsl<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Okhsv<&'b mut [T]>, &'b mut [T]>

type Item = Alpha<Okhsv<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Okhsv<&'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Okhsv<[T; N]>, [T; N]>

type Item = Alpha<Okhsv<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Okhsv<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Okhsv<Box<[T]>>, Box<[T]>>

type Item = Alpha<Okhsv<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Okhsv<Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Okhsv<Vec<T>>, Vec<T>>

type Item = Alpha<Okhsv<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Okhsv<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Okhwb<&'b mut [T]>, &'b mut [T]>

type Item = Alpha<Okhwb<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Okhwb<&'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Okhwb<[T; N]>, [T; N]>

type Item = Alpha<Okhwb<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Okhwb<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Okhwb<Box<[T]>>, Box<[T]>>

type Item = Alpha<Okhwb<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Okhwb<Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Okhwb<Vec<T>>, Vec<T>>

type Item = Alpha<Okhwb<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Okhwb<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Oklab<&'b mut [T]>, &'b mut [T]>

type Item = Alpha<Oklab<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Oklab<&'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Oklab<[T; N]>, [T; N]>

type Item = Alpha<Oklab<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Oklab<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Oklab<Box<[T]>>, Box<[T]>>

type Item = Alpha<Oklab<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Oklab<Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Oklab<Vec<T>>, Vec<T>>

type Item = Alpha<Oklab<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Oklab<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Oklch<&'b mut [T]>, &'b mut [T]>

type Item = Alpha<Oklch<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Oklch<&'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T, const N: usize> IntoIterator for &'a mut Alpha<Oklch<[T; N]>, [T; N]>

type Item = Alpha<Oklch<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Oklch<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Oklch<Box<[T]>>, Box<[T]>>

type Item = Alpha<Oklch<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Oklch<Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, T> IntoIterator for &'a mut Alpha<Oklch<Vec<T>>, Vec<T>>

type Item = Alpha<Oklch<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Oklch<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Rgb<S, &'b mut [T]>, &'b mut [T]>

type Item = Alpha<Rgb<S, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, S>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Rgb<S, &'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, S, T, const N: usize> IntoIterator for &'a mut Alpha<Rgb<S, [T; N]>, [T; N]>

type Item = Alpha<Rgb<S, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, S>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Rgb<S, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Rgb<S, Box<[T]>>, Box<[T]>>

type Item = Alpha<Rgb<S, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, S>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Rgb<S, Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, S, T> IntoIterator for &'a mut Alpha<Rgb<S, Vec<T>>, Vec<T>>

type Item = Alpha<Rgb<S, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, S>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Rgb<S, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Xyz<Wp, &'b mut [T]>, &'b mut [T]>

type Item = Alpha<Xyz<Wp, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, Wp>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Xyz<Wp, &'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, Wp, T, const N: usize> IntoIterator for &'a mut Alpha<Xyz<Wp, [T; N]>, [T; N]>

type Item = Alpha<Xyz<Wp, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, Wp>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Xyz<Wp, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Xyz<Wp, Box<[T]>>, Box<[T]>>

type Item = Alpha<Xyz<Wp, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, Wp>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Xyz<Wp, Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Xyz<Wp, Vec<T>>, Vec<T>>

type Item = Alpha<Xyz<Wp, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, Wp>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Xyz<Wp, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Yxy<Wp, &'b mut [T]>, &'b mut [T]>

type Item = Alpha<Yxy<Wp, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, Wp>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Yxy<Wp, &'b mut [T]>, &'b mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, Wp, T, const N: usize> IntoIterator for &'a mut Alpha<Yxy<Wp, [T; N]>, [T; N]>

type Item = Alpha<Yxy<Wp, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, Wp>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Yxy<Wp, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Yxy<Wp, Box<[T]>>, Box<[T]>>

type Item = Alpha<Yxy<Wp, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, Wp>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Yxy<Wp, Box<[T]>>, Box<[T]>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, 'b, Wp, T> IntoIterator for &'a mut Alpha<Yxy<Wp, Vec<T>>, Vec<T>>

type Item = Alpha<Yxy<Wp, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, Wp>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <&'a mut Alpha<Yxy<Wp, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Cam16Jch<&'a [T]>, &'a [T]>

type Item = Alpha<Cam16Jch<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Cam16Jch<&'a [T]>, &'a [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Cam16Jch<&'a mut [T]>, &'a mut [T]>

type Item = Alpha<Cam16Jch<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Cam16Jch<&'a mut [T]>, &'a mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T, const N: usize> IntoIterator for Alpha<Cam16Jch<[T; N]>, [T; N]>

type Item = Alpha<Cam16Jch<T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T, N>>, IntoIter<T, N>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Cam16Jch<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Cam16Jch<Vec<T>>, Vec<T>>

type Item = Alpha<Cam16Jch<T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T>>, IntoIter<T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Cam16Jch<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Cam16Jmh<&'a [T]>, &'a [T]>

type Item = Alpha<Cam16Jmh<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Cam16Jmh<&'a [T]>, &'a [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Cam16Jmh<&'a mut [T]>, &'a mut [T]>

type Item = Alpha<Cam16Jmh<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Cam16Jmh<&'a mut [T]>, &'a mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T, const N: usize> IntoIterator for Alpha<Cam16Jmh<[T; N]>, [T; N]>

type Item = Alpha<Cam16Jmh<T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T, N>>, IntoIter<T, N>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Cam16Jmh<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Cam16Jmh<Vec<T>>, Vec<T>>

type Item = Alpha<Cam16Jmh<T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T>>, IntoIter<T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Cam16Jmh<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Cam16Jsh<&'a [T]>, &'a [T]>

type Item = Alpha<Cam16Jsh<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Cam16Jsh<&'a [T]>, &'a [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Cam16Jsh<&'a mut [T]>, &'a mut [T]>

type Item = Alpha<Cam16Jsh<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Cam16Jsh<&'a mut [T]>, &'a mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T, const N: usize> IntoIterator for Alpha<Cam16Jsh<[T; N]>, [T; N]>

type Item = Alpha<Cam16Jsh<T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T, N>>, IntoIter<T, N>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Cam16Jsh<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Cam16Jsh<Vec<T>>, Vec<T>>

type Item = Alpha<Cam16Jsh<T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T>>, IntoIter<T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Cam16Jsh<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Cam16Qch<&'a [T]>, &'a [T]>

type Item = Alpha<Cam16Qch<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Cam16Qch<&'a [T]>, &'a [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Cam16Qch<&'a mut [T]>, &'a mut [T]>

type Item = Alpha<Cam16Qch<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Cam16Qch<&'a mut [T]>, &'a mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T, const N: usize> IntoIterator for Alpha<Cam16Qch<[T; N]>, [T; N]>

type Item = Alpha<Cam16Qch<T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T, N>>, IntoIter<T, N>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Cam16Qch<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Cam16Qch<Vec<T>>, Vec<T>>

type Item = Alpha<Cam16Qch<T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T>>, IntoIter<T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Cam16Qch<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Cam16Qmh<&'a [T]>, &'a [T]>

type Item = Alpha<Cam16Qmh<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Cam16Qmh<&'a [T]>, &'a [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Cam16Qmh<&'a mut [T]>, &'a mut [T]>

type Item = Alpha<Cam16Qmh<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Cam16Qmh<&'a mut [T]>, &'a mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T, const N: usize> IntoIterator for Alpha<Cam16Qmh<[T; N]>, [T; N]>

type Item = Alpha<Cam16Qmh<T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T, N>>, IntoIter<T, N>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Cam16Qmh<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Cam16Qmh<Vec<T>>, Vec<T>>

type Item = Alpha<Cam16Qmh<T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T>>, IntoIter<T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Cam16Qmh<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Cam16Qsh<&'a [T]>, &'a [T]>

type Item = Alpha<Cam16Qsh<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Cam16Qsh<&'a [T]>, &'a [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Cam16Qsh<&'a mut [T]>, &'a mut [T]>

type Item = Alpha<Cam16Qsh<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Cam16Qsh<&'a mut [T]>, &'a mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T, const N: usize> IntoIterator for Alpha<Cam16Qsh<[T; N]>, [T; N]>

type Item = Alpha<Cam16Qsh<T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T, N>>, IntoIter<T, N>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Cam16Qsh<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Cam16Qsh<Vec<T>>, Vec<T>>

type Item = Alpha<Cam16Qsh<T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T>>, IntoIter<T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Cam16Qsh<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Cam16UcsJab<&'a [T]>, &'a [T]>

type Item = Alpha<Cam16UcsJab<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Cam16UcsJab<&'a [T]>, &'a [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Cam16UcsJab<&'a mut [T]>, &'a mut [T]>

type Item = Alpha<Cam16UcsJab<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Cam16UcsJab<&'a mut [T]>, &'a mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T, const N: usize> IntoIterator for Alpha<Cam16UcsJab<[T; N]>, [T; N]>

type Item = Alpha<Cam16UcsJab<T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T, N>>, IntoIter<T, N>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Cam16UcsJab<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Cam16UcsJab<Vec<T>>, Vec<T>>

type Item = Alpha<Cam16UcsJab<T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T>>, IntoIter<T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Cam16UcsJab<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Cam16UcsJmh<&'a [T]>, &'a [T]>

type Item = Alpha<Cam16UcsJmh<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Cam16UcsJmh<&'a [T]>, &'a [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Cam16UcsJmh<&'a mut [T]>, &'a mut [T]>

type Item = Alpha<Cam16UcsJmh<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Cam16UcsJmh<&'a mut [T]>, &'a mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T, const N: usize> IntoIterator for Alpha<Cam16UcsJmh<[T; N]>, [T; N]>

type Item = Alpha<Cam16UcsJmh<T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T, N>>, IntoIter<T, N>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Cam16UcsJmh<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Cam16UcsJmh<Vec<T>>, Vec<T>>

type Item = Alpha<Cam16UcsJmh<T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T>>, IntoIter<T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Cam16UcsJmh<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, S, T> IntoIterator for Alpha<Hsl<S, &'a [T]>, &'a [T]>

type Item = Alpha<Hsl<S, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, S>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Hsl<S, &'a [T]>, &'a [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, S, T> IntoIterator for Alpha<Hsl<S, &'a mut [T]>, &'a mut [T]>

type Item = Alpha<Hsl<S, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, S>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Hsl<S, &'a mut [T]>, &'a mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<S, T, const N: usize> IntoIterator for Alpha<Hsl<S, [T; N]>, [T; N]>

type Item = Alpha<Hsl<S, T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T, N>, S>, IntoIter<T, N>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Alpha<Hsl<S, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, S, T> IntoIterator for Alpha<Hsl<S, Vec<T>>, Vec<T>>

type Item = Alpha<Hsl<S, T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T>, S>, IntoIter<T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Alpha<Hsl<S, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, Wp, T> IntoIterator for Alpha<Hsluv<Wp, &'a [T]>, &'a [T]>

type Item = Alpha<Hsluv<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Hsluv<Wp, &'a [T]>, &'a [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, Wp, T> IntoIterator for Alpha<Hsluv<Wp, &'a mut [T]>, &'a mut [T]>

type Item = Alpha<Hsluv<Wp, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, Wp>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Hsluv<Wp, &'a mut [T]>, &'a mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<Wp, T, const N: usize> IntoIterator for Alpha<Hsluv<Wp, [T; N]>, [T; N]>

type Item = Alpha<Hsluv<Wp, T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T, N>, Wp>, IntoIter<T, N>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Hsluv<Wp, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, Wp, T> IntoIterator for Alpha<Hsluv<Wp, Vec<T>>, Vec<T>>

type Item = Alpha<Hsluv<Wp, T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T>, Wp>, IntoIter<T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Hsluv<Wp, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, S, T> IntoIterator for Alpha<Hsv<S, &'a [T]>, &'a [T]>

type Item = Alpha<Hsv<S, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, S>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Hsv<S, &'a [T]>, &'a [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, S, T> IntoIterator for Alpha<Hsv<S, &'a mut [T]>, &'a mut [T]>

type Item = Alpha<Hsv<S, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, S>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Hsv<S, &'a mut [T]>, &'a mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<S, T, const N: usize> IntoIterator for Alpha<Hsv<S, [T; N]>, [T; N]>

type Item = Alpha<Hsv<S, T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T, N>, S>, IntoIter<T, N>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Alpha<Hsv<S, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, S, T> IntoIterator for Alpha<Hsv<S, Vec<T>>, Vec<T>>

type Item = Alpha<Hsv<S, T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T>, S>, IntoIter<T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Alpha<Hsv<S, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, S, T> IntoIterator for Alpha<Hwb<S, &'a [T]>, &'a [T]>

type Item = Alpha<Hwb<S, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, S>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Hwb<S, &'a [T]>, &'a [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, S, T> IntoIterator for Alpha<Hwb<S, &'a mut [T]>, &'a mut [T]>

type Item = Alpha<Hwb<S, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, S>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Hwb<S, &'a mut [T]>, &'a mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<S, T, const N: usize> IntoIterator for Alpha<Hwb<S, [T; N]>, [T; N]>

type Item = Alpha<Hwb<S, T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T, N>, S>, IntoIter<T, N>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Alpha<Hwb<S, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, S, T> IntoIterator for Alpha<Hwb<S, Vec<T>>, Vec<T>>

type Item = Alpha<Hwb<S, T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T>, S>, IntoIter<T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Alpha<Hwb<S, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, Wp, T> IntoIterator for Alpha<Lab<Wp, &'a [T]>, &'a [T]>

type Item = Alpha<Lab<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Lab<Wp, &'a [T]>, &'a [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, Wp, T> IntoIterator for Alpha<Lab<Wp, &'a mut [T]>, &'a mut [T]>

type Item = Alpha<Lab<Wp, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, Wp>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Lab<Wp, &'a mut [T]>, &'a mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<Wp, T, const N: usize> IntoIterator for Alpha<Lab<Wp, [T; N]>, [T; N]>

type Item = Alpha<Lab<Wp, T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T, N>, Wp>, IntoIter<T, N>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Alpha<Lab<Wp, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, Wp, T> IntoIterator for Alpha<Lab<Wp, Vec<T>>, Vec<T>>

type Item = Alpha<Lab<Wp, T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T>, Wp>, IntoIter<T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Alpha<Lab<Wp, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, Wp, T> IntoIterator for Alpha<Lch<Wp, &'a [T]>, &'a [T]>

type Item = Alpha<Lch<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Lch<Wp, &'a [T]>, &'a [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, Wp, T> IntoIterator for Alpha<Lch<Wp, &'a mut [T]>, &'a mut [T]>

type Item = Alpha<Lch<Wp, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, Wp>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Lch<Wp, &'a mut [T]>, &'a mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<Wp, T, const N: usize> IntoIterator for Alpha<Lch<Wp, [T; N]>, [T; N]>

type Item = Alpha<Lch<Wp, T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T, N>, Wp>, IntoIter<T, N>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Alpha<Lch<Wp, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, Wp, T> IntoIterator for Alpha<Lch<Wp, Vec<T>>, Vec<T>>

type Item = Alpha<Lch<Wp, T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T>, Wp>, IntoIter<T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Alpha<Lch<Wp, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, Wp, T> IntoIterator for Alpha<Lchuv<Wp, &'a [T]>, &'a [T]>

type Item = Alpha<Lchuv<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Lchuv<Wp, &'a [T]>, &'a [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, Wp, T> IntoIterator for Alpha<Lchuv<Wp, &'a mut [T]>, &'a mut [T]>

type Item = Alpha<Lchuv<Wp, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, Wp>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Lchuv<Wp, &'a mut [T]>, &'a mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<Wp, T, const N: usize> IntoIterator for Alpha<Lchuv<Wp, [T; N]>, [T; N]>

type Item = Alpha<Lchuv<Wp, T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T, N>, Wp>, IntoIter<T, N>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Lchuv<Wp, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, Wp, T> IntoIterator for Alpha<Lchuv<Wp, Vec<T>>, Vec<T>>

type Item = Alpha<Lchuv<Wp, T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T>, Wp>, IntoIter<T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Lchuv<Wp, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, S, T> IntoIterator for Alpha<Luma<S, &'a [T]>, &'a [T]>

type Item = Alpha<Luma<S, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, S>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Luma<S, &'a [T]>, &'a [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, S, T> IntoIterator for Alpha<Luma<S, &'a mut [T]>, &'a mut [T]>

type Item = Alpha<Luma<S, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, S>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Luma<S, &'a mut [T]>, &'a mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<S, T, const N: usize> IntoIterator for Alpha<Luma<S, [T; N]>, [T; N]>

type Item = Alpha<Luma<S, T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T, N>, S>, IntoIter<T, N>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Alpha<Luma<S, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, S, T> IntoIterator for Alpha<Luma<S, Vec<T>>, Vec<T>>

type Item = Alpha<Luma<S, T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T>, S>, IntoIter<T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Alpha<Luma<S, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, Wp, T> IntoIterator for Alpha<Luv<Wp, &'a [T]>, &'a [T]>

type Item = Alpha<Luv<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Luv<Wp, &'a [T]>, &'a [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, Wp, T> IntoIterator for Alpha<Luv<Wp, &'a mut [T]>, &'a mut [T]>

type Item = Alpha<Luv<Wp, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, Wp>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Luv<Wp, &'a mut [T]>, &'a mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<Wp, T, const N: usize> IntoIterator for Alpha<Luv<Wp, [T; N]>, [T; N]>

type Item = Alpha<Luv<Wp, T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T, N>, Wp>, IntoIter<T, N>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Alpha<Luv<Wp, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, Wp, T> IntoIterator for Alpha<Luv<Wp, Vec<T>>, Vec<T>>

type Item = Alpha<Luv<Wp, T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T>, Wp>, IntoIter<T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Alpha<Luv<Wp, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Okhsl<&'a [T]>, &'a [T]>

type Item = Alpha<Okhsl<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Alpha<Okhsl<&'a [T]>, &'a [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Okhsl<&'a mut [T]>, &'a mut [T]>

type Item = Alpha<Okhsl<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Okhsl<&'a mut [T]>, &'a mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T, const N: usize> IntoIterator for Alpha<Okhsl<[T; N]>, [T; N]>

type Item = Alpha<Okhsl<T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T, N>>, IntoIter<T, N>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Alpha<Okhsl<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Okhsl<Vec<T>>, Vec<T>>

type Item = Alpha<Okhsl<T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T>>, IntoIter<T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Alpha<Okhsl<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Okhsv<&'a [T]>, &'a [T]>

type Item = Alpha<Okhsv<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Alpha<Okhsv<&'a [T]>, &'a [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Okhsv<&'a mut [T]>, &'a mut [T]>

type Item = Alpha<Okhsv<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Okhsv<&'a mut [T]>, &'a mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T, const N: usize> IntoIterator for Alpha<Okhsv<[T; N]>, [T; N]>

type Item = Alpha<Okhsv<T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T, N>>, IntoIter<T, N>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Alpha<Okhsv<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Okhsv<Vec<T>>, Vec<T>>

type Item = Alpha<Okhsv<T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T>>, IntoIter<T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Alpha<Okhsv<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Okhwb<&'a [T]>, &'a [T]>

type Item = Alpha<Okhwb<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Alpha<Okhwb<&'a [T]>, &'a [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Okhwb<&'a mut [T]>, &'a mut [T]>

type Item = Alpha<Okhwb<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Okhwb<&'a mut [T]>, &'a mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T, const N: usize> IntoIterator for Alpha<Okhwb<[T; N]>, [T; N]>

type Item = Alpha<Okhwb<T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T, N>>, IntoIter<T, N>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Alpha<Okhwb<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Okhwb<Vec<T>>, Vec<T>>

type Item = Alpha<Okhwb<T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T>>, IntoIter<T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Alpha<Okhwb<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Oklab<&'a [T]>, &'a [T]>

type Item = Alpha<Oklab<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Alpha<Oklab<&'a [T]>, &'a [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Oklab<&'a mut [T]>, &'a mut [T]>

type Item = Alpha<Oklab<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Oklab<&'a mut [T]>, &'a mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T, const N: usize> IntoIterator for Alpha<Oklab<[T; N]>, [T; N]>

type Item = Alpha<Oklab<T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T, N>>, IntoIter<T, N>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Alpha<Oklab<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Oklab<Vec<T>>, Vec<T>>

type Item = Alpha<Oklab<T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T>>, IntoIter<T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Alpha<Oklab<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Oklch<&'a [T]>, &'a [T]>

type Item = Alpha<Oklch<&'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Alpha<Oklch<&'a [T]>, &'a [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Oklch<&'a mut [T]>, &'a mut [T]>

type Item = Alpha<Oklch<&'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Oklch<&'a mut [T]>, &'a mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T, const N: usize> IntoIterator for Alpha<Oklch<[T; N]>, [T; N]>

type Item = Alpha<Oklch<T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T, N>>, IntoIter<T, N>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Alpha<Oklch<[T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for Alpha<Oklch<Vec<T>>, Vec<T>>

type Item = Alpha<Oklch<T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T>>, IntoIter<T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Alpha<Oklch<Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, S, T> IntoIterator for Alpha<Rgb<S, &'a [T]>, &'a [T]>

type Item = Alpha<Rgb<S, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, S>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Rgb<S, &'a [T]>, &'a [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, S, T> IntoIterator for Alpha<Rgb<S, &'a mut [T]>, &'a mut [T]>

type Item = Alpha<Rgb<S, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, S>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Rgb<S, &'a mut [T]>, &'a mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<S, T, const N: usize> IntoIterator for Alpha<Rgb<S, [T; N]>, [T; N]>

type Item = Alpha<Rgb<S, T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T, N>, S>, IntoIter<T, N>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Alpha<Rgb<S, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, S, T> IntoIterator for Alpha<Rgb<S, Vec<T>>, Vec<T>>

type Item = Alpha<Rgb<S, T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T>, S>, IntoIter<T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Alpha<Rgb<S, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, Wp, T> IntoIterator for Alpha<Xyz<Wp, &'a [T]>, &'a [T]>

type Item = Alpha<Xyz<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Xyz<Wp, &'a [T]>, &'a [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, Wp, T> IntoIterator for Alpha<Xyz<Wp, &'a mut [T]>, &'a mut [T]>

type Item = Alpha<Xyz<Wp, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, Wp>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Xyz<Wp, &'a mut [T]>, &'a mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<Wp, T, const N: usize> IntoIterator for Alpha<Xyz<Wp, [T; N]>, [T; N]>

type Item = Alpha<Xyz<Wp, T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T, N>, Wp>, IntoIter<T, N>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Alpha<Xyz<Wp, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, Wp, T> IntoIterator for Alpha<Xyz<Wp, Vec<T>>, Vec<T>>

type Item = Alpha<Xyz<Wp, T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T>, Wp>, IntoIter<T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Alpha<Xyz<Wp, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, Wp, T> IntoIterator for Alpha<Yxy<Wp, &'a [T]>, &'a [T]>

type Item = Alpha<Yxy<Wp, &'a T>, &'a T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<Iter<'a, T>, Wp>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Yxy<Wp, &'a [T]>, &'a [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, Wp, T> IntoIterator for Alpha<Yxy<Wp, &'a mut [T]>, &'a mut [T]>

type Item = Alpha<Yxy<Wp, &'a mut T>, &'a mut T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IterMut<'a, T>, Wp>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter( self, ) -> <Alpha<Yxy<Wp, &'a mut [T]>, &'a mut [T]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<Wp, T, const N: usize> IntoIterator for Alpha<Yxy<Wp, [T; N]>, [T; N]>

type Item = Alpha<Yxy<Wp, T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T, N>, Wp>, IntoIter<T, N>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Alpha<Yxy<Wp, [T; N]>, [T; N]> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, Wp, T> IntoIterator for Alpha<Yxy<Wp, Vec<T>>, Vec<T>>

type Item = Alpha<Yxy<Wp, T>, T>

The type of the elements being iterated over.

type IntoIter = Iter<Iter<IntoIter<T>, Wp>, IntoIter<T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Alpha<Yxy<Wp, Vec<T>>, Vec<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<C, T> IsWithinBounds for Alpha<C, T>

where C: IsWithinBounds, T: Stimulus + PartialCmp<Mask = <C as HasBoolMask>::Mask> + IsWithinBounds, <C as HasBoolMask>::Mask: BitAnd<Output = <C as HasBoolMask>::Mask>,

fn is_within_bounds(&self) -> <C as HasBoolMask>::Mask

Check if the color’s components are within the expected range bounds.

impl<C> Lighten for Alpha<C, <C as Lighten>::Scalar>

where C: Lighten,

type Scalar = <C as Lighten>::Scalar

The type of the lighten modifier.

fn lighten( self, factor: <C as Lighten>::Scalar, ) -> Alpha<C, <C as Lighten>::Scalar>

Scale the color towards the maximum lightness by factor, a value ranging from 0.0 to 1.0.

fn lighten_fixed( self, amount: <C as Lighten>::Scalar, ) -> Alpha<C, <C as Lighten>::Scalar>

Lighten the color by amount, a value ranging from 0.0 to 1.0.

impl<C> LightenAssign for Alpha<C, <C as LightenAssign>::Scalar>

where C: LightenAssign,

type Scalar = <C as LightenAssign>::Scalar

The type of the lighten modifier.

fn lighten_assign(&mut self, factor: <C as LightenAssign>::Scalar)

Scale the color towards the maximum lightness by factor, a value ranging from 0.0 to 1.0.

fn lighten_fixed_assign(&mut self, amount: <C as LightenAssign>::Scalar)

Lighten the color by amount, a value ranging from 0.0 to 1.0.

impl<C, T> LowerHex for Alpha<C, T>

where T: LowerHex, C: LowerHex,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<C> Mix for Alpha<C, <C as Mix>::Scalar>

where C: Mix, <C as Mix>::Scalar: Zero + One + Clamp + Arithmetics + Clone,

type Scalar = <C as Mix>::Scalar

The type of the mixing factor.

fn mix( self, other: Alpha<C, <C as Mix>::Scalar>, factor: <C as Mix>::Scalar, ) -> Alpha<C, <C as Mix>::Scalar>

Mix the color with an other color, by factor.

impl<C> MixAssign for Alpha<C, <C as MixAssign>::Scalar>

where C: MixAssign, <C as MixAssign>::Scalar: Zero + One + Clamp + Arithmetics + AddAssign + Clone,

type Scalar = <C as MixAssign>::Scalar

The type of the mixing factor.

fn mix_assign( &mut self, other: Alpha<C, <C as MixAssign>::Scalar>, factor: <C as MixAssign>::Scalar, )

Mix the color with an other color, by factor.

impl<T, C> Mul<T> for Alpha<C, T>

where T: Mul + Clone, C: Mul<T>,

type Output = Alpha<<C as Mul<T>>::Output, <T as Mul>::Output>

The resulting type after applying the * operator.

fn mul(self, c: T) -> <Alpha<C, T> as Mul<T>>::Output

Performs the * operation.

impl<C, T> Mul for Alpha<C, T>

where C: Mul, T: Mul,

type Output = Alpha<<C as Mul>::Output, <T as Mul>::Output>

The resulting type after applying the * operator.

fn mul(self, other: Alpha<C, T>) -> <Alpha<C, T> as Mul>::Output

Performs the * operation.

impl<T, C> MulAssign<T> for Alpha<C, T>

where T: MulAssign + Clone, C: MulAssign<T>,

fn mul_assign(&mut self, c: T)

Performs the *= operation.

impl<C, T> MulAssign for Alpha<C, T>

where C: MulAssign, T: MulAssign,

fn mul_assign(&mut self, other: Alpha<C, T>)

Performs the *= operation.

impl<C, T> PartialEq for Alpha<C, T>

where T: PartialEq, C: PartialEq,

fn eq(&self, other: &Alpha<C, T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<C, T> RelativeEq for Alpha<C, T>

where C: RelativeEq<Epsilon = <T as AbsDiffEq>::Epsilon>, T: RelativeEq, <T as AbsDiffEq>::Epsilon: Clone,

fn default_max_relative() -> <Alpha<C, T> as AbsDiffEq>::Epsilon

The default relative tolerance for testing values that are far-apart.

fn relative_eq( &self, other: &Alpha<C, T>, epsilon: <Alpha<C, T> as AbsDiffEq>::Epsilon, max_relative: <Alpha<C, T> as AbsDiffEq>::Epsilon, ) -> bool

A test for equality that uses a relative comparison if the values are far apart.

fn relative_ne( &self, other: &Rhs, epsilon: Self::Epsilon, max_relative: Self::Epsilon, ) -> bool

The inverse of RelativeEq::relative_eq.

impl<C> Saturate for Alpha<C, <C as Saturate>::Scalar>

where C: Saturate,

type Scalar = <C as Saturate>::Scalar

The type of the saturation modifier.

fn saturate( self, factor: <C as Saturate>::Scalar, ) -> Alpha<C, <C as Saturate>::Scalar>

Scale the color towards the maximum saturation by factor, a value ranging from 0.0 to 1.0.

fn saturate_fixed( self, amount: <C as Saturate>::Scalar, ) -> Alpha<C, <C as Saturate>::Scalar>

Increase the saturation by amount, a value ranging from 0.0 to 1.0.

impl<C> SaturateAssign for Alpha<C, <C as SaturateAssign>::Scalar>

where C: SaturateAssign,

type Scalar = <C as SaturateAssign>::Scalar

The type of the saturation modifier.

fn saturate_assign(&mut self, factor: <C as SaturateAssign>::Scalar)

Scale the color towards the maximum saturation by factor, a value ranging from 0.0 to 1.0.

fn saturate_fixed_assign(&mut self, amount: <C as SaturateAssign>::Scalar)

Increase the saturation by amount, a value ranging from 0.0 to 1.0.

impl<T, C> SaturatingAdd<T> for Alpha<C, T>

where T: SaturatingAdd + Clone, C: SaturatingAdd<T>,

type Output = Alpha<<C as SaturatingAdd<T>>::Output, <T as SaturatingAdd>::Output>

The resulting type.

fn saturating_add(self, c: T) -> <Alpha<C, T> as SaturatingAdd<T>>::Output

Returns the sum of self and other, but saturates instead of overflowing.

impl<C, T> SaturatingAdd for Alpha<C, T>

where C: SaturatingAdd, T: SaturatingAdd,

type Output = Alpha<<C as SaturatingAdd>::Output, <T as SaturatingAdd>::Output>

The resulting type.

fn saturating_add( self, other: Alpha<C, T>, ) -> <Alpha<C, T> as SaturatingAdd>::Output

Returns the sum of self and other, but saturates instead of overflowing.

impl<T, C> SaturatingSub<T> for Alpha<C, T>

where T: SaturatingSub + Clone, C: SaturatingSub<T>,

type Output = Alpha<<C as SaturatingSub<T>>::Output, <T as SaturatingSub>::Output>

The resulting type.

fn saturating_sub(self, c: T) -> <Alpha<C, T> as SaturatingSub<T>>::Output

Returns the difference of self and other, but saturates instead of overflowing.

impl<C, T> SaturatingSub for Alpha<C, T>

where C: SaturatingSub, T: SaturatingSub,

type Output = Alpha<<C as SaturatingSub>::Output, <T as SaturatingSub>::Output>

The resulting type.

fn saturating_sub( self, other: Alpha<C, T>, ) -> <Alpha<C, T> as SaturatingSub>::Output

Returns the difference of self and other, but saturates instead of overflowing.

impl<C, T> Serialize for Alpha<C, T>

where C: Serialize, T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<C, T, H> SetHue<H> for Alpha<C, T>

where C: SetHue<H>,

fn set_hue(&mut self, hue: H)

Change the hue to a specific value.

impl<C, T> ShiftHue for Alpha<C, T>

where C: ShiftHue,

type Scalar = <C as ShiftHue>::Scalar

The type of the hue modifier.

fn shift_hue(self, amount: <Alpha<C, T> as ShiftHue>::Scalar) -> Alpha<C, T>

Return a copy of self with the hue shifted by amount.

impl<C, T> ShiftHueAssign for Alpha<C, T>

where C: ShiftHueAssign,

type Scalar = <C as ShiftHueAssign>::Scalar

The type of the hue modifier.

fn shift_hue_assign(&mut self, amount: <Alpha<C, T> as ShiftHueAssign>::Scalar)

Shifts the hue by amount.

impl<T, C> Sub<T> for Alpha<C, T>

where T: Sub + Clone, C: Sub<T>,

type Output = Alpha<<C as Sub<T>>::Output, <T as Sub>::Output>

The resulting type after applying the - operator.

fn sub(self, c: T) -> <Alpha<C, T> as Sub<T>>::Output

Performs the - operation.

impl<C, T> Sub for Alpha<C, T>

where C: Sub, T: Sub,

type Output = Alpha<<C as Sub>::Output, <T as Sub>::Output>

The resulting type after applying the - operator.

fn sub(self, other: Alpha<C, T>) -> <Alpha<C, T> as Sub>::Output

Performs the - operation.

impl<T, C> SubAssign<T> for Alpha<C, T>

where T: SubAssign + Clone, C: SubAssign<T>,

fn sub_assign(&mut self, c: T)

Performs the -= operation.

impl<C, T> SubAssign for Alpha<C, T>

where C: SubAssign, T: SubAssign,

fn sub_assign(&mut self, other: Alpha<C, T>)

Performs the -= operation.

impl<T, A> Tetradic for Alpha<Cam16UcsJab<T>, A>

where Cam16UcsJab<T>: Tetradic, A: Clone,

fn tetradic( self, ) -> (Alpha<Cam16UcsJab<T>, A>, Alpha<Cam16UcsJab<T>, A>, Alpha<Cam16UcsJab<T>, A>)

Return the three additional colors of a tetradic color scheme.

impl<Wp, T, A> Tetradic for Alpha<Lab<Wp, T>, A>

where Lab<Wp, T>: Tetradic, A: Clone,

fn tetradic( self, ) -> (Alpha<Lab<Wp, T>, A>, Alpha<Lab<Wp, T>, A>, Alpha<Lab<Wp, T>, A>)

Return the three additional colors of a tetradic color scheme.

impl<Wp, T, A> Tetradic for Alpha<Luv<Wp, T>, A>

where Luv<Wp, T>: Tetradic, A: Clone,

fn tetradic( self, ) -> (Alpha<Luv<Wp, T>, A>, Alpha<Luv<Wp, T>, A>, Alpha<Luv<Wp, T>, A>)

Return the three additional colors of a tetradic color scheme.

impl<T, A> Tetradic for Alpha<Oklab<T>, A>

where Oklab<T>: Tetradic, A: Clone,

fn tetradic( self, ) -> (Alpha<Oklab<T>, A>, Alpha<Oklab<T>, A>, Alpha<Oklab<T>, A>)

Return the three additional colors of a tetradic color scheme.

impl<'a, C, T, const N: usize> TryFrom<&'a [T]> for &'a Alpha<C, T>

where Alpha<C, T>: ArrayCast<Array = [T; N]>,

type Error = <&'a [T; N] as TryFrom<&'a [T]>>::Error

The type returned in the event of a conversion error.

fn try_from( slice: &'a [T], ) -> Result<&'a Alpha<C, T>, <&'a Alpha<C, T> as TryFrom<&'a [T]>>::Error>

Performs the conversion.

impl<'a, C, T, const N: usize> TryFrom<&'a mut [T]> for &'a mut Alpha<C, T>

where Alpha<C, T>: ArrayCast<Array = [T; N]>,

type Error = <&'a mut [T; N] as TryFrom<&'a mut [T]>>::Error

The type returned in the event of a conversion error.

fn try_from( slice: &'a mut [T], ) -> Result<&'a mut Alpha<C, T>, <&'a mut Alpha<C, T> as TryFrom<&'a mut [T]>>::Error>

Performs the conversion.

impl<C, T> UlpsEq for Alpha<C, T>

where C: UlpsEq<Epsilon = <T as AbsDiffEq>::Epsilon>, T: UlpsEq, <T as AbsDiffEq>::Epsilon: Clone,

fn default_max_ulps() -> u32

The default ULPs to tolerate when testing values that are far-apart.

fn ulps_eq( &self, other: &Alpha<C, T>, epsilon: <Alpha<C, T> as AbsDiffEq>::Epsilon, max_ulps: u32, ) -> bool

A test for equality that uses units in the last place (ULP) if the values are far apart.

fn ulps_ne(&self, other: &Rhs, epsilon: Self::Epsilon, max_ulps: u32) -> bool

The inverse of UlpsEq::ulps_eq.

impl<C, T> UpperHex for Alpha<C, T>

where T: UpperHex, C: UpperHex,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<C, A> WithAlpha<A> for Alpha<C, A>

type Color = C

The opaque color type, without any transparency.

type WithAlpha = Alpha<C, A>

The color type with transparency applied.

fn with_alpha(self, alpha: A) -> <Alpha<C, A> as WithAlpha<A>>::WithAlpha

Transforms the color into a transparent color with the provided alpha value. If Self already has a transparency, it is overwritten.

fn without_alpha(self) -> <Alpha<C, A> as WithAlpha<A>>::Color

Removes the transparency from the color. If Self::Color has an internal transparency field, that field will be set to A::max_intensity() to make it opaque.

fn split(self) -> (<Alpha<C, A> as WithAlpha<A>>::Color, A)

Splits the color into separate color and transparency values.

impl<C, T, H> WithHue<H> for Alpha<C, T>

where C: WithHue<H>,

fn with_hue(self, hue: H) -> Alpha<C, T>

Return a copy of self with a specific hue.

impl<C, T> Deref for Alpha<C, T>

type Target = C

The resulting type after dereferencing.

fn deref(&self) -> &C

Dereferences the value.

impl<C, T> Copy for Alpha<C, T>

where C: Copy, T: Copy,

impl<C, T> Eq for Alpha<C, T>

where T: Eq, C: Eq,