Trait PackedElim

pub trait PackedElim {
    type SnowyOwl;
    type HornedOwl;
    type Duck;
    type Cockatiel;
    type Chicken;
    type Bat;
    type Penguin;
    type Goose;
    type Peacock;
    type Eagle;
    type Parrot;
    type Crow;
    type Dodo;
    type Parakeet;
    type Puffin;
    type Toucan;
    type BloodmoonBat;
    type VampireBat;
}

Required Associated Types

type SnowyOwl

type HornedOwl

type Duck

type Cockatiel

type Chicken

type Bat

type Penguin

type Goose

type Peacock

type Eagle

type Parrot

type Crow

type Dodo

type Parakeet

type Puffin

type Toucan

type BloodmoonBat

type VampireBat

Implementors

impl<T> PackedElim for Pure<T>

type SnowyOwl = Pure<T>

type HornedOwl = Pure<T>

type Duck = Pure<T>

type Cockatiel = Pure<T>

type Chicken = Pure<T>

type Bat = Pure<T>

type Penguin = Pure<T>

type Goose = Pure<T>

type Peacock = Pure<T>

type Eagle = Pure<T>

type Parrot = Pure<T>

type Crow = Pure<T>

type Dodo = Pure<T>

type Parakeet = Pure<T>

type Puffin = Pure<T>

type Toucan = Pure<T>

type BloodmoonBat = Pure<T>

type VampireBat = Pure<T>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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