### Example Searches for Deserializer

Source: https://docs.rs/serde/latest/serde/trait.Deserializer.html?search=

These are example search queries that can be used to find specific deserialization patterns or types.

```rust
std::vec
```

```rust
u32 -> bool
```

```rust
Option<T>, (T -> U) -> Option<U>
```

--------------------------------

### Serialize Map Example

Source: https://docs.rs/serde/latest/src/serde/core/ser/mod.rs.html

Example of implementing `SerializeMap` for a `HashMap`. This is used for serializing key-value pairs.

```rust
use std::marker::PhantomData;

struct HashMap<K, V>(PhantomData<K>, PhantomData<V>);

impl<K, V> HashMap<K, V> {
    fn len(&self) -> usize {
        unimplemented!()
    }
}

impl<'a, K, V> IntoIterator for &'a HashMap<K, V> {
    type Item = (&'a K, &'a V);
    type IntoIter = Box<dyn Iterator<Item = (&'a K, &'a V)>>;

    fn into_iter(self) -> Self::IntoIter {
        unimplemented!()
    }
}

use serde::ser::{Serialize, SerializeMap, Serializer};

impl<K, V>
where
    K: Serialize,
    V: Serialize,
{
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut map = serializer.serialize_map(Some(self.len()))?;
        for (k, v) in self {
            map.serialize_entry(k, v)?;
        }
        map.end()
    }
}
```

--------------------------------

### Serialize Map Example

Source: https://docs.rs/serde/latest/src/serde/core/ser/mod.rs.html?search=u32+-%3E+bool

Shows how to serialize a map-like data structure. This example iterates over key-value pairs and serializes them using `serialize_entry`.

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

impl<K, V> Serialize for HashMap<K, V>
where
    K: Serialize,
    V: Serialize,
{
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut map = serializer.serialize_map(Some(self.len()))?;
        for (k, v) in self {
            map.serialize_entry(k, v)?;
        }
        map.end()
    }
}
```

--------------------------------

### Example deserialize_bool implementation

Source: https://docs.rs/serde/latest/serde/macro.forward_to_deserialize_any.html

A concrete example of how a `Deserializer` method like `deserialize_bool` can be implemented by forwarding to `deserialize_any`.

```rust
#[inline]
fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
    V: Visitor<'de>,
{
    self.deserialize_any(visitor)
}
```

--------------------------------

### Example Usage: Serializing a 3-element tuple

Source: https://docs.rs/serde/latest/serde/ser/trait.SerializeTuple.html

An example demonstrating how to implement the Serialize trait for a 3-element tuple using SerializeTuple.

```APIDOC
## §Example use
ⓘ```
use serde::ser::{Serialize, SerializeTuple, Serializer};

impl<A, B, C> Serialize for (A, B, C)
where
    A: Serialize,
    B: Serialize,
    C: Serialize,
{
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut tup = serializer.serialize_tuple(3)?;
        tup.serialize_element(&self.0)?;
        tup.serialize_element(&self.1)?;
        tup.serialize_element(&self.2)?;
        tup.end()
    }
}
```
```

--------------------------------

### Example Usage: Serializing a Vec<T>

Source: https://docs.rs/serde/latest/serde/ser/trait.SerializeSeq.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

This example demonstrates how to implement the `Serialize` trait for a `Vec<T>` by utilizing the `SerializeSeq` trait to serialize its elements.

```APIDOC
## Example Use

ⓘ```rust
use serde::ser::{Serialize, SerializeSeq, Serializer};

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 Usage of FlattenedVecVisitor

Source: https://docs.rs/serde/latest/src/serde/lib.rs.html?search=

Demonstrates how to use the FlattenedVecVisitor to deserialize a sequence into a flattened Vec<u64>.

```rust
# fn example<'de, D>(deserializer: D) -> Result<(), D::Error>
# where
#     D: Deserializer<'de>,
# {
let visitor = FlattenedVecVisitor(PhantomData);
let flattened: Vec<u64> = deserializer.deserialize_seq(visitor)?;
#     Ok(())
# }
```

--------------------------------

### Example Usage: Serializing a fixed-size array

Source: https://docs.rs/serde/latest/serde/ser/trait.SerializeTuple.html

An example demonstrating how to implement the Serialize trait for a fixed-size array of 16 elements using SerializeTuple.

```APIDOC
ⓘ```
use serde::ser::{Serialize, SerializeTuple, Serializer};

impl<T> Serialize for [T; 16]
where
    T: Serialize,
{
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut seq = serializer.serialize_tuple(16)?;
        for element in self {
            seq.serialize_element(element)?;
        }
        seq.end()
    }
}
```
```

--------------------------------

### Collect Sequence from Iterator Example

Source: https://docs.rs/serde/latest/src/serde/core/ser/mod.rs.html

Demonstrates serializing an iterator's items as a sequence. The example shows incrementing each item before serialization.

```rust
impl Serialize for SecretlyOneHigher {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.collect_seq(self.data.iter().map(|x| x + 1))
    }
}
```

--------------------------------

### Serialize Tuple Struct Example

Source: https://docs.rs/serde/latest/src/serde/core/ser/mod.rs.html?search=std%3A%3Avec

Demonstrates how to serialize a tuple struct by calling `serialize_tuple_struct` and then serializing each field.

```rust
{
        let mut ts = serializer.serialize_tuple_struct("Rgb", 3)?;
        ts.serialize_field(&self.0)?;
        ts.serialize_field(&self.1)?;
        ts.serialize_field(&self.2)?;
        ts.end()
    }
```

--------------------------------

### SerializeTuple Example: Array Implementation

Source: https://docs.rs/serde/latest/src/serde/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how to implement Serialize for an array type by iterating over its elements and serializing them as a tuple.

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

# mod fool {
#     trait Serialize {}
impl<T> Serialize for [T; 16]
#     {}
# }
# 
# impl<T> Serialize for Array<T>
where
    T: Serialize,
{
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut seq = serializer.serialize_tuple(16)?;
        for element in self {
            seq.serialize_element(element)?;
        }
        seq.end()
    }
}
```

--------------------------------

### Example `Deserialize` Implementation for `IpAddr`

Source: https://docs.rs/serde/latest/src/serde/lib.rs.html?search=

This example demonstrates a basic implementation of the `Deserialize` trait for a custom `IpAddr` type, showing how to handle deserialization errors using `serde::de::Error`.

```rust
use serde::de::{self, Deserialize, Deserializer};

impl<'de> Deserialize<'de> for IpAddr {
```

--------------------------------

### Serialize Struct Example

Source: https://docs.rs/serde/latest/src/serde/core/ser/mod.rs.html?search=u32+-%3E+bool

Illustrates how to serialize a struct by defining its fields. This is a common pattern for serializing structured data.

```rust
use serde::ser::{Serialize, SerializeStruct, Serializer};

struct Rgb {
    r: u8,
    g: u8,
    b: u8,
}

impl Serialize for Rgb {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut s = serializer.serialize_struct("Rgb", 3)?;
        s.serialize_field("r", &self.r)?;
        s.serialize_field("g", &self.g)?;
        s.serialize_field("b", &self.b)?;
        s.end()
    }
}
```

--------------------------------

### Serialize i128 Example

Source: https://docs.rs/serde/latest/serde/ser/trait.Serializer.html?search=

Implementation of `Serialize` for `i128` by delegating to the serializer's `serialize_i128` method.

```rust
impl Serialize for i128 {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.serialize_i128(*self)
    }
}
```

--------------------------------

### Example Implementation of SerializeTupleStruct

Source: https://docs.rs/serde/latest/serde/ser/trait.SerializeTupleStruct.html

Demonstrates how to implement the Serialize trait for a custom struct 'Rgb' by using SerializeTupleStruct.

```rust
use serde::ser::{Serialize, SerializeTupleStruct, Serializer};

struct Rgb(u8, u8, u8);

impl Serialize for Rgb {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut ts = serializer.serialize_tuple_struct("Rgb", 3)?;
        ts.serialize_field(&self.0)?;
        ts.serialize_field(&self.1)?;
        ts.serialize_field(&self.2)?;
        ts.end()
    }
}
```

--------------------------------

### RangeFromVisitor for SeqAccess

Source: https://docs.rs/serde/latest/src/serde/lib.rs.html?search=

Handles deserialization of `RangeFrom` when the input is a sequence. It expects exactly one element, which is the 'start' value.

```rust
impl<'de, Idx> Visitor<'de> for RangeFromVisitor<Idx> where
    Idx: Deserialize<'de> {
    type Value = Idx;
    fn expecting(&self, formatter: &mut fmt::Formatter)
        -> fmt::Result {
        formatter.write_str(self.expecting)
    }
    fn visit_seq<A>(self, mut seq: A)
        -> Result<Self::Value, A::Error> where A: SeqAccess<'de> {
        let start: Idx = 
            match match seq.next_element() {
                    Ok(val) => val,
                    Err(err) => return Err(err),
                } {
                Some(value) => value,
                None => { return Err(Error::invalid_length(0, &self)); }
            };
        Ok(start)
    }
    // ... visit_map implementation follows ...
```

--------------------------------

### Stateless vs. Stateful Deserialization API Examples

Source: https://docs.rs/serde/latest/src/serde/lib.rs.html?search=std%3A%3Avec

Illustrates the typical API signatures for stateless deserialization using Deserialize and for stateful deserialization using DeserializeSeed.

```rust
# use serde::Deserialize;
# 
# enum Error {}
# 
fn func<'de, T: Deserialize<'de>>() -> Result<T, Error>
# {
#     unimplemented!()
# }

```

```rust
# use serde::de::DeserializeSeed;
# 
# enum Error {}
# 
fn func_seed<'de, T: DeserializeSeed<'de>>(seed: T) -> Result<T::Value, Error>
# {
#     let _ = seed;
#     unimplemented!()
# }

```

--------------------------------

### Basic `forward_to_deserialize_any` Usage

Source: https://docs.rs/serde/latest/src/serde/core/macros.rs.html

This example shows a basic implementation of `Deserializer` using `forward_to_deserialize_any` to forward specific methods to `deserialize_any`.

```rust
# use serde::forward_to_deserialize_any;
# use serde::de::{value, Deserializer, Visitor};
# 
# struct MyDeserializer;
# 
# impl<'de> Deserializer<'de> for MyDeserializer {
#     type Error = value::Error;
# 
#     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
#     where
#         V: Visitor<'de>,
#     {
#         /* ... */
# #       let _ = visitor;
# #       unimplemented!()
#     }
# 
#     forward_to_deserialize_any! {
#         bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
#         bytes byte_buf option unit unit_struct newtype_struct seq tuple
#         tuple_struct map struct enum identifier ignored_any
#     }
# }

```

--------------------------------

### Basic Deserializer Implementation with forward_to_deserialize_any

Source: https://docs.rs/serde/latest/src/serde/core/macros.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

This example shows a basic implementation of `Deserializer` where `deserialize_bool` forwards to `deserialize_any`. The `forward_to_deserialize_any!` macro is used to implement other methods.

```rust
# use serde::forward_to_deserialize_any;
# use serde::de::{value, Deserializer, Visitor};
# 
# struct MyDeserializer;
# 
# impl<'de> Deserializer<'de> for MyDeserializer {
#     type Error = value::Error;
# 
#     fn deserialize_any<V>(self, _: V) -> Result<V::Value, Self::Error>
#     where
#         V: Visitor<'de>,
#     {
#         unimplemented!()
#     }
# 
#[inline]
fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
    V: Visitor<'de>,
{
    self.deserialize_any(visitor)
}
# 
#     forward_to_deserialize_any! {
#         i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
#         bytes byte_buf option unit unit_struct newtype_struct seq tuple
#         tuple_struct map struct enum identifier ignored_any
#     }
# }
```

--------------------------------

### Example Usage of SerializeStructVariant

Source: https://docs.rs/serde/latest/serde/ser/trait.SerializeStructVariant.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

This example demonstrates how to implement and use the SerializeStructVariant trait for an enum with a struct variant.

```APIDOC
## Example Use

```rust
use serde::ser::{Serialize, SerializeStructVariant, Serializer};

enum E {
    S { r: u8, g: u8, b: u8 },
}

impl Serialize for E {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        match *self {
            E::S {
                ref r,
                ref g,
                ref b,
            } => {
                let mut sv = serializer.serialize_struct_variant("E", 0, "S", 3)?;
                sv.serialize_field("r", r)?;
                sv.serialize_field("g", g)?;
                sv.serialize_field("b", b)?;
                sv.end()
            }
        }
    }
}
```
```

--------------------------------

### Basic Deserializer Implementation with `forward_to_deserialize_any!`

Source: https://docs.rs/serde/latest/src/serde/core/macros.rs.html?search=u32+-%3E+bool

This example demonstrates a basic implementation of the `Deserializer` trait for a custom struct `MyDeserializer`. It shows how to use `forward_to_deserialize_any!` to forward all supported data types to the `deserialize_any` method, simplifying the trait implementation.

```rust
use serde::forward_to_deserialize_any;
use serde::de::{value, Deserializer, Visitor};

struct MyDeserializer;

impl<'de> Deserializer<'de> for MyDeserializer {
    type Error = value::Error;

    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor<'de>,
    {
        self.deserialize_any(visitor)
    }

    forward_to_deserialize_any! {
        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
        bytes byte_buf option unit unit_struct newtype_struct seq tuple
        tuple_struct map struct enum identifier ignored_any
    }
}
```

--------------------------------

### Example Usage of SerializeStruct

Source: https://docs.rs/serde/latest/serde/ser/trait.SerializeStruct.html?search=u32+-%3E+bool

This example demonstrates how to implement the `Serialize` trait for a struct by using `SerializeStruct` to serialize its fields.

```APIDOC
## Example use
```rust
use serde::ser::{Serialize, SerializeStruct, Serializer};

struct Rgb {
    r: u8,
    g: u8,
    b: u8,
}

impl Serialize for Rgb {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut rgb = serializer.serialize_struct("Rgb", 3)?;
        rgb.serialize_field("r", &self.r)?;
        rgb.serialize_field("g", &self.g)?;
        rgb.serialize_field("b", &self.b)?;
        rgb.end()
    }
}
```
```

--------------------------------

### Example of `forward_to_deserialize_any` forwarding a single method

Source: https://docs.rs/serde/latest/src/serde/core/macros.rs.html?search=

Illustrates a minimal `Deserializer` implementation where only `deserialize_bool` is explicitly handled and forwarded to `deserialize_any`.

```rust
# use serde::forward_to_deserialize_any;
# use serde::de::{value, Deserializer, Visitor};
# 
# struct MyDeserializer;
# 
# impl<'de> Deserializer<'de> for MyDeserializer {
#     type Error = value::Error;
# 
#     fn deserialize_any<V>(self, _: V) -> Result<V::Value, Self::Error>
#     where
#         V: Visitor<'de>,
#     {
#         unimplemented!()
#     }
# 
# #[inline]
# fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
# where
#     V: Visitor<'de>,
# {
#     self.deserialize_any(visitor)
# }
# 
#     forward_to_deserialize_any! {
#         i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
#         bytes byte_buf option unit unit_struct newtype_struct seq tuple
#         tuple_struct map struct enum identifier ignored_any
#     }
# }

```

--------------------------------

### SerializeStruct Implementation Example

Source: https://docs.rs/serde/latest/src/serde/core/ser/mod.rs.html?search=

This example demonstrates how to implement the `SerializeStruct` trait for a custom struct. It serializes each field of the struct individually.

```rust
impl Serialize for Rgb {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut rgb = serializer.serialize_struct("Rgb", 3)?;
        rgb.serialize_field("r", &self.r)?;
        rgb.serialize_field("g", &self.g)?;
        rgb.serialize_field("b", &self.b)?;
        rgb.end()
    }
}

```

--------------------------------

### Example Usage of SerializeStruct

Source: https://docs.rs/serde/latest/serde/ser/trait.SerializeStruct.html

This example demonstrates how to implement the `Serialize` trait for a `Rgb` struct, utilizing `SerializeStruct` to serialize its fields.

```APIDOC
## Example Use

```rust
use serde::ser::{Serialize, SerializeStruct, Serializer};

struct Rgb {
    r: u8,
    g: u8,
    b: u8,
}

impl Serialize for Rgb {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut rgb = serializer.serialize_struct("Rgb", 3)?;
        rgb.serialize_field("r", &self.r)?;
        rgb.serialize_field("g", &self.g)?;
        rgb.serialize_field("b", &self.b)?;
        rgb.end()
    }
}
```
```

--------------------------------

### Deserializer Implementation Forwarding All Methods

Source: https://docs.rs/serde/latest/src/serde/core/macros.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

This example demonstrates using `forward_to_deserialize_any!` to forward all standard deserializer methods to `deserialize_any`. This is a common pattern for simple deserializers.

```rust
# use serde::forward_to_deserialize_any;
# use serde::de::{value, Deserializer, Visitor};
# 
# struct MyDeserializer;
# 
impl<'de> Deserializer<'de> for MyDeserializer {
#   type Error = value::Error;
# 
    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor<'de>,
    {
        /* ... */
#       let _ = visitor;
#       unimplemented!()
    }

    forward_to_deserialize_any! {
        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
        bytes byte_buf option unit unit_struct newtype_struct seq tuple
        tuple_struct map struct enum identifier ignored_any
    }
}
```

--------------------------------

### Serialize Range Struct

Source: https://docs.rs/serde/latest/src/serde/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Serializes a `Range` struct with 'start' and 'end' fields. This is used when a range has both a start and an end point.

```rust
impl<Idx> Serialize for Range<Idx> where Idx: Serialize {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where S: Serializer {
        use super::SerializeStruct;
        let mut state =
            match serializer.serialize_struct("Range", 2) {
                Ok(val) => val,
                Err(err) => return Err(err),
            };
        match state.serialize_field("start", &self.start) {
            Ok(val) => val,
            Err(err) => return Err(err),
        };
        match state.serialize_field("end", &self.end) {
            Ok(val) => val,
            Err(err) => return Err(err),
        };
        state.end()
    }
}
```

--------------------------------

### Collect Map from Iterator Example

Source: https://docs.rs/serde/latest/src/serde/core/ser/mod.rs.html

Illustrates serializing an iterator of key-value pairs as a map. This example maps keys to a unit value.

```rust
impl Serialize for MapToUnit {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.collect_map(self.keys.iter().map(|k| (k, ()))
    }
}
```

--------------------------------

### Using forward_to_deserialize_any in Deserializer implementation

Source: https://docs.rs/serde/latest/serde/macro.forward_to_deserialize_any.html

Demonstrates how to use the `forward_to_deserialize_any!` macro within an `impl Deserializer` block to forward multiple methods.

```rust
impl<'de> Deserializer<'de> for MyDeserializer {
    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: Visitor<'de>,
    {
        /* ... */
    }

    forward_to_deserialize_any! {
        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
        bytes byte_buf option unit unit_struct newtype_struct seq tuple
        tuple_struct map struct enum identifier ignored_any
    }
}
```

--------------------------------

### Example: Implementing Serialize for a Struct

Source: https://docs.rs/serde/latest/src/serde/core/ser/mod.rs.html?search=std%3A%3Avec

Demonstrates how to implement the `Serialize` trait for a custom struct `Rgb`. This involves using `serializer.serialize_struct` to create a struct serializer and then `serialize_field` for each field.

```rust
use serde::ser::{Serialize, SerializeStruct, Serializer};

struct Rgb {
    r: u8,
    g: u8,
    b: u8,
}

impl Serialize for Rgb {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut rgb = serializer.serialize_struct("Rgb", 3)?;
        rgb.serialize_field("r", &self.r)?;
        rgb.serialize_field("g", &self.g)?;
        rgb.serialize_field("b", &self.b)?;
        rgb.end()
    }
}

```

--------------------------------

### Stateful Deserialization API Example with DeserializeSeed

Source: https://docs.rs/serde/latest/src/serde/lib.rs.html

Shows how to adapt an API for stateful deserialization by accepting a DeserializeSeed. This allows passing data or state into the deserialization process, enabling optimizations like reusing buffers.

```rust
/// Adjusting an API like this to support stateful deserialization is a matter
/// of accepting a seed as input:
///
/// ```edition2021
/// # use serde::de::DeserializeSeed;
/// # 
/// # enum Error {}
/// # 
/// fn func_seed<'de, T: DeserializeSeed<'de>>(seed: T) -> Result<T::Value, Error>
/// # {
/// #     let _ = seed;
/// #     unimplemented!()
/// # }
/// ```
```

--------------------------------

### Serialize Newtype Variant Example

Source: https://docs.rs/serde/latest/src/serde/core/ser/mod.rs.html?search=u32+-%3E+bool

Example of how to serialize a newtype variant within an enum. This is useful when a variant holds a single value.

```rust
///             E::M(ref s) => serializer.serialize_newtype_variant("E", 0, "M", s),
///             E::N(n) => serializer.serialize_newtype_variant("E", 1, "N", &n),
///         }
///     }
/// }
/// ```
```

--------------------------------

### Basic `forward_to_deserialize_any` Usage

Source: https://docs.rs/serde/latest/src/serde/core/macros.rs.html?search=

Demonstrates how to use `forward_to_deserialize_any` to forward specific deserialization methods to `deserialize_any` within a custom `Deserializer` implementation.

```rust
# use serde::forward_to_deserialize_any;
# use serde::de::{value, Deserializer, Visitor};
# 
# struct MyDeserializer;
# 
# impl<'de> Deserializer<'de> for MyDeserializer {
#   type Error = value::Error;
# 
#     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
#     where
#         V: Visitor<'de>,
#     {
#         /* ... */
# #       let _ = visitor;
# #       unimplemented!()
#     }
# 
#     forward_to_deserialize_any! {
#         bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
#         bytes byte_buf option unit unit_struct newtype_struct seq tuple
#         tuple_struct map struct enum identifier ignored_any
#     }
# }

```

--------------------------------

### Example Usage of SerializeTupleStruct

Source: https://docs.rs/serde/latest/serde/ser/trait.SerializeTupleStruct.html?search=

This example demonstrates how to implement the Serialize trait for a custom struct (Rgb) using SerializeTupleStruct to serialize its fields.

```APIDOC
## Example use

```rust
use serde::ser::{Serialize, SerializeTupleStruct, Serializer};

struct Rgb(u8, u8, u8);

impl Serialize for Rgb {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut ts = serializer.serialize_tuple_struct("Rgb", 3)?;
        ts.serialize_field(&self.0)?;
        ts.serialize_field(&self.1)?;
        ts.serialize_field(&self.2)?;
        ts.end()
    }
}
```
```

--------------------------------

### Basic Serialize Implementation for a Struct

Source: https://docs.rs/serde/latest/src/serde/core/ser/mod.rs.html

Provides a template for implementing the `Serialize` trait for a custom struct (`Person`). This example shows how to define the `serialize` method, which is the entry point for serializing the struct's data.

```rust
use serde::ser::{Serialize, SerializeStruct, Serializer};

struct Person {
    name: String,
    age: u8,
    phones: Vec<String>,
}

impl Serialize for Person {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        // Implementation would go here, likely using SerializeStruct
        unimplemented!()
    }
}
```

--------------------------------

### Serialize RangeFrom Struct

Source: https://docs.rs/serde/latest/src/serde/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Serializes a `RangeFrom` struct with a 'start' field. This is used for ranges that start from a specific point and go to infinity.

```rust
impl<Idx> Serialize for RangeFrom<Idx> where Idx: Serialize {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
        where S: Serializer {
        use super::SerializeStruct;
        let mut state =
            match serializer.serialize_struct("RangeFrom", 1) {
                Ok(val) => val,
                Err(err) => return Err(err),
            };
        match state.serialize_field("start", &self.start) {
            Ok(val) => val,
            Err(err) => return Err(err),
        };
        state.end()
    }
}
```

--------------------------------

### Serde Error Trait Example Implementation

Source: https://docs.rs/serde/latest/src/serde/lib.rs.html?search=std%3A%3Avec

Example of implementing the Serde Error trait. Most deserializers only need to provide the `Error::custom` method.

```rust
/// The `Error` trait allows `Deserialize` implementations to create descriptive
/// error messages belonging to the `Deserializer` against which they are
/// currently running.
///
/// Every `Deserializer` declares an `Error` type that encompasses both
/// general-purpose deserialization errors as well as errors specific to the
/// particular deserialization format. For example the `Error` type of
/// `serde_json` can represent errors like an invalid JSON escape sequence or an
/// unterminated string literal, in addition to the error cases that are part of
/// this trait.
///
/// Most deserializers should only need to provide the `Error::custom` method
/// and inherit the default behavior for the other methods.
///
/// # Example implementation
///
/// The [example data format] presented on the website shows an error
/// type appropriate for a basic JSON data format.
///
/// [example data format]: https://serde.rs/data-format.html
#[diagnostic::on_unimplemented(message =
    "the trait bound `{Self}: serde::de::Error` is not satisfied",)]
pub trait Error: Sized + StdError {
    /// Raised when there is general error when deserializing a type.
    ///
    /// The message should not be capitalized and should not end with a period.
    ///
    /// ```edition2021
    /// # use std::str::FromStr;
    /// #
    /// # struct IpAddr;
    /// #
    /// # impl FromStr for IpAddr {
    /// #     type Err = String;
    /// #
    /// #     fn from_str(_: &str) -> Result<Self, String> {
    /// #         unimplemented!()
    /// #     }
    /// # }
    /// #
    /// use serde::de::{self, Deserialize, Deserializer};
    ///
    /// impl<'de> Deserialize<'de> for IpAddr {

```

--------------------------------

### Implement `visit_i32` for Visitor

Source: https://docs.rs/serde/latest/src/serde/lib.rs.html?search=std%3A%3Avec

Handles `i32` input. The default implementation forwards the value to `visit_i64`.

```rust
# use serde::de::Error;
fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E> where
    E: Error {
    self.visit_i64(v as i64)
}

```

--------------------------------

### Customizing Visitor and Lifetime Parameters

Source: https://docs.rs/serde/latest/serde/macro.forward_to_deserialize_any.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

This example demonstrates how to use `forward_to_deserialize_any!` with custom type and lifetime parameters for the `Visitor`. This is useful when the default `'de` lifetime and `V` visitor type parameters do not match your implementation.

```rust
forward_to_deserialize_any! {
    <W: Visitor<'q>>
    bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
    bytes byte_buf option unit unit_struct newtype_struct seq tuple
    tuple_struct map struct enum identifier ignored_any
}
```

--------------------------------

### Example Usage of NthElement

Source: https://docs.rs/serde/latest/src/serde/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

This example demonstrates how to deserialize only the element at index 3 from a sequence, expecting it to be a string. Elements before and after index 3 can be of any type and are ignored.

```rust
# fn example<'de, D>(deserializer: D) -> Result<(), D::Error>
# where
#     D: Deserializer<'de>,
# {
// Deserialize only the sequence element at index 3 from this deserializer.
// The element at index 3 is required to be a string. Elements before and
// after index 3 are allowed to be of any type.
let s: String = NthElement::new(3).deserialize(deserializer)?;
#     Ok(())
# }
```

--------------------------------

### Serialize for `RangeFrom<Idx>`

Source: https://docs.rs/serde/latest/src/serde/core/ser/impls.rs.html?search=

Serializes a `RangeFrom<Idx>` struct, representing a range from `start` (inclusive) to infinity. It is serialized as a struct with a single field: `start`.

```APIDOC
## Serialize for `RangeFrom<Idx>`

### Description
Implements the `Serialize` trait for `RangeFrom<Idx>`, representing a range from `start` (inclusive) onwards. It serializes as a struct with a single `start` field.

### Method
`serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>`

### Endpoint
N/A (SDK method)

### Parameters
- `serializer`: The serializer implementation.

### Response
- `Result<S::Ok, S::Error>`: The result of the serialization process.

### Request Example
```json
{
  "start": "value"
}
```

### Response Example
```json
{
  "start": "value"
}
```
```

--------------------------------

### Implement Visitor for i32

Source: https://docs.rs/serde/latest/src/serde/lib.rs.html

Implements the `visit_i32` method for a visitor. It attempts to convert the i32 to a u64 if non-negative, otherwise returns an error.

```rust
fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
        where E: Error {
            if 0 <= v {

                #[allow(irrefutable_let_patterns)]
                if let Ok(v) = Self::Value::try_from(v as u64) {
                    return Ok(v as Self::Value);
                }
            }
            Err(Error::invalid_value(Unexpected::Signed(v as i64),
                    &self))
        }
```

--------------------------------

### Implement `visit_u32` for Visitor

Source: https://docs.rs/serde/latest/src/serde/lib.rs.html?search=std%3A%3Avec

Handles `u32` input. The default implementation forwards the value to `visit_u64`.

```rust
# use serde::de::Error;
fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E> where
    E: Error {
    self.visit_u64(v as u64)
}

```

--------------------------------

### MapAccess: Get Next Key

Source: https://docs.rs/serde/latest/src/serde/lib.rs.html

A convenience method to get the next key from a map, automatically handling the DeserializeSeed. Useful when the type of the key is known.

```rust
fn next_key<K>(&mut self) -> Result<Option<K>, Self::Error> where
            K: Deserialize<'de> {
            self.next_key_seed(PhantomData)
        }
```

--------------------------------

### SeqAccess: Get Next Element

Source: https://docs.rs/serde/latest/src/serde/lib.rs.html

A convenience method to get the next element from a sequence, automatically handling the DeserializeSeed. Useful when the type of the element is known.

```rust
fn next_element<T>(&mut self) -> Result<Option<T>, Self::Error> where
            T: Deserialize<'de> {
            self.next_element_seed(PhantomData)
        }
```

--------------------------------

### Serialize for `RangeInclusive<Idx>`

Source: https://docs.rs/serde/latest/src/serde/core/ser/impls.rs.html?search=

Serializes a `RangeInclusive<Idx>` struct, representing a range from `start` (inclusive) to `end` (inclusive). It is serialized as a struct with two fields: `start` and `end`.

```APIDOC
## Serialize for `RangeInclusive<Idx>`

### Description
Implements the `Serialize` trait for `RangeInclusive<Idx>`, representing a range from `start` (inclusive) to `end` (inclusive). It serializes as a struct with `start` and `end` fields.

### Method
`serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>`

### Endpoint
N/A (SDK method)

### Parameters
- `serializer`: The serializer implementation.

### Response
- `Result<S::Ok, S::Error>`: The result of the serialization process.

### Request Example
```json
{
  "start": "value",
  "end": "value"
}
```

### Response Example
```json
{
  "start": "value",
  "end": "value"
}
```
```

--------------------------------

### Serialize for `Range<Idx>`

Source: https://docs.rs/serde/latest/src/serde/core/ser/impls.rs.html?search=

Serializes a `Range<Idx>` struct, which represents a range from `start` (inclusive) to `end` (exclusive). It is serialized as a struct with two fields: `start` and `end`.

```APIDOC
## Serialize for `Range<Idx>`

### Description
Implements the `Serialize` trait for `Range<Idx>`, representing a range from `start` (inclusive) to `end` (exclusive). It serializes as a struct with `start` and `end` fields.

### Method
`serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>`

### Endpoint
N/A (SDK method)

### Parameters
- `serializer`: The serializer implementation.

### Response
- `Result<S::Ok, S::Error>`: The result of the serialization process.

### Request Example
```json
{
  "start": "value",
  "end": "value"
}
```

### Response Example
```json
{
  "start": "value",
  "end": "value"
}
```
```

--------------------------------

### Implement Visitor for i8

Source: https://docs.rs/serde/latest/src/serde/lib.rs.html

Implements the `visit_i8` method for a visitor. It attempts to convert the i8 to a u64 if non-negative, otherwise returns an error.

```rust
fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E> where
        E: Error {
            if 0 <= v {

                #[allow(irrefutable_let_patterns)]
                if let Ok(v) = Self::Value::try_from(v as u64) {
                    return Ok(v as Self::Value);
                }
            }
            Err(Error::invalid_value(Unexpected::Signed(v as i64),
                    &self))
        }
```

--------------------------------

### Example Implementation of Error Trait for Path

Source: https://docs.rs/serde/latest/serde/ser/trait.Error.html

This example demonstrates how a `Path` type can implement the `Serialize` trait and use `ser::Error::custom` to return an error when encountering invalid UTF-8 data.

```APIDOC
## Example implementation

```rust
use serde::ser::{self, Serialize, Serializer};

implement Serialize for Path {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        match self.to_str() {
            Some(s) => serializer.serialize_str(s),
            None => Err(ser::Error::custom("path contains invalid UTF-8 characters")),
        }
    }
}
```
```

--------------------------------

### Implement `visit_f32` for Visitor

Source: https://docs.rs/serde/latest/src/serde/lib.rs.html?search=std%3A%3Avec

Handles `f32` input. The default implementation forwards the value to `visit_f64`.

```rust
# use serde::de::Error;
fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E> where
    E: Error {
    self.visit_f64(v as f64)
}

```

--------------------------------

### Example of Stateful Deserialization with DeserializeSeed

Source: https://docs.rs/serde/latest/src/serde/lib.rs.html?search=

This example demonstrates using DeserializeSeed to deserialize nested JSON arrays into a single flat vector, reusing allocated memory for efficiency. It requires custom implementations for Visitor and SeqAccess.

```Rust
use serde::de::{Deserialize, DeserializeSeed, Deserializer, SeqAccess, Visitor};
use std::fmt;
use std::marker::PhantomData;

```