Dynamic object subscription

[innovate-invent]

Currently there is no way to dynamically subscript an object. This is important when the identifier is only known at runtime, or an expression is being repeated over multiple identifiers. I propose we expand the bracket-specifier syntax to accept strings when applied to an object:

bracket-specifier = "[" (number / slice-expression / expression) "]"

example:

search({important: a, values: {a: 1, b: 2, c: 3}}, values[important]) -> 1

[springcomp]

Do you mean identifiers, rather than strings here?

[springcomp]

Revisiting this discussion, can you clarify the exact syntax you expect?

Given the initial JSON document that you are referring to:

{ "important": "a", "values": [ "a": 1, "b": 2, "c": 3 ] }

You are after something like this:

search( values[`"a`"] , … ) -> 1 where "a" is a literal JSON string. Or
search( values['a'], …) -> 1 where 'a' is a raw-string.

Which, I think, is not intuitive. Maybe someone would expect something like this instead:

search( values[a], … ) -> 1 where a is an identifier.

Now, what you are after is being able to somehow dereference or evaluate the value of an identifier which, if it is a string-type, could be used as an identifier in the resulting expression. Something like the following syntax, using a hypothetical eval() function:

• search( important, … ) -> "a"
• search( eval(important), … ) -> null. This being equivalent to search( a, … ) -> null.
• search( values[eval(important)], … ) -> 1, This being equivalent to search( values[a], …) -> 1.

Caveat: I seem to remember that introducing an eval() function might open a whole new can of worms…

Seems to me this discussion is actually mixing two proposals.

[innovate-invent]

sorry, this was a stupid mistake when I wrote this. The grammar I meant to propose was:

bracket-specifier = "[" (number / slice-expression / expression) "]"

Where the expression must resolve to a string (or number).

in my example "important" is an identifier as the expression that references a string value ("a") from the current context.
search(values[important], {important: a, values: {a: 1, b: 2, c: 3}} ) -> 1
This is equivalent to search(values['a'], {important: a, values: {a: 1, b: 2, c: 3}} ) -> 1

This would also allow search(values[important], {important: 2, values: [3, 4, 5]}) -> 5

[springcomp]

Wearing my implementor hat here, seems to me that evaluating the following expression:

search( values[important], … ) -> 1

would be non trivial and involve some recursive evaluations or multiple passes during evaluation.

[innovate-invent]

if the "values" identifier is available, what would prevent looking up the value of the "important" identifier at that time?

er, right, the context within the brackets is the value of "values" making "important" unavailable to the expression. I suppose I mostly envisioned this being used with let().

search(let({important: a}, &values[important]), {values: {a: 1, b: 2, c: 3}} ) -> 1

search(let({values: values}, &important[*].values[@]), {important: [c, b], values: {a: 1, b: 2, c: 3}} ) -> [3, 2]

Basically, how do we deal with the situation where the data points at itself and we want to actually resolve that reference in the path?

[innovate-invent]

On second thought, the context within the bracket specifier is currently undefined as it is not a filter expression. We could simply define that the context of the subscripted item is inherited within the bracket specifier.

[springcomp]

This feature can now be promoted as it is made easier with the let-expression.