TOML

https://docs.rs/toml/latest
Admin
TOML is a Rust library providing a serde-compatible parser for the TOML configuration format, widely...
Tokens:161,209
Snippets:1,799
Trust Score:9.7
Update:1 month ago
Show doc for...
Tokens:
Raw
### TOML Configuration Example

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

A basic example of the TOML configuration format.

```toml
[package]
name = "toml"

[dependencies]
serde = "1.0"
```

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

### Example Datetime Value

Source: https://docs.rs/toml/latest/toml/enum.Value.html?search=

An example of a valid ISO 8601 datetime string as parsed by the toml crate.

```text
1979-05-27T07:32:00Z
```

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

### Local Date-Time examples

Source: https://docs.rs/toml/latest/toml/value/struct.Datetime.html?search=

Examples of RFC 3339 formatted date-times without offsets.

```toml
ldt1 = 1979-05-27T07:32:00
ldt2 = 1979-05-27T00:32:00.999999
```

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

### Constructing a Vector with Capacity

Source: https://docs.rs/toml/latest/toml/value/type.Array.html

Example of creating a vector with a pre-allocated capacity and demonstrating its behavior.

```rust
let mut vec = Vec::with_capacity(10);

// The vector contains no items, even though it has capacity for more
assert_eq!(vec.len(), 0);
assert!(vec.capacity() >= 10);

// These are all done without reallocating...
for i in 0..10 {
    vec.push(i);
}
assert_eq!(vec.len(), 10);
assert!(vec.capacity() >= 10);

// ...but this may make the vector reallocate
vec.push(11);
assert_eq!(vec.len(), 11);
assert!(vec.capacity() >= 11);

// A vector of a zero-sized type will always over-allocate, since no
// allocation is necessary
let vec_units = Vec::<()>::with_capacity(10);
assert_eq!(vec_units.capacity(), usize::MAX);
```

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

### Constructing a New Vector

Source: https://docs.rs/toml/latest/toml/value/type.Array.html

Example of creating a new, empty vector.

```rust
let mut vec: Vec<i32> = Vec::new();
```

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

### get()

Source: https://docs.rs/toml/latest/toml/map/struct.OccupiedEntry.html

Gets a reference to the value in the entry.

```APIDOC
## pub fn get(&self) -> &V

### Description
Gets a reference to the value in the entry.
```

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

### Offset Date-Time examples

Source: https://docs.rs/toml/latest/toml/value/struct.Datetime.html?search=

Examples of RFC 3339 formatted date-times with offsets as defined in the TOML v1.0.0 spec.

```toml
odt1 = 1979-05-27T07:32:00Z
odt2 = 1979-05-27T00:32:00-07:00
odt3 = 1979-05-27T00:32:00.999999-07:00
```

```toml
odt4 = 1979-05-27 07:32:00Z
```

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

### TOML Time Specification Examples

Source: https://docs.rs/toml/latest/toml/value/struct.Time.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Examples of TOML local time values as described in the TOML v1.0.0 specification.

```toml
lt1 = 07:32:00
lt2 = 00:32:00.999999
```

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

### Consuming Iterator Example

Source: https://docs.rs/toml/latest/toml/value/type.Array.html

Shows how to create a consuming iterator from a vector and retrieve the first element.

```rust
let v = vec!["a".to_string(), "b".to_string()];
let mut v_iter = v.into_iter();

let first_element: Option<String> = v_iter.next();
```

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

### Example searches for API documentation

Source: https://docs.rs/toml/latest/toml/value/enum.Value.html?search=

Common search patterns used to find types, conversions, or function signatures within the documentation.

```text
  * std::vec
  * u32 -> bool
  * Option<T>, (T -> U) -> Option<U>
```

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

### Creating a Vec using Vec::from_fn

Source: https://docs.rs/toml/latest/toml/value/type.Array.html

Examples of generating a vector where each element is determined by its index.

```rust
#![feature(vec_from_fn)]

let vec = Vec::from_fn(5, |i| i);

// indexes are:  0  1  2  3  4
assert_eq!(vec, [0, 1, 2, 3, 4]);

let vec2 = Vec::from_fn(8, |i| i * 2);

// indexes are:   0  1  2  3  4  5   6   7
assert_eq!(vec2, [0, 2, 4, 6, 8, 10, 12, 14]);

let bool_vec = Vec::from_fn(5, |i| i % 2 == 0);

// indexes are:       0     1      2     3      4
assert_eq!(bool_vec, [true, false, true, false, true]);
```

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

### TOML Local Date Example

Source: https://docs.rs/toml/latest/toml/value/struct.Date.html

An example of a local date value as defined by the TOML v1.0.0 specification.

```toml
ld1 = 1979-05-27
```

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

### key()

Source: https://docs.rs/toml/latest/toml/map/struct.OccupiedEntry.html

Gets a reference to the key in the entry.

```APIDOC
## pub fn key(&self) -> &K

### Description
Gets a reference to the key in the entry.
```

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

### Vec::split_at_spare_mut example

Source: https://docs.rs/toml/latest/toml/value/type.Array.html

Splits a vector into initialized and uninitialized slices, requiring the vec_split_at_spare feature.

```rust
#![feature(vec_split_at_spare)]

let mut v = vec![1, 1, 2];

// Reserve additional space big enough for 10 elements.
v.reserve(10);

let (init, uninit) = v.split_at_spare_mut();
let sum = init.iter().copied().sum::<u32>();

// Fill in the next 4 elements.
uninit[0].write(sum);
uninit[1].write(sum * 2);
uninit[2].write(sum * 3);
uninit[3].write(sum * 4);

// Mark the 4 elements of the vector as being initialized.
unsafe {
    let len = v.len();
    v.set_len(len + 4);
}

assert_eq!(&v, &[1, 1, 2, 4, 8, 12, 16]);
```

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

### Vec::resize_with example

Source: https://docs.rs/toml/latest/toml/value/type.Array.html

Resizes a vector using a closure to generate new elements or Default::default for padding.

```rust
let mut vec = vec![1, 2, 3];
vec.resize_with(5, Default::default);
assert_eq!(vec, [1, 2, 3, 0, 0]);

let mut vec = vec![];
let mut p = 1;
vec.resize_with(4, || { p *= 2; p });
assert_eq!(vec, [2, 4, 8, 16]);
```

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

### Serialize a struct to TOML

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

Example demonstrating how to use ValueSerializer to serialize a custom Rust struct into a TOML string.

```rust
use serde::Serialize;

#[derive(Serialize)]
struct Config {
    database: Database,
}

#[derive(Serialize)]
struct Database {
    ip: String,
    port: Vec<u16>,
    connection_max: u32,
    enabled: bool,
}

let config = Config {
    database: Database {
        ip: "192.168.1.1".to_string(),
        port: vec![8001, 8002, 8003],
        connection_max: 5000,
        enabled: false,
    },
};

let mut value = String::new();
serde::Serialize::serialize(
    &config,
    toml::ser::ValueSerializer::new(&mut value)
).unwrap();
println!("{}", value)
```

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

### Map initialization methods

Source: https://docs.rs/toml/latest/src/toml/map.rs.html?search=

Methods for creating a new Map, including conditional implementations for capacity support based on the preserve_order feature.

```rust
45impl<K, V> Map<K, V>
46where
47    K: Ord + Hash,
48{
49    /// Makes a new empty Map.
50    #[inline]
51    pub fn new() -> Self {
52        Self {
53            #[cfg(feature = "preserve_order")]
54            map: MapImpl::with_hasher(RandomState::default()),
55            #[cfg(not(feature = "preserve_order"))]
56            map: MapImpl::new(),
57            dotted: false,
58            implicit: false,
59            inline: false,
60        }
61    }
62
63    #[cfg(not(feature = "preserve_order"))]
64    /// Makes a new empty Map with the given initial capacity.
65    #[inline]
66    pub fn with_capacity(capacity: usize) -> Self {
67        // does not support with_capacity
68        let _ = capacity;
69        Self::new()
70    }
71
72    #[cfg(feature = "preserve_order")]
73    /// Makes a new empty Map with the given initial capacity.
74    #[inline]
75    pub fn with_capacity(capacity: usize) -> Self {
76        Self {
77            map: IndexMap::with_capacity_and_hasher(capacity, RandomState::default()),
78            dotted: false,
79            implicit: false,
80            inline: false,
81        }
82    }
```

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

### Hashing a Vector

Source: https://docs.rs/toml/latest/toml/value/type.Array.html

Demonstrates how to hash a vector using RandomState.

```rust
let b = std::hash::RandomState::new();
let v: Vec<u8> = vec![0xa8, 0x3c, 0x09];
let s: &[u8] = &[0xa8, 0x3c, 0x09];
assert_eq!(b.hash_one(v), b.hash_one(s));
```

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

### toml::ser::Buffer::new

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

Initializes a new instance of the serialization buffer.

```APIDOC
## pub fn new() -> Self

### Description
Initializes a new serialization buffer for TOML documents.

### Returns
- **Self** - A new instance of the Buffer.
```

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

### get_mut()

Source: https://docs.rs/toml/latest/toml/map/struct.OccupiedEntry.html

Gets a mutable reference to the value in the entry.

```APIDOC
## pub fn get_mut(&mut self) -> &mut V

### Description
Gets a mutable reference to the value in the entry.
```

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

### OccupiedEntry::get method

Source: https://docs.rs/toml/latest/toml/map/struct.OccupiedEntry.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Gets a reference to the value in the entry.

```rust
pub fn get(&self) -> &V
```

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

### Table Display and FromStr Implementations

Source: https://docs.rs/toml/latest/src/toml/table.rs.html?search=

Optional implementations for displaying a Table as a string and parsing a Table from a string.

```rust
43#[cfg(feature = "display")]
44impl core::fmt::Display for Table {
45    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
46        crate::ser::to_string(self)
47            .expect("Unable to represent value as string")
48            .fmt(f)
49    }
50}
51
52#[cfg(feature = "parse")]
53impl core::str::FromStr for Table {
54    type Err = crate::de::Error;
55    fn from_str(s: &str) -> Result<Self, Self::Err> {
56        crate::from_str(s)
57    }
58}
```

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

### OccupiedEntry::get_mut method

Source: https://docs.rs/toml/latest/toml/map/struct.OccupiedEntry.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Gets a mutable reference to the value in the entry.

```rust
pub fn get_mut(&mut self) -> &mut V
```

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

### Buffer::new

Source: https://docs.rs/toml/latest/src/toml/ser/document/buffer.rs.html?search=u32+-%3E+bool

Initializes a new, empty serialization buffer.

```APIDOC
## Buffer::new

### Description
Creates a new instance of the TOML serialization buffer.

### Signature
`pub fn new() -> Self`
```

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

### VacantEntry::key

Source: https://docs.rs/toml/latest/toml/map/struct.VacantEntry.html?search=

Gets a reference to the key that would be used when inserting a value through the VacantEntry.

```APIDOC
## pub fn key(&self) -> &K

### Description
Gets a reference to the key that would be used when inserting a value through the `VacantEntry`.

### Returns
- **&K** - A reference to the key.
```

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

### toml!

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

Constructs a toml::value::Table from TOML syntax provided as a macro argument.

```APIDOC
## toml!

### Description
Constructs a `toml::value::Table` from TOML syntax. This macro allows for the declarative creation of TOML structures within Rust code.

### Usage
```rust
let cargo_toml = toml::toml! {
    [package]
    name = "toml"

    [dependencies]
    serde = "1.0"
};
```
```

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

### Array Iteration Assertions

Source: https://docs.rs/toml/latest/toml/value/type.Array.html

Example assertions demonstrating the iteration behavior of the array type.

```rust
assert_eq!(first_element, Some("a".to_string()));
assert_eq!(v_iter.next(), Some("b".to_string()));
assert_eq!(v_iter.next(), None);
```

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

### Creating a new Serializer

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

Initializes a new serializer that writes TOML output into the provided buffer.

```rust
    pub fn new(buf: &'d mut Buffer) -> Self {
        let table = buf.root_table();
        Self {
            buf,
            style: Default::default(),
            table,
        }
    }
```

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

### toml!

Source: https://docs.rs/toml/latest/toml/macro.toml.html

Constructs a Table from TOML syntax provided as a token stream.

```APIDOC
## macro toml!

### Description
Constructs a `Table` from TOML syntax. This macro is available when the `serde` crate feature is enabled.

### Signature
`macro_rules! toml { ($($toml:tt)+) => { ... }; }`

### Example
```rust
let cargo_toml = toml::toml! {
    [package]
    name = "toml"

    [dependencies]
    serde = "1.0"

    [dev-dependencies]
    serde_derive = "1.0"
    serde_json = "1.0"
};

println!("{:#?}", cargo_toml);
```
```

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

### Using from_parts_in with external memory

Source: https://docs.rs/toml/latest/toml/value/type.Array.html

Shows how to use from_parts_in with memory allocated via the Global allocator.

```rust
#![feature(allocator_api)]

use std::alloc::{AllocError, Allocator, Global, Layout};

fn main() {
    let layout = Layout::array::<u32>(16).expect("overflow cannot happen");

    let vec = unsafe {
        let mem = match Global.allocate(layout) {
            Ok(mem) => mem.cast::<u32>(),
            Err(AllocError) => return,
        };

        mem.write(1_000_000);

        Vec::from_parts_in(mem, 1, 16, Global)
    };

    assert_eq!(vec, &[1_000_000]);
    assert_eq!(vec.capacity(), 16);
}
```

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

### Value Display and FromStr Implementations

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

Implementations for fmt::Display and core::str::FromStr for the Value type, gated by features.

```rust
#[cfg(feature = "display")]
impl fmt::Display for Value {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        use serde_core::Serialize as _;

        let mut output = String::new();
        let serializer = crate::ser::ValueSerializer::new(&mut output);
        self.serialize(serializer).unwrap();
        output.fmt(f)
    }
}
```

```rust
#[cfg(feature = "parse")]
impl core::str::FromStr for Value {
    type Err = crate::de::Error;
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        use serde_core::Deserialize as _;
        Self::deserialize(crate::de::ValueDeserializer::parse(s)?)
    }
}
```

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

### Vec::recycle alignment mismatch error

Source: https://docs.rs/toml/latest/toml/value/type.Array.html

Example of a failed recycle attempt due to different alignments.

```rust
#![feature(vec_recycle, transmutability)]
let vec: Vec<[u16; 0]> = Vec::new();
let _: Vec<[u8; 0]> = vec.recycle();
```

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

### Vec::recycle size mismatch error

Source: https://docs.rs/toml/latest/toml/value/type.Array.html

Example of a failed recycle attempt due to different sizes.

```rust
#![feature(vec_recycle, transmutability)]
let vec: Vec<[u8; 2]> = Vec::new();
let _: Vec<[u8; 1]> = vec.recycle();
```

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

### Vec::spare_capacity_mut example

Source: https://docs.rs/toml/latest/toml/value/type.Array.html

Accesses the unused capacity of a vector as a slice of MaybeUninit to manually initialize elements.

```rust
// Allocate vector big enough for 10 elements.
let mut v = Vec::with_capacity(10);

// Fill in the first 3 elements.
let uninit = v.spare_capacity_mut();
uninit[0].write(0);
uninit[1].write(1);
uninit[2].write(2);

// Mark the first 3 elements of the vector as being initialized.
unsafe {
    v.set_len(3);
}

assert_eq!(&v, &[0, 1, 2]);
```

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

### Vec::leak example

Source: https://docs.rs/toml/latest/toml/value/type.Array.html

Consumes a vector and returns a mutable reference to its contents, effectively leaking the memory.

```rust
let x = vec![1, 2, 3];
let static_ref: &'static mut [usize] = x.leak();
static_ref[0] += 1;
assert_eq!(static_ref, &[2, 2, 3]);
```

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

### Initialize Vec via as_mut_ptr

Source: https://docs.rs/toml/latest/toml/value/type.Array.html

Demonstrates allocating a vector and initializing its elements using a raw mutable pointer obtained via as_mut_ptr.

```rust
// Allocate vector big enough for 4 elements.
let size = 4;
let mut x: Vec<i32> = Vec::with_capacity(size);
let x_ptr = x.as_mut_ptr();

// Initialize elements via raw pointer writes, then set length.
unsafe {
    for i in 0..size {
        *x_ptr.add(i) = i as i32;
    }
    x.set_len(size);
}
assert_eq!(&*x, &[0, 1, 2, 3]);
```

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

### Offset Date-Time with Space Delimiter

Source: https://docs.rs/toml/latest/toml/value/struct.Datetime.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Example of an Offset Date-Time using a space character instead of the T delimiter.

```toml
odt4 = 1979-05-27 07:32:00Z
```

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

### Initialize Vec via as_non_null

Source: https://docs.rs/toml/latest/toml/value/type.Array.html

Demonstrates allocating a vector and initializing its elements using a NonNull pointer obtained via as_non_null. Requires the box_vec_non_null feature.

```rust
#![feature(box_vec_non_null)]

// Allocate vector big enough for 4 elements.
let size = 4;
let mut x: Vec<i32> = Vec::with_capacity(size);
let x_ptr = x.as_non_null();

// Initialize elements via raw pointer writes, then set length.
unsafe {
    for i in 0..size {
        x_ptr.add(i).write(i as i32);
    }
    x.set_len(size);
}
assert_eq!(&*x, &[0, 1, 2, 3]);
```

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

### Vec::split_off example

Source: https://docs.rs/toml/latest/toml/value/type.Array.html

Splits a vector into two at the specified index, returning the second part as a new vector.

```rust
let mut vec = vec!['a', 'b', 'c'];
let vec2 = vec.split_off(1);
assert_eq!(vec, ['a']);
assert_eq!(vec2, ['b', 'c']);
```

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

### ValueVisitor implementation for TOML

Source: https://docs.rs/toml/latest/src/toml/value.rs.html

Implements the visitor pattern to handle various TOML types during deserialization, including strings, sequences, and tables.

```rust
fn visit_string<E>(self, value: String) -> Result<Value, E> {
    Ok(Value::String(value))
}

fn visit_some<D>(self, deserializer: D) -> Result<Value, D::Error>
where
    D: de::Deserializer<'de>,
{
    de::Deserialize::deserialize(deserializer)
}

fn visit_seq<V>(self, mut visitor: V) -> Result<Value, V::Error>
where
    V: de::SeqAccess<'de>,
{
    let mut vec = Vec::new();
    while let Some(elem) = visitor.next_element()? {
        vec.push(elem);
    }
    Ok(Value::Array(vec))
}

fn visit_map<V>(self, mut visitor: V) -> Result<Value, V::Error>
where
    V: de::MapAccess<'de>,
{
    let key = match toml_datetime::de::VisitMap::next_key_seed(&mut visitor)? {
        Some(toml_datetime::de::VisitMap::Datetime(datetime)) => {
            return Ok(Value::Datetime(datetime));
        }
        None => return Ok(Value::Table(Table::new())),
        Some(toml_datetime::de::VisitMap::Key(key)) => key,
    };
    let mut map = Table::new();
    map.insert(key.into_owned(), visitor.next_value()?);
    while let Some(key) = visitor.next_key::<String>()? {
        if let crate::map::Entry::Vacant(vacant) = map.entry(&key) {
            vacant.insert(visitor.next_value()?);
        } else {
            let msg = format!("duplicate key: `{key}`");
            return Err(de::Error::custom(msg));
        }
    }
    Ok(Value::Table(map))
}
```

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

### Memory leak warning with set_len

Source: https://docs.rs/toml/latest/toml/value/type.Array.html

Shows an example where set_len causes a memory leak because it does not drop the existing elements.

```rust
let mut vec = vec![vec![1, 0, 0],
                   vec![0, 1, 0],
                   vec![0, 0, 1]];
// SAFETY:
// 1. `old_len..0` is empty so no elements need to be initialized.
// 2. `0 <= capacity` always holds whatever `capacity` is.
unsafe {
    vec.set_len(0);
}
```

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

### Creating a Vec from custom allocated memory

Source: https://docs.rs/toml/latest/toml/value/type.Array.html

Shows how to use Vec::from_parts with memory allocated via the global allocator.

```rust
#![feature(box_vec_non_null)]

use std::alloc::{alloc, Layout};
use std::ptr::NonNull;

fn main() {
    let layout = Layout::array::<u32>(16).expect("overflow cannot happen");

    let vec = unsafe {
        let Some(mem) = NonNull::new(alloc(layout).cast::<u32>()) else {
            return;
        };

        mem.write(1_000_000);

        Vec::from_parts(mem, 1, 16)
    };

    assert_eq!(vec, &[1_000_000]);
    assert_eq!(vec.capacity(), 16);
}
```

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

### Vec::recycle exotic type limitation

Source: https://docs.rs/toml/latest/toml/value/type.Array.html

Example of a limitation where exotic types like slices or trait objects cannot be recycled.

```rust
#![feature(vec_recycle, transmutability)]
let mut storage: Vec<&[&str]> = Vec::new();

for input in inputs {
    let mut buffer: Vec<&str> = storage.recycle();
    buffer.extend(input.split(" "));
    process(&buffer);
    storage = buffer.recycle();
}
```

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

### Reconstructing a Vec with from_parts_in

Source: https://docs.rs/toml/latest/toml/value/type.Array.html

Demonstrates deconstructing a vector into its raw parts and rebuilding it using from_parts_in.

```rust
#![feature(allocator_api)]

use std::alloc::System;

let mut v = Vec::with_capacity_in(3, System);
v.push(1);
v.push(2);
v.push(3);

// Deconstruct the vector into parts.
let (p, len, cap, alloc) = v.into_parts_with_alloc();

unsafe {
    // Overwrite memory with 4, 5, 6
    for i in 0..len {
        p.add(i).write(4 + i);
    }

    // Put everything back together into a Vec
    let rebuilt = Vec::from_parts_in(p, len, cap, alloc.clone());
    assert_eq!(rebuilt, [4, 5, 6]);
}
```

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

### Transposing Spanned Enum

Source: https://docs.rs/toml/latest/toml/struct.Spanned.html

Example showing how to transpose a Spanned<Enum<T>> into Enum<Spanned<T>> using the Spanned::new method.

```rust
use serde::de::{Deserialize, Deserializer};
use serde_untagged::UntaggedEnumVisitor;
use toml::Spanned;

pub enum Dependency {
    Simple(Spanned<String>),
    Detailed(Spanned<DetailedDependency>),
}

impl<'de> Deserialize<'de> for Dependency {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        enum DependencyKind {
            Simple(String),
            Detailed(DetailedDependency),
        }

        impl<'de> Deserialize<'de> for DependencyKind {
            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
            where
                D: Deserializer<'de>,
            {
                UntaggedEnumVisitor::new()
                    .expecting(
                        "a version string like \"0.9.8\" or a \
                            detailed dependency like { version = \"0.9.8\" }",
                    )
                    .string(|value| Ok(DependencyKind::Simple(value.to_owned())))
                    .map(|value| value.deserialize().map(DependencyKind::Detailed))
                    .deserialize(deserializer)
            }
        }

        let spanned: Spanned<DependencyKind> = Deserialize::deserialize(deserializer)?;
        let range = spanned.span();
        Ok(match spanned.into_inner() {
            DependencyKind::Simple(simple) => Dependency::Simple(Spanned::new(range, simple)),
            DependencyKind::Detailed(detailed) => Dependency::Detailed(Spanned::new(range, detailed)),
        })
    }
}
```
Tokens:
Raw