Trait PackedElim 

pub trait PackedElim {
    type None;
    type Grass;
    type TemperateLeaves;
    type PineLeaves;
    type Acacia;
    type Mangrove;
    type PalmLeavesInner;
    type PalmLeavesOuter;
    type Water;
    type GreenSludge;
    type Fruit;
    type Coconut;
    type MaybeChest;
    type Hollow;
    type Liana;
    type Normal;
    type Log;
    type Filled;
    type Sprite;
    type Chestnut;
    type Baobab;
    type BirchWood;
    type FrostpineLeaves;
    type EntitySpawner;
    type Keyhole;
    type BoneKeyhole;
    type GlassKeyhole;
    type Sign;
    type KeyholeBars;
    type HaniwaKeyhole;
    type TerracottaKeyhole;
    type SahaginKeyhole;
    type VampireKeyhole;
    type MyrmidonKeyhole;
    type MinotaurKeyhole;
    type MapleLeaves;
    type CherryLeaves;
    type AutumnLeaves;
    type RedwoodWood;
    type SpriteWithCfg;
    type Choice;
}

Required Associated Types

type None

type Grass

type TemperateLeaves

type PineLeaves

type Acacia

type Mangrove

type PalmLeavesInner

type PalmLeavesOuter

type Water

type GreenSludge

type Fruit

type Coconut

type MaybeChest

type Hollow

type Liana

type Normal

type Log

type Filled

type Sprite

type Chestnut

type Baobab

type BirchWood

type FrostpineLeaves

type EntitySpawner

type Keyhole

type BoneKeyhole

type GlassKeyhole

type Sign

type KeyholeBars

type HaniwaKeyhole

type TerracottaKeyhole

type SahaginKeyhole

type VampireKeyhole

type MyrmidonKeyhole

type MinotaurKeyhole

type MapleLeaves

type CherryLeaves

type AutumnLeaves

type RedwoodWood

type SpriteWithCfg

type Choice

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 None = Pure<T>

type Grass = Pure<T>

type TemperateLeaves = Pure<T>

type PineLeaves = Pure<T>

type Acacia = Pure<T>

type Mangrove = Pure<T>

type PalmLeavesInner = Pure<T>

type PalmLeavesOuter = Pure<T>

type Water = Pure<T>

type GreenSludge = Pure<T>

type Fruit = Pure<T>

type Coconut = Pure<T>

type MaybeChest = Pure<T>

type Hollow = Pure<T>

type Liana = Pure<T>

type Normal = Pure<T>

type Log = Pure<T>

type Filled = Pure<T>

type Sprite = Pure<T>

type Chestnut = Pure<T>

type Baobab = Pure<T>

type BirchWood = Pure<T>

type FrostpineLeaves = Pure<T>

type EntitySpawner = Pure<T>

type Keyhole = Pure<T>

type BoneKeyhole = Pure<T>

type GlassKeyhole = Pure<T>

type Sign = Pure<T>

type KeyholeBars = Pure<T>

type HaniwaKeyhole = Pure<T>

type TerracottaKeyhole = Pure<T>

type SahaginKeyhole = Pure<T>

type VampireKeyhole = Pure<T>

type MyrmidonKeyhole = Pure<T>

type MinotaurKeyhole = Pure<T>

type MapleLeaves = Pure<T>

type CherryLeaves = Pure<T>

type AutumnLeaves = Pure<T>

type RedwoodWood = Pure<T>

type SpriteWithCfg = Pure<T>

type Choice = Pure<T>

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

where WeakHead<Pure<Target>, Target>: SynthTyped<(), Target> + SynthTyped<((BlockKind, Rgb<u8>), ()), Target> + SynthTyped<((String, f32), ()), Target> + SynthTyped<((Content, u8), ()), Target> + SynthTyped<((StructureSprite, SpriteCfg), ()), Target>, WeakHead<Rgb<u8>, Target>: SynthTyped<((Rgb<u8>,), ()), Target>, WeakHead<StructureSprite, Target>: SynthTyped<((StructureSprite,), ()), Target>, WeakHead<String, Target>: SynthTyped<((String,), ()), Target>, WeakHead<Vec<(f32, StructureBlock)>, Target>: SynthTyped<((Vec<(f32, StructureBlock)>,), ()), Target>,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type Normal = <WeakHead<Rgb<u8>, Target> as SynthTyped<((Rgb<u8>,), ()), Target>>::Expr

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

type Filled = <WeakHead<Pure<Target>, Target> as SynthTyped<((BlockKind, Rgb<u8>), ()), Target>>::Expr

type Sprite = <WeakHead<StructureSprite, Target> as SynthTyped<((StructureSprite,), ()), Target>>::Expr

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

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

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

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

type EntitySpawner = <WeakHead<Pure<Target>, Target> as SynthTyped<((String, f32), ()), Target>>::Expr

type Keyhole = <WeakHead<String, Target> as SynthTyped<((String,), ()), Target>>::Expr

type BoneKeyhole = <WeakHead<String, Target> as SynthTyped<((String,), ()), Target>>::Expr

type GlassKeyhole = <WeakHead<String, Target> as SynthTyped<((String,), ()), Target>>::Expr

type Sign = <WeakHead<Pure<Target>, Target> as SynthTyped<((Content, u8), ()), Target>>::Expr

type KeyholeBars = <WeakHead<String, Target> as SynthTyped<((String,), ()), Target>>::Expr

type HaniwaKeyhole = <WeakHead<String, Target> as SynthTyped<((String,), ()), Target>>::Expr

type TerracottaKeyhole = <WeakHead<String, Target> as SynthTyped<((String,), ()), Target>>::Expr

type SahaginKeyhole = <WeakHead<String, Target> as SynthTyped<((String,), ()), Target>>::Expr

type VampireKeyhole = <WeakHead<String, Target> as SynthTyped<((String,), ()), Target>>::Expr

type MyrmidonKeyhole = <WeakHead<String, Target> as SynthTyped<((String,), ()), Target>>::Expr

type MinotaurKeyhole = <WeakHead<String, Target> as SynthTyped<((String,), ()), Target>>::Expr

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

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

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

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

type SpriteWithCfg = <WeakHead<Pure<Target>, Target> as SynthTyped<((StructureSprite, SpriteCfg), ()), Target>>::Expr

type Choice = <WeakHead<Vec<(f32, StructureBlock)>, Target> as SynthTyped<((Vec<(f32, StructureBlock)>,), ()), Target>>::Expr