Keypath for GetPath

[nicopap]

Consider the GetPath trait.

It accepts a &str as returns a &dyn Reflect (or a downcasted version).

Consider keypaths. Those are type-safe versions of the stringly-typed &str we pass to the GetPath methods…

What if, instead of accepting an &str, the GetPath methods had a different type parameter:

fn path<P: Path<Self>>(
    &'r self,
    path: &P,
) -> Result<&'r P::Target, ReflectPathError<'p>>

The implementation of the Path trait would look as follow:

trait Path<S> {
	type Target;
}

struct Keypath<SRC, TRG>(PhantomData<(SRC, TRG)>;

impl<SRC, TRG> Path<SRC> for Keypath<SRC, TRG> {
	type Target = TRG;
	fn get(&self, src: &Src) -> Option<&TRG> { … }
	fn get_mut(&self, src: &mut Src) -> Option<&mut TRG> { … }
}
impl<SRC: Reflect> Path<SRC> for str {
	type Target = dyn Reflect;

	fn get(&self, src: &Src) -> Option<&TRG> { 
		src.reflect_path(self).ok()
	}
	fn get_mut(&self, src: &mut Src) -> Option<&mut TRG> { 
		src.reflect_path_mut(self).ok()
	}
}

Now we have multiple ways to access fields, all perfectly type-safe. But the Keypath approach is much superior if you have awareness of the type at compile-time: basically the accessor will always be inlined, and you cannot construct an invalid Keypath.

---

What's the Keypath?

Poking at the internals of the keypath crate I find that a Keypath is just a Cow<'static, [PathComponent]>, with

pub enum PathComponent {
    Unnamed(usize),
    Named(&'static str),
    IndexInt(usize),
    IndexStr(&'static str),
}