Think about structs in structs about modular-bitfield HOT 5 CLOSED

#[derive(BitfieldSpecifier)]
struct Header {
    a: B2,
    b: B3,
}

/// Uses 3 bits in total.
#[derive(BitfieldSpecifier)]
struct HeaderHeader {
    x: B1,
    y: B2,
}

/// Uses 5 bits in total.
#[derive(BitfieldSpecifier)]
struct Header1 {
    a: B2,
    b: B3,
}

/// Uses 8 bits in total.
#[derive(BitfieldSpecifier)]
struct Header2 {
    hh: HeaderHeader,
    a: B2,
    b: B3,
}

/// Uses only header 1.
#[bitfield]
struct BaseA {
    h1: Header1,
    c: B11,
}

/// Uses only Header2.
///
/// Note that Header2 uses HeaderHeader internally.
#[bitfield]
struct BaseB {
    h: Header2,
    c: B19,
}

/// Uses all headers.
///
/// Note that this is effectively using HeaderHeader twice.
#[bitfield]
struct BaseC {
    h1: Header1,
    h2: Header2,
    h3: HeaderHeader,
    a: B7,
    b: B9,
}

/// Uses 3 bits in total.
#[derive(BitfieldSpecifier)]
struct Header {
    x: B1,
    y: B2,
}

impl modular_bitfield::Specifier for Header {
    const BITS: usize =
          <B1 as modular_bitfield::Specifier>::BITS
        + <B2 as modular_bitfield::Specifier>::BITS;
    type Base = <[(); <B1 as modular_bitfield::Specifier>::BITS
        + <B2 as modular_bitfield::Specifier>::BITS] as modular_bitfield::SpecifierBase>::Base;
    type Face = Header;
}

impl modular_bitfield::FromBits<<Header as modular_bitfield::Specifier>::Base> for Header {
    fn from_bits(bits: modular_bitfield::Bits<<Header as modular_bitfield::Specifier>::Base>) -> Self {
        // To be determined ...
    }
}

impl modular_bitfield::IntoBits<<Header as modular_bitfield::Specifier>::Base> for Header {
    fn into_bits(self) -> modular_bitfield::Bits<<Header as modular_bitfield::Specifier>::Base> {
        // To be determined ...
    }
}

#[bitfield(specifier = true)]
pub struct Header {
    a: B2,
    b: B3,
}

#[bitfield]
pub struct Generated {
    pub header: Header,
    pub rest: B3, // To make it divisible by 8.
}

impl modular_bitfield::Specifier for Header {
    const BITS: usize = 5;

    type Bytes = u8;
    type InOut = Self;

    fn into_bytes(
        value: Self::InOut,
    ) -> Result<Self::Bytes, OutOfBounds> {
        Ok(u8::from_le_bytes(value.data))
    }

    fn from_bytes(
        bytes: Self::Bytes,
    ) -> Result<Self::InOut, InvalidBitPattern<Self::Bytes>>
    {
        if bytes > ((0x01 << Self::BITS) - 1) {
            return Err(InvalidBitPattern::new(bytes))
        }
        Ok(Self {
            data: bytes.to_le_bytes(),
        })
    }
}