Description

While working on something else, I noticed that Value::follow_cell_path receives self.

While it would be ideal for the signature to be (&'a self, cell_path) -> &'a Value, that's not possible because:

1. Selecting a row from a list and field from a record can be done with a reference but selecting a column from a table requires creating a new list.
2. Value::Custom returns new Values when indexed.

So the signature becomes (&'a self, cell_path) -> Cow<'a, Value>.

Another complication that arises is, once a new Value is created, and it is further indexed, the current variable

1. can't be &'a Value, as the lifetime requirement means it can't refer to local variables
2. shouldn't be Cow<'a, Value>, as once it becomes an owned value, it can't be borrowed ever again, as current is derived from its previous value in further iterations. So once it's owned, it can't be indexed by reference, leading to more clones

We need current to have two possible lifetimes

1. 'out: references derived from &self
2. 'local: references derived from an owned value stored in a local variable

enum MultiLife<'out, 'local, T>
where
    'out: 'local,
    T: ?Sized,
{
    Out(&'out T),
    Local(&'local T),
}

With current: MultiLife<'out, '_, Value>, we can traverse values with minimal clones, and we can transform it to Cow<'out, Value> easily (MultiLife::Out -> Cow::Borrowed, MultiLife::Local -> Cow::Owned) to return it

User-Facing Changes

Tests + Formatting

After Submitting