# [−][src]Trait serde::ser::SerializeSeq

    pub trait SerializeSeq {
        type Ok;
        type Error: Error;
        fn serialize_element<T: ?Sized>(
            &mut self,
            value: &T
        ) -> Result<(), Self::Error>
        where
            T: Serialize;
        fn end(self) -> Result<Self::Ok, Self::Error>;
    }

Returned from `Serializer::serialize_seq`.

# Example use

    # use std::marker::PhantomData;
    #
    # struct Vec<T>(PhantomData<T>);
    #
    # impl<T> Vec<T> {
    #     fn len(&self) -> usize {
    #         unimplemented!()
    #     }
    # }
    #
    # impl<'a, T> IntoIterator for &'a Vec<T> {
    #     type Item = &'a T;
    #     type IntoIter = Box<Iterator<Item = &'a T>>;
    #     fn into_iter(self) -> Self::IntoIter {
    #         unimplemented!()
    #     }
    # }
    #
    use serde::ser::{Serialize, Serializer, SerializeSeq};

    impl<T> Serialize for Vec<T>
    where
        T: Serialize,
    {
        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where
            S: Serializer,
        {
            let mut seq = serializer.serialize_seq(Some(self.len()))?;
            for element in self {
                seq.serialize_element(element)?;
            }
            seq.end()
        }
    }

# Example implementation

The example data format presented on the website demonstrates an implementation of `SerializeSeq` for a basic JSON data format.

## Associated Types

### `type Ok`

Must match the `Ok` type of our `Serializer`.

### `type Error: Error`

Must match the `Error` type of our `Serializer`.

Loading content...

## Required methods

### `fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error> where
T: Serialize,`

Serialize a sequence element.

### `fn end(self) -> Result<Self::Ok, Self::Error>`

Finish serializing a sequence.

Loading content...

## Implementors

### `impl<Ok, Error> SerializeSeq for Impossible<Ok, Error> where
Error: Error,` [src]

#### `type Ok = Ok`

#### `type Error = Error`

#### `fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error> where
T: Serialize,` [src]

#### `fn end(self) -> Result<Ok, Error>`[src]

Loading content...

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)