Trait PackedElim 

pub trait PackedElim {
    type AmberOrange;
    type AmberYellow;
    type BrightBrown;
    type CornflowerBlue;
    type CuriousGreen;
    type EmeraldGreen;
    type ExoticPurple;
    type FrozenBlue;
    type GhastlyYellow;
    type LoyalBrown;
    type MagicPurple;
    type NobleBlue;
    type PineGreen;
    type PumpkinOrange;
    type RubyRed;
    type RegalPurple;
    type RustBrown;
    type SapphireBlue;
    type SulfurYellow;
    type ToxicGreen;
    type ViciousRed;
    type VigorousBlack;
}

Required Associated Types

type AmberOrange

type AmberYellow

type BrightBrown

type CornflowerBlue

type CuriousGreen

type EmeraldGreen

type ExoticPurple

type FrozenBlue

type GhastlyYellow

type LoyalBrown

type MagicPurple

type NobleBlue

type PineGreen

type PumpkinOrange

type RubyRed

type RegalPurple

type RustBrown

type SapphireBlue

type SulfurYellow

type ToxicGreen

type ViciousRed

type VigorousBlack

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl<T> PackedElim for Pure<T>

type AmberOrange = Pure<T>

type AmberYellow = Pure<T>

type BrightBrown = Pure<T>

type CornflowerBlue = Pure<T>

type CuriousGreen = Pure<T>

type EmeraldGreen = Pure<T>

type ExoticPurple = Pure<T>

type FrozenBlue = Pure<T>

type GhastlyYellow = Pure<T>

type LoyalBrown = Pure<T>

type MagicPurple = Pure<T>

type NobleBlue = Pure<T>

type PineGreen = Pure<T>

type PumpkinOrange = Pure<T>

type RubyRed = Pure<T>

type RegalPurple = Pure<T>

type RustBrown = Pure<T>

type SapphireBlue = Pure<T>

type SulfurYellow = Pure<T>

type ToxicGreen = Pure<T>

type ViciousRed = Pure<T>

type VigorousBlack = Pure<T>

impl<Target> PackedElim for WeakHead<EyeColor, Target>

where WeakHead<Pure<Target>, Target>: SynthTyped<(), Target>,

type AmberOrange = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type AmberYellow = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type BrightBrown = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type CornflowerBlue = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type CuriousGreen = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type EmeraldGreen = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type ExoticPurple = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type FrozenBlue = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type GhastlyYellow = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type LoyalBrown = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type MagicPurple = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type NobleBlue = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type PineGreen = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type PumpkinOrange = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type RubyRed = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type RegalPurple = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type RustBrown = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type SapphireBlue = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type SulfurYellow = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type ToxicGreen = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type ViciousRed = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr

type VigorousBlack = <WeakHead<Pure<Target>, Target> as SynthTyped<(), Target>>::Expr