I take the example in the caveat section as a bug fix 🫠

Maybe even $val.foo should return [A, null]?

Update: there're some problems in the cell_path completion for lists like [{foo: A}, {baz: B}]. I'll fix it up when we come to a conclusion of what $val.foo should behave like.

I know you've tried different inputs, but can we do some fuzzy testing on this? Maybe I don't fully understand how cell paths are evaluated. I'm just concerned we might break something in odd cases.

I take the example in the caveat section as a bug fix 🫠

Maybe even $val.foo should return [A, null]?

Update: there're some problems in the cell_path completion for lists like [{foo: A}, {baz: B}]. I'll fix it up when we come to a conclusion of what $val.foo should behave like.

hmm, I don't think this is correct. you can already get [A, null] with $val.foo?, which case $val.foo?.0 works. i think the current behavior is correct, and the behavior from this PR would be incorrect?

My hunch is that reordering beyond moving one level (which would suffice for correct table semantics) would be overly permissive and could lead to surprises on input data that is not conforming to the schema that was initially expected.

Again NO performance tag without at least a minimal attempt at showing a benchmark (doesn't have to be an exhaustive and fair suite but show with an example and don't claim)

@Bahex where are we at on this? Should we land it?

@fdncred

1. We need to reach consensus about whether this behavior is acceptable/desirable.

   let val = [{foo: A}, {baz: B}]
   $val
   # => ╭───┬─────┬─────╮
   # => │ # │ foo │ baz │
   # => ├───┼─────┼─────┤
   # => │ 0 │ A   │ ❎  │
   # => │ 1 │ ❎  │ B   │
   # => ╰───┴─────┴─────╯
   
   $val.foo
   # throws an error as expected
   
   $val.foo.0
   # before this PR, this also throws an error
   # but due to reordering the access to `$val.0.foo`
   # this works without issue and returns `A`

   Whether this is a good thing or bad isn't really clear 🤷

2. Additional tests to catch any possible regressions (I would like some help with coming up with or generating test cases)

3. Benchmarks

ok, we should put it on the agenda for a meeting so we can discuss it. I don't think you'll get much attention here.

After rebasing the branch on main, I ran some benchmarks comparing against main in both profiles, using both a small and a moderately big sample.

let binaries = [
	"./main-debug"
	"./main-release"
	"./follow-cellpath-reorder-debug"
	"./follow-cellpath-reorder-release"
]

let benchmark_src = r#'
	use std/bench

	let small = seq 1 4 | wrap a
	let big = seq 1 100 | each {|i| {e: {d: {c: {b: {a: $in}}}}} }

	bench --rounds 1000 ...[
		{ $big.e.d.c.b.a.42 }
		{ $big.42.e.d.c.b.a }
		{ $small.a.1 }
		{ $small.1.a }
	]
	| update code { ansi strip }
	| save -f ($nu.current-exe)-tests.nuon
'#

$binaries | each {|bin| ^$bin -n -c $benchmark_src} | ignore

• total_ratio is ratio among all the results
• each benchmark contains a manually reordered cell-path access for contrast

follow-cellpath-reorder-debug-tests.nuon

follow-cellpath-reorder-release-tests.nuon

main-debug-tests.nuon

main-release-tests.nuon

As #16028 is merged now, we can add an option for the reordering.