Custom (de-)serialization in Serde (Rust)

extern crate serde;
extern crate serde_derive;
extern crate serde_json;

use std::collections::BTreeMap as Map;

use serde::{
    de::{SeqAccess, Visitor},
    // ser::SerializeSeq,
    Deserialize,
    Deserializer,
    Serialize,
    Serializer,
};

// use std::time::Instant;

#[derive(Debug, Deserialize, Serialize)]
struct Data<'a> {
    title: &'a str,
    #[serde(deserialize_with = "deserialize_vec_to_map")]
    #[serde(serialize_with = "serialize_map_to_vec")]
    values: Map<&'a str, bool>,
}

struct SeqVisitor<T>(std::marker::PhantomData<T>);

impl<'de, T> Visitor<'de> for SeqVisitor<T>
where
    T: Deserialize<'de> + std::cmp::Ord,
{
    type Value = Map<T, bool>;

    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
        formatter.write_str("a sequence")
    }

    fn visit_seq<V>(self, mut seq: V) -> Result<Map<T, bool>, V::Error>
    where
        V: SeqAccess<'de>,
    {
        let mut map: Map<T, bool> = Map::new();
        while let Some(v) = seq.next_element()? {
            map.insert(v, true);
        }
        Ok(map)
    }
}

fn deserialize_vec_to_map<'de, T, D>(deserializer: D) -> Result<Map<T, bool>, D::Error>
where
    T: Deserialize<'de> + std::cmp::Ord, // + Copy,
    D: Deserializer<'de>,
{
    // Deserialize::deserialize(deserializer)
    //     .map(|v: Vec<T>| v.iter().copied().map(|k| (k, true)).collect())
    deserializer.deserialize_seq(SeqVisitor(std::marker::PhantomData))
}

fn serialize_map_to_vec<T, S>(value: &Map<T, bool>, serializer: S) -> Result<S::Ok, S::Error>
where
    T: Serialize,
    S: Serializer,
{
    // let mut seq = serializer.serialize_seq(Some(value.len()))?;
    // for (k, _) in value.iter().filter(|(_, &v)| v) {
    //     seq.serialize_element(k)?;
    // }
    // seq.end()
    serializer.collect_seq(value.iter().filter(|(_, &v)| v).map(|(k, _)| k))
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let src = r#"{"title":"Hello","values":["a", "b", "a"]}"#;
    println!("Source: {}\n", src);

    // let t1 = Instant::now();
    let serialized: Data = serde_json::from_str(src)?;
    // let t2 = Instant::now();
    println!("Serialized struct:\n{:#?}\n", serialized);
    // println!("Serialized in {}ms", (t2 - t1).as_nanos() as f64 / 1_000_000.0);

    // let t1 = Instant::now();
    let deserialized = serde_json::to_string(&serialized)?;
    // let t2 = Instant::now();
    println!("Deserialized: {}", deserialized);
    // println!("Deserialized in {}ms", (t2 - t1).as_nanos() as f64 / 1_000_000.0);
    Ok(())
}