Struct ColorHSLAOf

#[repr(C)]
pub struct ColorHSLAOf<T> {
    pub h: T,
    pub s: T,
    pub l: T,
    pub a: T,
}

Fields

h: T

Hue. Color coefficient. Ex: 0 = red, 0.25 = green, 0.5 = blue, 0.75 = magenta

s: T

Saturation. Grayscale : 0, 1: pure color.

l: T

Light. Black & White level. 0 = black, 0.5 = pure color, 1 = white

a: T

Alpha

Implementations

impl<T> ColorHSLAOf<T>

pub const H_INDEX: usize = 0usize

Hue

pub const S_INDEX: usize = 1usize

Saturation

pub const L_INDEX: usize = 2usize

Light

pub const A_INDEX: usize = 3usize

Alpha

pub const fn new(hue: T, saturation: T, lightness: T, alpha: T) -> Self

pub const fn new_hue(hue: T) -> Self

where T: FloatingNumber,

pub const fn gray(coef: T) -> Self

where T: FloatingNumber,

pub const fn hsla(hue: T, saturation: T, lightness: T, alpha: T) -> Self

H : Color coefficient. Ex: 0 = red, 0.25 = green, 0.5 = blue, 0.75 = magenta

S : Grayscale : 0, 1: pure color.

L : Black & White level. 0 = black, 0.5 = pure color, 1 = white

pub const fn hsl(hue: T, saturation: T, lightness: T) -> Self

where T: FloatingNumber,

Alpha is at max

H : Color coefficient. Ex: 0 = red, 0.25 = green, 0.5 = blue, 0.75 = magenta

S : Grayscale : 0, 1: pure color.

L : Black & White level. 0 = black, 0.5 = pure color, 1 = white

pub fn h(&self) -> T

where T: Copy,

Hue

pub fn with_h(self, h: T) -> Self

where T: Copy,

Hue

pub fn set_h(&mut self, h: T) -> &mut Self

Hue

pub fn replace_h(self, h: T) -> T

Hue

pub fn s(&self) -> T

where T: Copy,

Saturation

pub fn with_s(self, s: T) -> Self

where T: Copy,

Saturation

pub fn set_s(&mut self, s: T) -> &mut Self

Saturation

pub fn replace_s(self, s: T) -> T

Saturation

pub fn l(&self) -> T

where T: Copy,

Light

pub fn with_l(self, l: T) -> Self

where T: Copy,

Light

pub fn set_l(&mut self, l: T) -> &mut Self

Light

pub fn replace_l(self, l: T) -> T

Light

pub fn a(&self) -> T

where T: Copy,

Alpha

pub fn with_a(self, a: T) -> Self

where T: Copy,

Alpha

pub fn set_a(&mut self, a: T) -> &mut Self

Alpha

pub fn replace_a(self, a: T) -> T

Alpha

pub fn unpack_hsl(self) -> (T, T, T)

pub fn unpack_hsla(self) -> (T, T, T, T)

Trait Implementations

impl<T> Add<T> for ColorHSLAOf<T>

where T: Add<T> + Copy,

type Output = ColorHSLAOf<<T as Add>::Output>

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Self::Output

Performs the + operation.

impl<T> Add for ColorHSLAOf<T>

where T: Add<T>,

type Output = ColorHSLAOf<<T as Add>::Output>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<T> AddAssign<&ColorHSLAOf<T>> for ColorHSLAOf<T>

where T: AddAssign + Copy,

fn add_assign(&mut self, rhs: &Self)

Performs the += operation.

impl<T> AddAssign for ColorHSLAOf<T>

where T: AddAssign,

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<T> ArrayLike<T, 4> for ColorHSLAOf<T>

type WithType<T2> = ColorHSLAOf<T2>

fn array(&self) -> &[T; 4]

fn array_mut(&mut self) -> &mut [T; 4]

const DIMENSION: usize = N

fn splat(value: T) -> Self

where T: Clone,

fn map<U, F>(self, f: F) -> Self::WithType<U>

where F: FnMut(T) -> U,

fn map_with<U, T2, F>( self, other: Self::WithType<T2>, f: F, ) -> Self::WithType<U>

where F: FnMut(T, T2) -> U,

fn any<P>(&self, p: P) -> bool

where P: FnMut(&T) -> bool,

True if the predicate is true for at least one component

fn any_with<T2, P>(&self, other: Self::WithType<T2>, p: P) -> bool

where P: FnMut(&T, &T2) -> bool,

True if the predicate is true for at least one component

fn all<P>(&self, p: P) -> bool

where P: FnMut(&T) -> bool,

True if the predicate is true for all component

fn all_with<T2, P>(&self, other: &Self::WithType<T2>, p: P) -> bool

where P: FnMut(&T, &T2) -> bool,

True if the predicate is true for all component

fn for_each<F>(&self, f: F)

where F: FnMut(&T),

fn for_each_mut<F>(&mut self, f: F)

where F: FnMut(&mut T),

fn slice(&self) -> &[T]

fn slice_mut(&mut self) -> &mut [T]

impl<T> AsMut<[T; 4]> for ColorHSLAOf<T>

fn as_mut(&mut self) -> &mut [T; 4]

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T> AsRef<[T; 4]> for ColorHSLAOf<T>

fn as_ref(&self) -> &[T; 4]

Converts this type into a shared reference of the (usually inferred) input type.

impl<T> Binary for ColorHSLAOf<T>

where T: Binary,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> BitAnd<T> for ColorHSLAOf<T>

where T: BitAnd<T> + Copy,

type Output = ColorHSLAOf<<T as BitAnd>::Output>

The resulting type after applying the & operator.

fn bitand(self, rhs: T) -> Self::Output

Performs the & operation.

impl<T> BitAnd for ColorHSLAOf<T>

where T: BitAnd<T>,

type Output = ColorHSLAOf<<T as BitAnd>::Output>

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<T> BitAndAssign<&ColorHSLAOf<T>> for ColorHSLAOf<T>

where T: BitAndAssign + Copy,

fn bitand_assign(&mut self, rhs: &Self)

Performs the &= operation.

impl<T> BitAndAssign for ColorHSLAOf<T>

where T: BitAndAssign,

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<T> BitOr<T> for ColorHSLAOf<T>

where T: BitOr<T> + Copy,

type Output = ColorHSLAOf<<T as BitOr>::Output>

The resulting type after applying the | operator.

fn bitor(self, rhs: T) -> Self::Output

Performs the | operation.

impl<T> BitOr for ColorHSLAOf<T>

where T: BitOr<T>,

type Output = ColorHSLAOf<<T as BitOr>::Output>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<T> BitOrAssign<&ColorHSLAOf<T>> for ColorHSLAOf<T>

where T: BitOrAssign + Copy,

fn bitor_assign(&mut self, rhs: &Self)

Performs the |= operation.

impl<T> BitOrAssign for ColorHSLAOf<T>

where T: BitOrAssign,

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<T> BitXor<T> for ColorHSLAOf<T>

where T: BitXor<T> + Copy,

type Output = ColorHSLAOf<<T as BitXor>::Output>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: T) -> Self::Output

Performs the ^ operation.

impl<T> BitXor for ColorHSLAOf<T>

where T: BitXor<T>,

type Output = ColorHSLAOf<<T as BitXor>::Output>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<T> BitXorAssign<&ColorHSLAOf<T>> for ColorHSLAOf<T>

where T: BitXorAssign + Copy,

fn bitxor_assign(&mut self, rhs: &Self)

Performs the ^= operation.

impl<T> BitXorAssign for ColorHSLAOf<T>

where T: BitXorAssign,

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<T> Clone for ColorHSLAOf<T>

where T: Clone,

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for ColorHSLAOf<T>

where T: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<C: FloatingNumber> Default for ColorHSLAOf<C>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for ColorHSLAOf<T>

where [T; 4]: Deserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Display for ColorHSLAOf<T>

where T: Display,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Div<T> for ColorHSLAOf<T>

where T: Div<T> + Copy,

type Output = ColorHSLAOf<<T as Div>::Output>

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Self::Output

Performs the / operation.

impl<T> Div for ColorHSLAOf<T>

where T: Div<T>,

type Output = ColorHSLAOf<<T as Div>::Output>

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<T> DivAssign<&ColorHSLAOf<T>> for ColorHSLAOf<T>

where T: DivAssign + Copy,

fn div_assign(&mut self, rhs: &Self)

Performs the /= operation.

impl<T> DivAssign for ColorHSLAOf<T>

where T: DivAssign,

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<T> From<[T; 3]> for ColorHSLAOf<T>

where T: FloatingNumber,

fn from(value: [T; 3]) -> Self

Converts to this type from the input type.

impl<T> From<[T; 4]> for ColorHSLAOf<T>

fn from(value: [T; 4]) -> Self

Converts to this type from the input type.

impl<T> From<(T, T, T)> for ColorHSLAOf<T>

where T: FloatingNumber,

fn from(value: (T, T, T)) -> Self

Converts to this type from the input type.

impl<T> From<(T, T, T, T)> for ColorHSLAOf<T>

fn from(value: (T, T, T, T)) -> Self

Converts to this type from the input type.

impl<T> From<ColorHSLAOf<T>> for [T; 3]

fn from(value: ColorHSLAOf<T>) -> Self

Converts to this type from the input type.

impl<T> From<ColorHSLAOf<T>> for [T; 4]

fn from(value: ColorHSLAOf<T>) -> Self

Converts to this type from the input type.

impl<T> From<ColorHSLAOf<T>> for (T, T, T)

fn from(value: ColorHSLAOf<T>) -> Self

Converts to this type from the input type.

impl<T> From<ColorHSLAOf<T>> for (T, T, T, T)

fn from(value: ColorHSLAOf<T>) -> Self

Converts to this type from the input type.

impl<T> From<ColorHSLAOf<T>> for Vector3<T>

fn from(value: ColorHSLAOf<T>) -> Self

Converts to this type from the input type.

impl<T> From<ColorHSLAOf<T>> for Vector4<T>

fn from(value: ColorHSLAOf<T>) -> Self

Converts to this type from the input type.

impl From<ColorHSLAOf<f32>> for Color

fn from(value: ColorHSLA) -> Self

Converts to this type from the input type.

impl From<ColorHSLAOf<f32>> for ColorByte

fn from(value: ColorHSLAOf<float>) -> Self

Converts to this type from the input type.

impl<T> From<T> for ColorHSLAOf<T>

where T: Copy,

fn from(value: T) -> Self

Converts to this type from the input type.

impl<T> From<Vector<T, 3>> for ColorHSLAOf<T>

where T: FloatingNumber,

fn from(value: Vector3<T>) -> Self

Converts to this type from the input type.

impl<T> From<Vector<T, 4>> for ColorHSLAOf<T>

fn from(value: Vector4<T>) -> Self

Converts to this type from the input type.

impl<T, Idx> Get<Idx> for ColorHSLAOf<T>

where [T; 4]: Get<Idx>,

type Output = <[T; 4] as Get<Idx>>::Output

fn try_get(&self, index: Idx) -> Result<&Self::Output, ()>

fn get(&self, index: Idx) -> Option<&Self::Output>

unsafe fn get_unchecked(&self, index: Idx) -> &Self::Output

fn get_or_panic(&self, index: Idx) -> &Self::Output

fn is_index_valid(&self, index: Idx) -> bool

True if get(index) return Some, false otherwise.

fn is_index_invalid(&self, index: Idx) -> bool

True if get(index) return None, false otherwise.

impl<T, Idx> GetManyMut<Idx> for ColorHSLAOf<T>

where [T; 4]: GetManyMut<Idx>,

fn try_get_many_mut<const N: usize>( &mut self, indices: [Idx; N], ) -> Result<[&mut Self::Output; N], ()>

Returns multiples mutables references to the values. All values that can be accessed with the indices must be disjoint.

unsafe fn get_many_unchecked_mut<const N: usize>( &mut self, indices: [Idx; N], ) -> [&mut Self::Output; N]

Returns multiples mutables references to the values. All values that can be accessed with the indices must be disjoint.

fn get_many_mut<const N: usize>( &mut self, indices: [Idx; N], ) -> Option<[&mut Self::Output; N]>

Returns multiples mutables references to the values. All values that can be accessed with the indices must be disjoint.

fn get_many_mut_or_panic<const N: usize>( &mut self, indices: [Idx; N], ) -> [&mut Self::Output; N]

Returns multiples mutables references to the values. All values that can be accessed with the indices must be disjoint.

fn try_swap(&mut self, a: Idx, b: Idx) -> Result<(), ()>

where Self::Output: Sized,

Swaps the values at two mutable locations, without deinitializing either one.

fn swap(&mut self, a: Idx, b: Idx) -> bool

where Self::Output: Sized,

Swaps the values at two mutable locations, without deinitializing either one.

fn swap_or_panic(&mut self, a: Idx, b: Idx)

where Self::Output: Sized,

Swaps the values at two mutable locations, without deinitializing either one.

unsafe fn swap_unchecked(&mut self, a: Idx, b: Idx)

where Self::Output: Sized,

Swaps the values at two mutable locations, without deinitializing either one.

impl<T, Idx> GetMut<Idx> for ColorHSLAOf<T>

where [T; 4]: GetMut<Idx>,

fn try_get_mut(&mut self, index: Idx) -> Result<&mut Self::Output, ()>

fn get_mut(&mut self, index: Idx) -> Option<&mut Self::Output>

unsafe fn get_unchecked_mut(&mut self, index: Idx) -> &mut Self::Output

fn get_mut_or_panic(&mut self, idx: Idx) -> &mut Self::Output

fn try_replace( &mut self, index: Idx, value: Self::Output, ) -> Result<Self::Output, ()>

where Self::Output: Sized,

Replace the value and return the old one.

fn replace(&mut self, index: Idx, value: Self::Output) -> Option<Self::Output>

where Self::Output: Sized,

Replace the value and return the old one.

fn replace_or_panic(&mut self, index: Idx, value: Self::Output) -> Self::Output

where Self::Output: Sized,

Replace the value and return the old one.

unsafe fn replace_unchecked( &mut self, index: Idx, value: Self::Output, ) -> Self::Output

where Self::Output: Sized,

Replace the value and return the old one.

fn try_set(&mut self, index: Idx, value: Self::Output) -> Result<(), ()>

where Self::Output: Sized,

Set the value and drop the previous one.

fn set(&mut self, index: Idx, value: Self::Output) -> bool

where Self::Output: Sized,

Set the value and drop the previous one.

fn set_or_panic(&mut self, index: Idx, value: Self::Output) -> &mut Self

where Self::Output: Sized,

Set the value and drop the previous one.

unsafe fn set_unchecked(&mut self, index: Idx, value: Self::Output) -> &mut Self

where Self::Output: Sized,

impl<T> Hash for ColorHSLAOf<T>

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T, Idx> Index<Idx> for ColorHSLAOf<T>

where [T; 4]: Index<Idx>,

type Output = <[T; 4] as Index<Idx>>::Output

The returned type after indexing.

fn index(&self, index: Idx) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T, Idx> IndexMut<Idx> for ColorHSLAOf<T>

where [T; 4]: IndexMut<Idx>,

fn index_mut(&mut self, index: Idx) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a, T> IntoIterator for &'a ColorHSLAOf<T>

where &'a [T; 4]: IntoIterator,

type Item = <&'a [T; 4] as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <&'a [T; 4] as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut ColorHSLAOf<T>

where &'a mut [T; 4]: IntoIterator,

type Item = <&'a mut [T; 4] as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <&'a mut [T; 4] as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> IntoIterator for ColorHSLAOf<T>

where [T; 4]: IntoIterator,

type Item = <[T; 4] as IntoIterator>::Item

The type of the elements being iterated over.

type IntoIter = <[T; 4] as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T> LowerExp for ColorHSLAOf<T>

where T: LowerExp,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> LowerHex for ColorHSLAOf<T>

where T: LowerHex,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Mul<T> for ColorHSLAOf<T>

where T: Mul<T> + Copy,

type Output = ColorHSLAOf<<T as Mul>::Output>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

impl<T> Mul for ColorHSLAOf<T>

where T: Mul<T>,

type Output = ColorHSLAOf<<T as Mul>::Output>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<T> MulAssign<&ColorHSLAOf<T>> for ColorHSLAOf<T>

where T: MulAssign + Copy,

fn mul_assign(&mut self, rhs: &Self)

Performs the *= operation.

impl<T> MulAssign for ColorHSLAOf<T>

where T: MulAssign,

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<T> Neg for ColorHSLAOf<T>

where T: Neg,

type Output = ColorHSLAOf<<T as Neg>::Output>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T> Not for ColorHSLAOf<T>

where T: Not,

type Output = ColorHSLAOf<<T as Not>::Output>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T> Octal for ColorHSLAOf<T>

where T: Octal,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Ord for ColorHSLAOf<T>

where T: Ord,

fn cmp(&self, rhs: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T> PartialEq for ColorHSLAOf<T>

where T: PartialEq,

fn eq(&self, rhs: &Self) -> 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<T> PartialOrd for ColorHSLAOf<T>

where T: PartialOrd,

fn partial_cmp(&self, rhs: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> Pointer for ColorHSLAOf<T>

where T: Pointer,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Product for ColorHSLAOf<T>

where Self: One + Mul<Self, Output = Self>,

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by multiplying the items.

impl<T> Rem<T> for ColorHSLAOf<T>

where T: Rem<T> + Copy,

type Output = ColorHSLAOf<<T as Rem>::Output>

The resulting type after applying the % operator.

fn rem(self, rhs: T) -> Self::Output

Performs the % operation.

impl<T> Rem for ColorHSLAOf<T>

where T: Rem<T>,

type Output = ColorHSLAOf<<T as Rem>::Output>

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl<T> RemAssign<&ColorHSLAOf<T>> for ColorHSLAOf<T>

where T: RemAssign + Copy,

fn rem_assign(&mut self, rhs: &Self)

Performs the %= operation.

impl<T> RemAssign for ColorHSLAOf<T>

where T: RemAssign,

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

impl<T> Serialize for ColorHSLAOf<T>

where [T; 4]: Serialize,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Shl<T> for ColorHSLAOf<T>

where T: Shl<T> + Copy,

type Output = ColorHSLAOf<<T as Shl>::Output>

The resulting type after applying the << operator.

fn shl(self, rhs: T) -> Self::Output

Performs the << operation.

impl<T> Shl for ColorHSLAOf<T>

where T: Shl<T>,

type Output = ColorHSLAOf<<T as Shl>::Output>

The resulting type after applying the << operator.

fn shl(self, rhs: Self) -> Self::Output

Performs the << operation.

impl<T> ShlAssign<&ColorHSLAOf<T>> for ColorHSLAOf<T>

where T: ShlAssign + Copy,

fn shl_assign(&mut self, rhs: &Self)

Performs the <<= operation.

impl<T> ShlAssign for ColorHSLAOf<T>

where T: ShlAssign,

fn shl_assign(&mut self, rhs: Self)

Performs the <<= operation.

impl<T> Shr<T> for ColorHSLAOf<T>

where T: Shr<T> + Copy,

type Output = ColorHSLAOf<<T as Shr>::Output>

The resulting type after applying the >> operator.

fn shr(self, rhs: T) -> Self::Output

Performs the >> operation.

impl<T> Shr for ColorHSLAOf<T>

where T: Shr<T>,

type Output = ColorHSLAOf<<T as Shr>::Output>

The resulting type after applying the >> operator.

fn shr(self, rhs: Self) -> Self::Output

Performs the >> operation.

impl<T> ShrAssign<&ColorHSLAOf<T>> for ColorHSLAOf<T>

where T: ShrAssign + Copy,

fn shr_assign(&mut self, rhs: &Self)

Performs the >>= operation.

impl<T> ShrAssign for ColorHSLAOf<T>

where T: ShrAssign,

fn shr_assign(&mut self, rhs: Self)

Performs the >>= operation.

impl<T> Sub<T> for ColorHSLAOf<T>

where T: Sub<T> + Copy,

type Output = ColorHSLAOf<<T as Sub>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self::Output

Performs the - operation.

impl<T> Sub for ColorHSLAOf<T>

where T: Sub<T>,

type Output = ColorHSLAOf<<T as Sub>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<T> SubAssign<&ColorHSLAOf<T>> for ColorHSLAOf<T>

where T: SubAssign + Copy,

fn sub_assign(&mut self, rhs: &Self)

Performs the -= operation.

impl<T> SubAssign for ColorHSLAOf<T>

where T: SubAssign,

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<T> Sum for ColorHSLAOf<T>

where Self: Zero + Add<Self, Output = Self>,

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<T> UpperExp for ColorHSLAOf<T>

where T: UpperExp,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> UpperHex for ColorHSLAOf<T>

where T: UpperHex,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Copy for ColorHSLAOf<T>

where T: Copy,

impl<T> Eq for ColorHSLAOf<T>

where T: Eq,