Struct DiscardSeq 

pub struct DiscardSeq<T, Len>(/* private fields */);

Discards a length-prefixed sequence: reads the length (encoded per Len) and steps over every element with the element schema T, advancing the reader exactly as decoding the sequence would, yet never allocates a backing buffer and always yields an empty Vec.

Every wincode sequence — Vec, String, slices, sets, and maps — shares the same length prefix + elements wire layout, so this discards any of them; T only names one element’s wire form:

• a Vec<u32>: DiscardSeq<u32, Len>;
• a String: DiscardSeq<u8, Len> (identical bytes to a Vec<u8>);
• a map such as HashMap<K, V> / BTreeMap<K, V>: DiscardSeq<(K, V), Len>, since each entry is encoded as a (K, V) pair;
• nested sequences, with no allocation at any level: DiscardSeq<DiscardSeq<u8, L2>, L1> for a Vec<Vec<u8>>.

The produced value is always an empty Vec<T::Dst>, and that type is incidental. Deprecating a field is then just repointing it at DiscardSeq and changing its type to the matching Vec<…>: the field is dead, so its concrete collection type no longer matters — only that the bytes are consumed and the stream stays aligned.

The length prefix is still validated against the configured preallocation limit, so a hostile length errors out identically to a real read.

Like Discard, the sequence held in the instance is ignored on write and an empty sequence is emitted, matching what read reconstructs. Use the configuration’s default length encoding, e.g. BincodeLen, to match how the field was originally encoded.

#[derive(SchemaWrite, SchemaRead, Debug, PartialEq)]
struct Full {
    data: Vec<u32>,
    tag: u8,
}

#[derive(SchemaWrite, SchemaRead, Debug, PartialEq)]
struct Partial {
    #[wincode(with = "DiscardSeq<u32, BincodeLen>")]
    data: Vec<u32>,
    tag: u8,
}

// On read, `data` is stepped over and reset to an empty `Vec`.
let bytes = wincode::serialize(&Full { data: vec![1, 2, 3], tag: 42 }).unwrap();
assert_eq!(
    wincode::deserialize::<Partial>(&bytes).unwrap(),
    Partial { data: Vec::new(), tag: 42 },
);

// On write, `data` is discarded and an empty sequence is serialized, so the
// output matches a `Full` with empty `data`.
let out = wincode::serialize(&Partial { data: vec![1, 2, 3], tag: 42 }).unwrap();
assert_eq!(out, wincode::serialize(&Full { data: vec![], tag: 42 }).unwrap());

Trait Implementations

impl<'de, C, T, Len> SchemaRead<'de, C> for DiscardSeq<T, Len>

where C: ConfigCore, Len: SeqLen<C>, T: SchemaRead<'de, C>,

Available on crate feature alloc only.

type Dst = Vec<<T as SchemaRead<'de, C>>::Dst>

fn read( reader: impl Reader<'de>, dst: &mut MaybeUninit<Self::Dst>, ) -> ReadResult<()>

Read into dst from reader.

const TYPE_META: TypeMeta = TypeMeta::Dynamic

Metadata about the type’s serialization.

fn get(reader: impl Reader<'de>) -> ReadResult<Self::Dst>

Read Self::Dst from reader into a new Self::Dst.

impl<C, T, Len> SchemaWrite<C> for DiscardSeq<T, Len>

where C: ConfigCore, Len: SeqLen<C>, T: SchemaWrite<C>, T::Src: Sized,

Available on crate feature alloc only.

type Src = Vec<<T as SchemaWrite<C>>::Src>

fn size_of(_src: &Self::Src) -> WriteResult<usize>

Get the serialized size of Self::Src.

fn write(writer: impl Writer, _src: &Self::Src) -> WriteResult<()>

Write Self::Src to writer.

const TYPE_META: TypeMeta = TypeMeta::Dynamic

Metadata about the type’s serialization.