Десериализовать массив json в существующий Vec

Обновлено: я забыл о serde::Deserialize::deserialize_in_place (скрытом в документации), когда писал этот ответ. Хотя этот ответ действительно показывает, как можно добиться аналогичных результатов с помощью Visitor, я рекомендую вместо этого следовать ответу kmdreko.

Мы не можем полностью десериализовать все на месте, потому что serde спроектирован так, чтобы возвращать значение по мере его десериализации. Однако, если вы просто хотите десериализовать в один Vec, мы можем создать посетителя, который справится с этой ситуацией. Вот примерно как это будет выглядеть.

use serde::de::{DeserializeOwned, SeqAccess, Visitor};
use serde::{Deserialize, Deserializer};
use std::fmt::{self, Formatter};

struct InPlaceVisitor<'a, T> {
    buffer: &'a mut Vec<T>,
}

impl<'de, 'a: 'de, T> Visitor<'de> for InPlaceVisitor<'a, T>
where
    T: Deserialize<'de>,
{
    /// We are deserializing in place so we won't have any output
    type Value = ();

    /// Every visitor needs to implement this function to add some
    /// context to error messages. This will be called if any of the
    /// `visit_*` functions we didn't implement get called.
    fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result {
        write!(f, "sequence of values")
    }

    /// Handle the case where the deserializer finds a sequence of
    /// values.
    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
    where
        A: SeqAccess<'de>,
    {
        // Clear the buffer before we begin
        self.buffer.clear();

        // If the deserializer knows the number of items in the
        // sequence we can ensure we have enough capacity before
        // starting. However, this is generally only the case for
        // formats that prefix sequences with their lengths.
        if let Some(hint) = seq.size_hint() {
            self.buffer.reserve(hint);
        }

        // Now we can just read the values and add them to the
        // buffer. This will call serde::Deserialize::deserialize for 
        // each element.
        while let Some(value) = seq.next_element()? {
            self.buffer.push(value);
        }

        Ok(())
    }
}

Теперь одна из сложных частей использования этого заключается в том, что нам нужно создать нашего посетителя с буфером, в который мы хотим отправить. Это сложно, а это значит, что у нас не будет доступа к нашему буферу внутри serde::Deserialize::deserialize. В результате мы должны сами сконструировать десериализатор. Не все форматы serde раскрывают свои типы Serializer и Deserializer, поэтому это решение будет невозможно для всех форматов данных. К счастью, serde_json предоставляет свой десериализатор, поэтому мы можем реализовать общую функцию для использования нашего посетителя.

pub fn deserialize_json_in_place<'de, 'a: 'de, T, R>(
    reader: R,
    buffer: &'a mut Vec<T>,
) -> serde_json::Result<()>
where
    T: Deserialize<'de>,
    R: serde_json::de::Read<'de>,
{
    let mut deserializer = serde_json::de::Deserializer::new(reader);

    let visitor = InPlaceVisitor { buffer };

    // We tell the deserializer what we are hoping to find, then the
    // deserializer calls the `visit_*` function corresponding to the
    // type it actually encountered.
    deserializer.deserialize_seq(visitor)
}

С этим у нас все готово. Однако для удобства вы все равно можете захотеть создать несколько простых функций-оболочек для создания средства чтения.

pub fn from_str_into<T>(x: &str, buffer: &mut Vec<T>) -> serde_json::Result<()>
where
    T: DeserializeOwned,
{
    let reader = serde_json::de::StrRead::new(x);
    deserialize_json_in_place(reader, buffer)
}

Ржавая площадка

Существует скрытый¹метод deserialize_in_place для типажа Deserialize, который может это поддержать. По умолчанию он просто создаст новое значение и присвоит его существующему, но имплант Vec делает именно то, что вы хотите.

Поэтому вам просто нужно вызвать его вручную с помощью десериализатора serde-json:

use serde::Deserialize;
use serde_json::Deserializer;

let mut deserializer = Deserializer::from_str(&resp);
Deserialize::deserialize_in_place(&mut deserializer, &mut bigvec).unwrap();

^{1. This is not a private API. The documentation says "This method is stable and an official public API, but hidden from the documentation because it is almost never what newbies are looking for."}

Однако использование #[derive(Deserialize)] НЕ будет реализовано deserialize_in_place, если вы не включите функцию deserialize_in_place в serde_derive. Реализация Deserialize::deserialize_in_place по умолчанию просто вызывает Deserialize::deserialize. Это означает, что вызов deserialize_in_place не всегда будет выполнять десериализацию на месте.

#[derive(Deserialize)]
struct Foo {
    a: Vec<i32>,
}

let mut foo = Foo { a: Vec::new() };
for data in example_data {
    // If the `deserialize_in_place` feature is not enabled, this call will result
    // in a new `Vec` being created every call.
    let mut deserializer = Deserializer::from_str(&resp);
    Foo::deserialize_in_place(&mut deserializer, &mut foo).unwrap();
}