How can I use Valuable on serde_json::Value

[Vrajs16]

I am using the valuable experimental feature, but doesn't seem to work with serde_json value. It seems I have to derive the Valuable Trait on struct but not sure how I would do that with serde_json::Value since I can't implement a trait on a type outside my crate. Are there any solutions or alternatives that I can do?

[Vrajs16]

I found this here. But seems like it has not been merged. I am trying to do the same with the new type pattern but stuck on array and object

use serde_json::{Map, Value as Json};

use valuable::{Mappable, Valuable, Value, Visit};

pub struct JsonValueable<'a>(pub &'a Json);
pub struct JsonValueableMap<'a>(pub &'a Map<String, Json>);

impl<'a> Valuable for JsonValueable<'a> {
    fn as_value(&self) -> Value<'_> {
        match self.0 {
            Json::Array(_) => todo!(),
            Json::Bool(value) => value.as_value(),
            Json::Number(num) => {
                if num.is_f64() {
                    Value::F64(num.as_f64().unwrap())
                } else if num.is_i64() {
                    Value::I64(num.as_i64().unwrap())
                } else {
                    unreachable!()
                }
            }
            Json::Null => Value::Unit,
            Json::String(s) => s.as_value(),
            Json::Object(object) => todo!(),
        }
    }

    fn visit(&self, visit: &mut dyn Visit) {
        match self.0 {
            Json::Array(array) => array
                .iter()
                .map(JsonValueable)
                .collect::<Vec<_>>()
                .visit(visit),
            Json::Bool(value) => value.visit(visit),
            Json::Number(num) => {
                if num.is_f64() {
                    num.as_f64().unwrap().visit(visit)
                } else if num.is_i64() {
                    num.as_i64().unwrap().visit(visit)
                } else {
                    unreachable!()
                }
            }
            Json::Null => Value::Unit.visit(visit),
            Json::String(s) => s.visit(visit),
            Json::Object(object) => JsonValueableMap(object).visit(visit),
        }
    }
}

impl<'a> Valuable for JsonValueableMap<'a> {
    fn as_value(&self) -> Value<'_> {
        Value::Mappable(self)
    }

    fn visit(&self, visit: &mut dyn Visit) {
        for (k, v) in self.0.iter() {
            visit.visit_entry(k.as_value(), JsonValueable(v).as_value());
        }
    }
}

impl<'a> Mappable for JsonValueableMap<'a> {
    fn size_hint(&self) -> (usize, Option<usize>) {
        let len = self.0.len();
        (len, Some(len))
    }
}

If anyone can help me that would be greately appreciated. Thanks!

[Vrajs16]

Posted on Stackoverflow and seems like a reasonable solution.