serde_with有这样的东西：KeyValueMap：

use serde::{Deserialize, Serialize};
use serde_with::{serde_as, KeyValueMap};

#[derive(Debug, Serialize, Deserialize)]
struct Item {
    #[serde(rename = "$key$")]
    name: String,
    uid: String,
    foo: String,
}

#[serde_as]
#[derive(Debug, Serialize, Deserialize)]
struct Schema {
    #[serde_as(as = "KeyValueMap<_>")]
    items: Vec<Item>,
}

字符串

您可以使用自定义的解析器和Visitor来完成此操作，而无需中间分配：

use serde::Deserializer;
use serde::de::MapAccess;
use serde::de::Visitor;
use serde_derive::{Deserialize, Serialize};
use std::fmt;
use std::vec::Vec;

#[derive(Debug, Serialize, Deserialize)]
struct Item {
  name: String,
  uid: String,
  foo: String,
}

#[derive(Debug, Serialize, Deserialize)]
struct Schema {
    #[serde(deserialize_with = "deserialize_items")]
    items: Vec<Item>,
}

fn deserialize_items<'de, D> (deserializer: D) -> Result<Vec<Item>, D::Error>
where D: Deserializer<'de>,
{
    struct ItemsVisitor;

    impl<'de> Visitor<'de> for ItemsVisitor
    {
        type Value = Vec<Item>;

        fn expecting (&self, formatter: &mut fmt::Formatter) -> fmt::Result {
            formatter.write_str("an items map")
        }
        
        fn visit_map<M> (self, mut map: M) -> Result<Vec<Item>, M::Error>
        where M: MapAccess<'de>,
        {
            #[derive(Deserialize)]
            struct ItemFields {
                uid: String,
                foo: String,
            }

            let mut result = vec![];
            while let Some ((name, fields)) = map.next_entry::<_, ItemFields>()? {
                result.push (Item { name, uid: fields.uid, foo: fields.foo });
            }
            Ok (result)
        }
    }
    
    deserializer.deserialize_map (ItemsVisitor)
}

fn main() {
    let input = r###"
items:
  item1:
    uid: ab1234
    foo: bar
  item2:
    uid: cd5678
    foo: baz
"###;

    let items = serde_yaml::from_str::<Schema>(input);
    println!("{:?}", items);
}

字符串
Playground的
标签：https://serde.rs/stream-array.html

虽然这肯定不是解决这个问题的最好的方法，但你可以将tuple_vec_map crate和一个自定义的函数组合起来：

#[derive(Debug, Serialize, Deserialize)]
struct Schema {
    #[serde(deserialize_with = "vec_item")]
    items: Vec<Item>,
}

fn vec_item<'de, D>(de: D) -> Result<Vec<Item>, D::Error>
where
    D: Deserializer<'de>,
{
    #[derive(Deserialize)]
    struct ItemSerde {
        uid: String,
        foo: String,
    }
    #[derive(Deserialize)]
    #[serde(transparent)]
    struct SchemaSerde(#[serde(with = "tuple_vec_map")] Vec<(String, ItemSerde)>);

    let SchemaSerde(items) = Deserialize::deserialize(de)?;
    Ok(items
        .into_iter()
        .map(|(name, ItemSerde { uid, foo })| Item { name, uid, foo })
        .collect())
}

字符串
Explorer

你可以读入String-> RawItem（没有名字的项目）的临时Map，并将其转换为你需要的结构：

#[derive(Debug, Deserialize)]
struct Schema {
    #[serde(deserialize_with = "deserialize_schema_items")]
    items: Vec<Item>,
}

fn deserialize_schema_items<'de, D: Deserializer<'de>>(d: D) -> Result<Vec<Item>, D::Error> {
    #[derive(Deserialize)]
    struct RawItem {
        uid: String,
        foo: String,
    }
    let raw_items: IndexMap<String, RawItem> = Deserialize::deserialize(d)?;
    let items = raw_items
        .into_iter()
        .map(|(name, raw_item)| Item {
            name,
            uid: raw_item.uid,
            foo: raw_item.foo,
        })
        .collect();
    Ok(items)
}

字符串
上面的代码使用indexmap::IndexMap来保持顺序。如果你不关心顺序，你可以使用HashMap。如果你选择IndexMap，请注意，你需要打开indexmap机箱的serde功能。