Serde

https://serde.rs
Admin
Serde is a framework for serializing and deserializing Rust data structures efficiently and...
Tokens:53,844
Snippets:300
Trust Score:9.4
Update:1 week ago
Show doc for...
Tokens:
Raw
### Example JSON response with pagination metadata

Source: https://serde.rs/attr-flatten.html

Shows a JSON object with pagination fields `limit`, `offset`, `total`, and a `users` array. This is the input data for the pagination example.

```json
{
  "limit": 100,
  "offset": 200,
  "total": 1053,
  "users": [
    {"id": "49824073-979f-4814-be10-5ea416ee1c2f", "username": "john_doe"},
    ...
  ]
}
```

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

### Rust example: deserialize string or struct

Source: https://serde.rs/string-or-struct.html

Complete Rust example using FromStr and deserialize_with to handle a field that can be a string or a struct. Includes main function, struct definitions, and the custom visitor.

```rust
use std::collections::BTreeMap as Map;
use std::fmt;
use std::marker::PhantomData;
use std::str::FromStr;

use serde::{Deserialize, Deserializer};
use serde::de::{self, Visitor, MapAccess};
use void::Void;

fn main() {
    let build_string = "
        build: ./dir
    ";
    let service: Service = serde_yaml::from_str(build_string).unwrap();

    // context="./dir"
    // dockerfile=None
    // args={}
    println!("{:?}", service);

    let build_struct = "
        build:
          context: ./dir
          dockerfile: Dockerfile-alternate
          args:
            buildno: '1'
    ";
    let service: Service = serde_yaml::from_str(build_struct).unwrap();

    // context="./dir"
    // dockerfile=Some("Dockerfile-alternate")
    // args={"buildno": "1"}
    println!("{:?}", service);
}

#[derive(Debug, Deserialize)]
struct Service {
    // The `string_or_struct` function delegates deserialization to a type's
    // `FromStr` impl if given a string, and to the type's `Deserialize` impl if
    // given a struct. The function is generic over the field type T (here T is
    // `Build`) so it can be reused for any field that implements both `FromStr`
    // and `Deserialize`.
    #[serde(deserialize_with = "string_or_struct")]
    build: Build,
}

#[derive(Debug, Deserialize)]
struct Build {
    // This is the only required field.
    context: String,

    dockerfile: Option<String>,

    // When `args` is not present in the input, this attribute tells Serde to
    // use `Default::default()` which in this case is an empty map. See the
    // "default value for a field" example for more about `#[serde(default)]`.
    #[serde(default)]
    args: Map<String, String>,
}

// The `string_or_struct` function uses this impl to instantiate a `Build` if
// the input file contains a string and not a struct. According to the
// docker-compose.yml documentation, a string by itself represents a `Build`
// with just the `context` field set.
//
// > `build` can be specified either as a string containing a path to the build
// > context, or an object with the path specified under context and optionally
// > dockerfile and args.
impl FromStr for Build {
    // This implementation of `from_str` can never fail, so use the impossible
    // `Void` type as the error type.
    type Err = Void;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        Ok(Build {
            context: s.to_string(),
            dockerfile: None,
            args: Map::new(),
        })
    }
}

fn string_or_struct<'de, T, D>(deserializer: D) -> Result<T, D::Error>
where
    T: Deserialize<'de> + FromStr<Err = Void>,
    D: Deserializer<'de>,
{
    // This is a Visitor that forwards string types to T's `FromStr` impl and
    // forwards map types to T's `Deserialize` impl. The `PhantomData` is to
    // keep the compiler from complaining about T being an unused generic type
    // parameter. We need T in order to know the Value type for the Visitor
    // impl.
    struct StringOrStruct<T>(PhantomData<fn() -> T>);

    impl<'de, T> Visitor<'de> for StringOrStruct<T>
    where
        T: Deserialize<'de> + FromStr<Err = Void>,
    {
        type Value = T;

        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
            formatter.write_str("string or map")
        }

        fn visit_str<E>(self, value: &str) -> Result<T, E>
        where
            E: de::Error,
        {
            Ok(FromStr::from_str(value).unwrap())
        }

        fn visit_map<M>(self, map: M) -> Result<T, M::Error>
        where
            M: MapAccess<'de>,
        {
            // `MapAccessDeserializer` is a wrapper that turns a `MapAccess`
            // into a `Deserializer`, allowing it to be used as the input to T's
            // `Deserialize` implementation. T then deserializes itself using
            // the entries from the map visitor.
            Deserialize::deserialize(de::value::MapAccessDeserializer::new(map))
        }
    }

    deserializer.deserialize_any(StringOrStruct(PhantomData))
}

```

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

### Serialize sequence start

Source: https://serde.rs/impl-serializer.html

Serializes the start of a sequence as '['. The length may or may not be known ahead of time; JSON does not represent it explicitly.

```rust
    // Now we get to the serialization of compound types.
    //
    // The start of the sequence, each value, and the end are three separate
    // method calls. This one is responsible only for serializing the start,
    // which in JSON is `[`.
    //
    // The length of the sequence may or may not be known ahead of time. This
    // doesn't make a difference in JSON because the length is not represented
    // explicitly in the serialized form. Some serializers may only be able to
    // support sequences for which the length is known up front.
    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
        self.output += "[";
        Ok(self)
    }
```

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

### Output of cargo run

Source: https://serde.rs/derive.html

Shows the expected output when running the example: serialized JSON and deserialized struct.

```text
$ cargo run
serialized = {"x":1,"y":2}
deserialized = Point { x: 1, y: 2 }

```

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

### Serialize impls for Vec and MyMap

Source: https://serde.rs/impl-serialize.html

Compound types follow a three-step process: init, elements, end. The Vec example uses serialize_seq and serialize_element; the MyMap example uses serialize_map and serialize_entry. Both require the element types to implement Serialize.

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

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 e in self {
            seq.serialize_element(e)?;
        }
        seq.end()
    }
}

impl<K, V> Serialize for MyMap<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()
    }
}
```

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

### YAML example: build as string or struct

Source: https://serde.rs/string-or-struct.html

Shows the two possible forms of the 'build' key in docker-compose.yml: a simple string path or a struct with context, dockerfile, and args.

```yaml
build: ./dir

# --- or ---

build:
  context: ./dir
  dockerfile: Dockerfile-alternate
  args:
    buildno: 1

```

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

### Serde default attribute example with function, Default trait, and method

Source: https://serde.rs/attr-default.html

Complete Rust example showing three ways to specify default values for struct fields with #[serde(default)]. The first field uses a function, the second uses the type's Default implementation, and the third uses a method on the type. The main function deserializes a JSON array and prints the resulting structs, demonstrating the defaults applied.

```rust
use serde::Deserialize;

#[derive(Deserialize, Debug)]
struct Request {
    // Use the result of a function as the default if "resource" is
    // not included in the input.
    #[serde(default = "default_resource")]
    resource: String,

    // Use the type's implementation of std::default::Default if
    // "timeout" is not included in the input.
    #[serde(default)]
    timeout: Timeout,

    // Use a method from the type as the default if "priority" is not
    // included in the input. This may also be a trait method.
    #[serde(default = "Priority::lowest")]
    priority: Priority,
}

fn default_resource() -> String {
    "/".to_string()
}

/// Timeout in seconds.
#[derive(Deserialize, Debug)]
struct Timeout(u32);
impl Default for Timeout {
    fn default() -> Self {
        Timeout(30)
    }
}

#[derive(Deserialize, Debug)]
enum Priority { ExtraHigh, High, Normal, Low, ExtraLow }
impl Priority {
    fn lowest() -> Self { Priority::ExtraLow }
}

fn main() {
    let json = r#"
        [
          {
            "resource": "/users"
          },
          {
            "timeout": 5,
            "priority": "High"
          }
        ]
    "#;

    let requests: Vec<Request> = serde_json::from_str(json).unwrap();

    // The first request has resource="/users", timeout=30, priority=ExtraLow
    println!("{:?}", requests[0]);

    // The second request has resource="/", timeout=5, priority=High
    println!("{:?}", requests[1]);
}
```

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

### Deserialize implementation for i32

Source: https://serde.rs/impl-deserialize.html

Shows how to drive the `I32Visitor` by calling `deserialize_i32` on the deserializer. Note that the deserializer may not follow the hint; for example, JSON calls `visit_i64` for signed integers.

```rust
impl<'de> Deserialize<'de> for i32 {
    fn deserialize<D>(deserializer: D) -> Result<i32, D::Error>
    where
        D: Deserializer<'de>,
    {
        deserializer.deserialize_i32(I32Visitor)
    }
}

```

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

### Adjacently tagged representation JSON examples

Source: https://serde.rs/enum-representations.html

Shows two JSON examples for the adjacently tagged representation, where the tag and content are adjacent fields in the same object.

```json
{"t": "Para", "c": [{...}, {...}]}
{"t": "Str", "c": "the string"}

```

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

### Example from linked-hash-map crate using serde_test assert_tokens

Source: https://serde.rs/unit-testing.html

Shows how to test Serialize and Deserialize implementations using serde_test's assert_tokens function with Token sequences. Includes two test functions: test_ser_de_empty for an empty map and test_ser_de for a map with three entries. Requires the linked_hash_map and serde_test crates.

```rust
use linked_hash_map::LinkedHashMap;
use serde_test::{Token, assert_tokens};

#[test]
fn test_ser_de_empty() {
    let map = LinkedHashMap::<char, u32>::new();

    assert_tokens(&map, &[
        Token::Map { len: Some(0) },
        Token::MapEnd,
    ]);
}

#[test]
fn test_ser_de() {
    let mut map = LinkedHashMap::new();
    map.insert('b', 20);
    map.insert('a', 10);
    map.insert('c', 30);

    assert_tokens(&map, &[
        Token::Map { len: Some(3) },
        Token::Char('b'),
        Token::I32(20),

        Token::Char('a'),
        Token::I32(10),

        Token::Char('c'),
        Token::I32(30),
        Token::MapEnd,
    ]);
}
```

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

### Untagged representation JSON example

Source: https://serde.rs/enum-representations.html

Shows the JSON syntax for the untagged representation, where there is no explicit tag and the content is directly the variant fields.

```json
{"id": "...", "method": "...", "params": {...}}

```

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

### Internally tagged representation JSON example

Source: https://serde.rs/enum-representations.html

Shows the JSON syntax for the internally tagged representation, where the tag field is inside the content alongside the variant fields.

```json
{"type": "Request", "id": "...", "method": "...", "params": {...}}

```

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

### Serialize and deserialize a struct with serde derive

Source: https://serde.rs/

Use the derive macro to implement Serialize and Deserialize for a struct. The example converts a Point to a JSON string with serde_json::to_string and back with serde_json::from_str, printing the results.

```rust
use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, Debug)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let point = Point { x: 1, y: 2 };

    // Convert the Point to a JSON string.
    let serialized = serde_json::to_string(&point).unwrap();

    // Prints serialized = {"x":1,"y":2}
    println!("serialized = {}", serialized);

    // Convert the JSON string back to a Point.
    let deserialized: Point = serde_json::from_str(&serialized).unwrap();

    // Prints deserialized = Point { x: 1, y: 2 }
    println!("deserialized = {:?}", deserialized);
}

```

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

### Custom Date Format with chrono and serde

Source: https://serde.rs/custom-date-format.html

This example uses the `chrono` crate to serialize and deserialize JSON data with a custom date format. The `with` attribute is used to provide the logic for handling the custom representation. The code defines a struct with a custom date format, implements custom serialization and deserialization functions, and demonstrates usage in main.

```rust
use chrono::{DateTime, Utc};
use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, Debug)]
pub struct StructWithCustomDate {
    // DateTime supports Serde out of the box, but uses RFC3339 format. Provide
    // some custom logic to make it use our desired format.
    #[serde(with = "my_date_format")]
    pub timestamp: DateTime<Utc>,

    // Any other fields in the struct.
    pub bidder: String,
}

mod my_date_format {
    use chrono::{DateTime, Utc, NaiveDateTime};
    use serde::{self, Deserialize, Serializer, Deserializer};

    const FORMAT: &'static str = "%Y-%m-%d %H:%M:%S";

    // The signature of a serialize_with function must follow the pattern:
    //
    //    fn serialize<S>(&T, S) -> Result<S::Ok, S::Error>
    //    where
    //        S: Serializer
    //
    // although it may also be generic over the input types T.
    pub fn serialize<S>(
        date: &DateTime<Utc>,
        serializer: S,
    ) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let s = format!("{}", date.format(FORMAT));
        serializer.serialize_str(&s)
    }

    // The signature of a deserialize_with function must follow the pattern:
    //
    //    fn deserialize<'de, D>(D) -> Result<T, D::Error>
    //    where
    //        D: Deserializer<'de>
    //
    // although it may also be generic over the output types T.
    pub fn deserialize<'de, D>(
        deserializer: D,
    ) -> Result<DateTime<Utc>, D::Error>
    where
        D: Deserializer<'de>,
    {
        let s = String::deserialize(deserializer)?;
        let dt = NaiveDateTime::parse_from_str(&s, FORMAT).map_err(serde::de::Error::custom)?;
        Ok(DateTime::<Utc>::from_naive_utc_and_offset(dt, Utc))
    }
}

fn main() {
    let json_str = r#"
      {
        "timestamp": "2017-02-16 21:54:30",
        "bidder": "Skrillex"
      }
    "#;

    let data: StructWithCustomDate = serde_json::from_str(json_str).unwrap();
    println!("{:#?}", data);

    let serialized = serde_json::to_string_pretty(&data).unwrap();
    println!("{}", serialized);
}

```

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

### Serialize and deserialize nested JSON string with serde

Source: https://serde.rs/convert-error.html

This example defines a Resource struct with a policy field serialized as a JSON string using a custom module as_json_string. It shows how to convert between serde_json and the outer format's error types using serde::ser::Error and serde::de::Error. The main function creates a Resource and serializes it to YAML, demonstrating the nested JSON string representation.

```rust
use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct Resource {
    name: String,

    #[serde(with = "as_json_string")]
    policy: Policy,
}

#[derive(Serialize, Deserialize)]
struct Policy {
    effect: String,
    action: String,
    resource: String,
}

// Serialize and deserialize logic for dealing with nested values represented as
// JSON strings.
mod as_json_string {
    use serde_json;
    use serde::ser::{Serialize, Serializer};
    use serde::de::{Deserialize, DeserializeOwned, Deserializer};

    // Serialize to a JSON string, then serialize the string to the output
    // format.
    pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
    where
        T: Serialize,
        S: Serializer,
    {
        use serde::ser::Error;
        let j = serde_json::to_string(value).map_err(Error::custom)?;
        j.serialize(serializer)
    }

    // Deserialize a string from the input format, then deserialize the content
    // of that string as JSON.
    pub fn deserialize<'de, T, D>(deserializer: D) -> Result<T, D::Error>
    where
        T: DeserializeOwned,
        D: Deserializer<'de>,
    {
        use serde::de::Error;
        let j = String::deserialize(deserializer)?;
        serde_json::from_str(&j).map_err(Error::custom)
    }
}

fn main() {
    let resource = Resource {
        name: "test_policy".to_owned(),
        policy: Policy {
            effect: "Allow".to_owned(),
            action: "s3:ListBucket".to_owned(),
            resource: "arn:aws:s3:::example_bucket".to_owned(),
        },
    };

    let y = serde_yaml::to_string(&resource).unwrap();
    println!("{}", y);
}

```

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

### Enum Variant Serialization Example

Source: https://serde.rs/impl-serialize.html

Shows the four enum variant kinds and the corresponding Serializer methods to use for each. Struct and tuple variants require a three-step process: serialize_struct_variant, serialize_field, and end. Newtype variants use serialize_newtype_variant, and unit variants use serialize_unit_variant.

```rust
enum E {
    // Use three-step process:
    //   1. serialize_struct_variant
    //   2. serialize_field
    //   3. end
    Color { r: u8, g: u8, b: u8 },

    // Use three-step process:
    //   1. serialize_tuple_variant
    //   2. serialize_field
    //   3. end
    Point2D(f64, f64),

    // Use serialize_newtype_variant.
    Inches(u64),

    // Use serialize_unit_variant.
    Instance,
}
```

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

### Using skip_serializing and skip_serializing_if in Rust with serde

Source: https://serde.rs/attr-skip-serializing.html

This example demonstrates the `skip_serializing` attribute to always skip a field, and `skip_serializing_if` to conditionally skip a field based on a method. The `hash` field is never serialized, while `metadata` is skipped when empty. The output shows the resulting JSON without the skipped fields.

```rust
use serde::Serialize;

use std::collections::BTreeMap as Map;

#[derive(Serialize)]
struct Resource {
    // Always serialized.
    name: String,

    // Never serialized.
    #[serde(skip_serializing)]
    hash: String,

    // Use a method to decide whether the field should be skipped.
    #[serde(skip_serializing_if = "Map::is_empty")]
    metadata: Map<String, String>,
}

fn main() {
    let resources = vec![
        Resource {
            name: "Stack Overflow".to_string(),
            hash: "b6469c3f31653d281bbbfa6f94d60fea130abe38".to_string(),
            metadata: Map::new(),
        },
        Resource {
            name: "GitHub".to_string(),
            hash: "5cb7a0c47e53854cd00e1a968de5abce1c124601".to_string(),
            metadata: {
                let mut metadata = Map::new();
                metadata.insert("headquarters".to_string(),
                                "San Francisco".to_string());
                metadata
            },
        },
    ];

    let json = serde_json::to_string_pretty(&resources).unwrap();

    // Prints:
    //
    //    [
    //      {
    //        "name": "Stack Overflow"
    //      },
    //      {
    //        "name": "GitHub",
    //        "metadata": {
    //          "headquarters": "San Francisco"
    //        }
    //      }
    //    ]
    println!("{}", json);
}

```

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

### Serialize C-like enum as integer with serde_repr

Source: https://serde.rs/enum-number.html

Define a C-like enum with explicit integer values and use serde_repr's derive macros to serialize and deserialize it as a number instead of a string. The example prints [2,3,5,7] and deserializes the string "2" back to the Two variant.

```rust
use serde_repr::*;

#[derive(Serialize_repr, Deserialize_repr, PartialEq, Debug)]
#[repr(u8)]
enum SmallPrime {
    Two = 2,
    Three = 3,
    Five = 5,
    Seven = 7,
}

fn main() {
    use SmallPrime::*;
    let nums = vec![Two, Three, Five, Seven];

    // Prints [2,3,5,7]
    println!("{}", serde_json::to_string(&nums).unwrap());

    assert_eq!(Two, serde_json::from_str("2").unwrap());
}

```

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

### Base enum type used in examples

Source: https://serde.rs/enum-representations.html

Defines the Message enum with struct variants Request and Response, used as the base for the externally tagged, internally tagged, and untagged examples.

```rust
#[derive(Serialize, Deserialize)]
enum Message {
    Request { id: String, method: String, params: Params },
    Response { id: String, result: Value },
}

```

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

### src/main.rs using derive macros

Source: https://serde.rs/derive.html

Defines a Point struct with Serialize and Deserialize derives, serializes to JSON, and deserializes back. Requires Rust 1.31 or newer.

```rust
use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, Debug)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let point = Point { x: 1, y: 2 };

    let serialized = serde_json::to_string(&point).unwrap();
    println!("serialized = {}", serialized);

    let deserialized: Point = serde_json::from_str(&serialized).unwrap();
    println!("deserialized = {:?}", deserialized);
}

```

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

### Cargo.toml with serde derive feature

Source: https://serde.rs/derive.html

Adds serde with the derive feature and serde_json as a dependency for the example. Required for using #[derive(Serialize, Deserialize)].

```toml
[package]
name = "my-crate"
version = "0.1.0"
authors = ["Me <user@rust-lang.org>"]

[dependencies]
serde = { version = "1.0", features = ["derive"] }

# serde_json is just for the example, not required in general
serde_json = "1.0"

```

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

### Orphan rule violation example

Source: https://serde.rs/remote-derive.html

Shows the invalid attempt to implement Serialize for a type from another crate, which is not allowed by Rust's orphan rule.

```rust
- use serde::Serialize;
- use other_crate::Duration;
-
- // Not allowed by orphan rule.
- impl Serialize for Duration {
-     /* ... */
- }

```

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

### Implement next_key_seed and next_value_seed for MapAccess

Source: https://serde.rs/impl-deserializer.html

These methods are part of a MapAccess implementation. next_key_seed checks for the closing brace, handles commas between entries, and deserializes the key. next_value_seed expects a colon after the key and deserializes the value.

```rust
    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
    where
        K: DeserializeSeed<'de>,
    {
        // Check if there are no more entries.
        if self.de.peek_char()? == '}' {
            return Ok(None);
        }
        // Comma is required before every entry except the first.
        if !self.first && self.de.next_char()? != ',' {
            return Err(Error::ExpectedMapComma);
        }
        self.first = false;
        // Deserialize a map key.
        seed.deserialize(&mut *self.de).map(Some)
    }

    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
    where
        V: DeserializeSeed<'de>,
    {
        // It doesn't make a difference whether the colon is parsed at the end
        // of `next_key_seed` or at the beginning of `next_value_seed`. In this
        // case the code is a bit simpler having it here.
        if self.de.next_char()? != ':' {
            return Err(Error::ExpectedMapColon);
        }
        // Deserialize a map value.
        seed.deserialize(&mut *self.de)
    }
}
```

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

### Visitor implementation for i32

Source: https://serde.rs/impl-deserialize.html

A complete `Visitor` implementation that deserializes an `i32` from various integer types. It implements `visit_i8`, `visit_i32`, and `visit_i64`, with range checking for `i64`. Other methods are left unimplemented, causing type errors if called.

```rust
use std::fmt;

use serde::de::{self, Visitor};

struct I32Visitor;

impl<'de> Visitor<'de> for I32Visitor {
    type Value = i32;

    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("an integer between -2^31 and 2^31")
    }

    fn visit_i8<E>(self, value: i8) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        Ok(i32::from(value))
    }

    fn visit_i32<E>(self, value: i32) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        Ok(value)
    }

    fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        use std::i32;
        if value >= i64::from(i32::MIN) && value <= i64::from(i32::MAX) {
            Ok(value as i32)
        } else {
            Err(E::custom(format!("i32 out of range: {}", value)))
        }
    }

    // Similar for other methods:
    //   - visit_i16
    //   - visit_u8
    //   - visit_u16
    //   - visit_u32
    //   - visit_u64
}

```

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

### Externally tagged representation JSON example

Source: https://serde.rs/enum-representations.html

Shows the JSON syntax for the externally tagged representation of the Message enum, where the variant name is the key and the content is the value.

```json
{"Request": {"id": "...", "method": "...", "params": {...}}}

```

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

### Basic Serde data format crate structure (src/lib.rs)

Source: https://serde.rs/conventions.html

Shows the initial module declarations and re-exports for a Serde data format crate. The `de`, `error`, and `ser` modules are discussed in more detail on the following pages.

```rust
mod de;
mod error;
mod ser;

pub use de::{from_str, Deserializer};
pub use error::{Error, Result};
pub use ser::{to_string, Serializer};

```

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

### src/de.rs - Basic JSON Deserializer Implementation

Source: https://serde.rs/impl-deserializer.html

Complete implementation of a basic JSON deserializer using Serde. It defines a Deserializer struct that parses from a string, with methods for peeking and consuming characters, parsing booleans, and parsing unsigned integers. The from_str function deserializes a value and checks for trailing characters.

```rust
use std::ops::{AddAssign, MulAssign, Neg};

use serde::Deserialize;
use serde::de::{
    self, DeserializeSeed, EnumAccess, IntoDeserializer, MapAccess, SeqAccess,
    VariantAccess, Visitor,
};

use error::{Error, Result};

pub struct Deserializer<'de> {
    // This string starts with the input data and characters are truncated off
    // the beginning as data is parsed.
    input: &'de str,
}

impl<'de> Deserializer<'de> {
    // By convention, `Deserializer` constructors are named like `from_xyz`.
    // That way basic use cases are satisfied by something like
    // `serde_json::from_str(...)` while advanced use cases that require a
    // deserializer can make one with `serde_json::Deserializer::from_str(...)`.
    pub fn from_str(input: &'de str) -> Self {
        Deserializer { input }
    }
}

// By convention, the public API of a Serde deserializer is one or more
// `from_xyz` methods such as `from_str`, `from_bytes`, or `from_reader`
// depending on what Rust types the deserializer is able to consume as input.
//
// This basic deserializer supports only `from_str`.
pub fn from_str<'a, T>(s: &'a str) -> Result<T>
where
    T: Deserialize<'a>,
{
    let mut deserializer = Deserializer::from_str(s);
    let t = T::deserialize(&mut deserializer)?;
    if deserializer.input.is_empty() {
        Ok(t)
    } else {
        Err(Error::TrailingCharacters)
    }
}

// SERDE IS NOT A PARSING LIBRARY. This impl block defines a few basic parsing
// functions from scratch. More complicated formats may wish to use a dedicated
// parsing library to help implement their Serde deserializer.
impl<'de> Deserializer<'de> {
    // Look at the first character in the input without consuming it.
    fn peek_char(&mut self) -> Result<char> {
        self.input.chars().next().ok_or(Error::Eof)
    }

    // Consume the first character in the input.
    fn next_char(&mut self) -> Result<char> {
        let ch = self.peek_char()?;
        self.input = &self.input[ch.len_utf8()..];
        Ok(ch)
    }

    // Parse the JSON identifier `true` or `false`.
    fn parse_bool(&mut self) -> Result<bool> {
        if self.input.starts_with("true") {
            self.input = &self.input["true".len()..];
            Ok(true)
        } else if self.input.starts_with("false") {
            self.input = &self.input["false".len()..];
            Ok(false)
        } else {
            Err(Error::ExpectedBoolean)
        }
    }

    // Parse a group of decimal digits as an unsigned integer of type T.
    //
    // This implementation is a bit too lenient, for example `001` is not
    // allowed in JSON. Also the various arithmetic operations can overflow and
    // panic or return bogus data. But it is good enough for example code!
    fn parse_unsigned<T>(&mut self) -> Result<T>
    where
        T: AddAssign<T> + MulAssign<T> + From<u8>,
    {
        let mut int = match self.next_char()? {
            ch @ '0'..='9' => T::from(ch as u8 - b'0'),
            _ => {
                return Err(Error::ExpectedInteger);
            }
        };
        loop {
            match self.input.chars().next() {
                Some(ch @ '0'..='9') => {
                    self.input = &self.input[1..];
                    int *= T::from(10);
                    int += T::from(ch as u8 - b'0');
                }
                _ => {
                    return Ok(int);
                }
            }
        }
    }
```

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

### User struct with borrowed fields for zero-copy deserialization

Source: https://serde.rs/lifetimes.html

Example of a struct that borrows string data from the input using the 'de lifetime. This enables zero-copy deserialization, avoiding allocations for each field.

```rust
#[derive(Deserialize)]
struct User<'a> {
    id: u32,
    name: &'a str,
    screen_name: &'a str,
    location: &'a str,
}
```

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

### Enable derive feature for no-std

Source: https://serde.rs/no-std.html

Use this configuration to enable the derive macros in a no-std crate. The derive macros work the same as in a std environment.

```toml
[dependencies]
serde = { version = "1.0", default-features = false, features = ["derive"] }

```

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

### Explicitly specifying borrowed lifetimes

Source: https://serde.rs/lifetimes.html

Shows how to explicitly specify which lifetimes to borrow using #[serde(borrow = "'a + 'b")]. The Example struct borrows only the first two lifetimes of the Three struct, not the third.

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

// This struct borrows the first two lifetimes but not the third.
#[derive(Deserialize)]
struct Three<'a, 'b, 'c> {
    a: &'a str,
    b: &'b str,
    c: PhantomData<&'c str>,
}

#[derive(Deserialize)]
struct Example<'a, 'b, 'c> {
    // Borrow 'a and 'b only, not 'c.
    #[serde(borrow = "'a + 'b")]
    three: Three<'a, 'b, 'c>,
}

```

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

### Serialize impl for i32 primitive

Source: https://serde.rs/impl-serialize.html

The builtin Serialize implementation for i32 calls serializer.serialize_i32(*self). Serde provides such impls for all Rust primitives, but the method is useful for custom types that need to be represented as a primitive.

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

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

### deserialize_str and deserialize_string implementations

Source: https://serde.rs/impl-deserializer.html

Handles deserialization of borrowed and owned strings. deserialize_str calls visitor.visit_borrowed_str with the parsed string, while deserialize_string delegates to deserialize_str.

```rust
    // Refer to the "Understanding deserializer lifetimes" page for information
    // about the three deserialization flavors of strings in Serde.
    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        visitor.visit_borrowed_str(self.parse_string()?)
    }

    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        self.deserialize_str(visitor)
    }
```

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

### Example JSON output with flattened extra field

Source: https://serde.rs/attr-flatten.html

Shows the JSON representation when the flattened `extra` field contains `"mascot": "Ferris"`. Deserialization would populate `"mascot"` back into the `extra` field.

```json
{
  "id": "49824073-979f-4814-be10-5ea416ee1c2f",
  "username": "john_doe",
  "mascot": "Ferris"
}
```
Tokens:
Raw