Implement valuable value pointer

[taiki-e]

Example

use valuable::*;

#[derive(Valuable)]
struct Struct1 {
    x: String,
    y: Struct2,
}

#[derive(Valuable)]
struct Struct2 {
    z: String,
}

struct Visitor;

impl Visit for Visitor {
    fn visit_value(&mut self, value: Value<'_>) {
        println!("{:?}", value);
    }
}

fn main() {
    let value = Struct1 {
        x: "a".to_owned(),
        y: Struct2 {
            z: "b".to_owned(),
        },
    };

    let mut visitor = Visitor;

    visit_pointer!(value.x, visitor);   // "a"
    visit_pointer!(value.y, visitor);   // Struct2 { z: "b" }
    visit_pointer!(value.y.z, visitor); // "b"
}

TODO

• function to create Pointer from str
• decide APIs
  • naming
    • types and methods in pointer module
    • rename valuable-derive to valuable-macro(s)? (because visit_pointer! macro is proc-macro)
• write docs
• add tests

[Keats]

Can there be a Pointer::from_str? When querying data at runtime on arbitrary paths, you can't build a macro.

[taiki-e]

@Keats Good point. It definitely makes sense to provide the ability to dynamically create a pointer from str.

[Keats]

@taiki-e ping me when it's ready it works for a str, I'll be happy to try it out!

[carllerche]

Looks great to me. I added an inline thought. If this works for @Keats though, I say we move forward.

[carllerche]

The challenge will be to avoid using get_by_name here in favor of using a field as that would be faster. I'm not sure how we could do it though.

Part of the challenge is that there is no guarantee that the type will be the same each time the pointer is used. It is possible that we could do some sort of caching for faster lookup, but we could punt.

[taiki-e]

I optimized the cases of slice index (32df15f) and structs (acf64f7).

I don't have any good ideas about optimizing other things.

[Keats]

@taiki-e is that still planned? Can I help?

[hawkw]

Overall, I'm definitely onboard with the concept! It would be nice if the documentation better described what this is for, though.

Also, I wonder if it would be worth adding a method like

pub trait Valuable {
   // ...

   fn get_pointer<'a>(&'a self, pointer: Pointer<'_>) -> Option<Value<'a>> {
      // ...
   }
}

that traverses a Pointer path and returns it as a Value if the pointed path exists in self?

This could probably have a default implementation (or be part of an extension trait, in order to make it totally impossible for users to override it).

[hawkw]

Another thought: in addition to having the macros (and possibly a Pointer::parse("x.y.z"), as suggested in #59 (comment)), I wonder if it would make sense to have a programmatic builder API for constructing pointer paths? Something like

/// `x[0].y`
let ptr = Pointer::builder()
   .field("x")
   .index(0)
   .field("y")
   .finish();

or similar?

But, that can probably be added in a follow-up branch as well.

[taiki-e]

Also, I wonder if it would be worth adding a method like

pub trait Valuable {
   // ...

   fn get_pointer<'a>(&'a self, pointer: Pointer<'_>) -> Option<Value<'a>> {
      // ...
   }
}

that traverses a Pointer path and returns it as a Value if the pointed path exists in self?

This could probably have a default implementation (or be part of an extension trait, in order to make it totally impossible for users to override it).

visit_pointer is a method for it: https://github.com/tokio-rs/valuable/pull/59/files#diff-a7abcaf3ded7efa976120acbbda5060e74513453ccbced80d88a443dc464110fR75-R78

[hawkw]

it might be nice to have a Display formatter that formats the Pointer as an expression, like the inputs to the visit_pointer! macro. but, we could add that in a follow-up PR.

[hawkw]

should we maybe also consider having a pointer! macro that returns a Pointer without actually trying to visit it? the use-case i have in mind is storing a pointer in a struct so that it can be use to traverse multiple Valuables.

[Keats]

+1 on that, in my case I would like to create the pointer when parsing the templates where I don't have the data structures yet