Why compile fail? about rust HOT 2 CLOSED

fn main() {
    pub trait Encodable {
        fn encode(&self) -> Vec<u8>;
    }

    pub trait LengthComputable {
        fn len(&self) -> usize;
    }

    pub trait Decodable {
        fn decode<D: AsRef<[u8]>>(data: D) -> Self;
    }

    #[repr(u8)]
    #[derive(Copy, Clone)]
    pub enum DataType {
        Ack = 0x00,
        ParamSet = 0x04,
        VehicleCtrl = 0x05,
        BlueKey = 0x06,
        BlueKeyV2 = 0x07,
        ParamQuery = 0x0A,
        DataReport = 0x0C,
        FileTrans = 0x0F,
    }
    impl Encodable for DataType {
        fn encode(&self) -> Vec<u8> {
            vec![*self as u8]
        }
    }
    impl LengthComputable for DataType {
        fn len(&self) -> usize {
            std::mem::size_of::<Self>()
        }
    }
    impl Decodable for DataType {
        fn decode<D: AsRef<[u8]>>(data: D) -> Self {
            todo!()
        }
    }

    pub struct DataUnit<T>
    where
        T: Encodable + LengthComputable,
    {
        pub(crate) data_type: DataType,
        pub(crate) data: T,
    }

    impl<T> LengthComputable for DataUnit<T>
    where
        T: Encodable + LengthComputable,
    {
        fn len(&self) -> usize {
            self.data_type.len() + self.data.len()
        }
    }

    impl<T> Encodable for DataUnit<T>
    where
        T: Encodable + LengthComputable,
    {
        fn encode(&self) -> Vec<u8> {
            todo!()
        }
    }

    impl<T> Decodable for DataUnit<T>
    where
        T: Encodable + Decodable + LengthComputable,
    {
        fn decode<D: AsRef<[u8]>>(data: D) -> Self {
            let mut index = 0;
            let mut size = 0;

            size = std::mem::size_of::<DataType>();

            let data = Vec::from(data.as_ref());
            let data = &data[index..index + size];
            let data_type = DataType::decode(data);

            let data = &data[index..index + size];
            let data = T::decode(data);

            DataUnit { data_type, data }
        }
    }
}