Consider implementing a "true" ternary operator

[springcomp]

Most languages do have a ternary operator that is akin to an if-then-else syntax as a single statement.
For instance, many languages do have the following syntax:

<condition> ? <true-result> : <false-result>

Unfortunately JMESPath does not have a ternary operator.
The closest approximation suffers from a limitation that makes it not really a true ternary operator.

Please, consider introducing ternary operator to the language.

[gibson042]

Although I think adding true-ternary syntax (or even more general if/else/switch/case/etc.) is worthwhile, it is actually possible to achieve the functionality right now with an array-wrapping trick.

(`false` && [`0`] || [`null`])[0] 
// => `null`

(`true` && [`0`] || [`null`])[0] 
// => `0`

[springcomp]

@gibson042 are you saying 'it is probably worth' or are you advising against it ?

[gibson042]

Clarified; this is a gap worth addressing.

[springcomp]

What would be a more general syntax for a switch/case expression in your mind.
Would it take the following form?

x switch
a : <a-result>
b : <b-result>
_ : <fall-back-result>

Using a switch contextual keyword and, maybe, a _ discard token ?

[gibson042]

Hmm, there are lots of possibilities—most significantly differentiated by matching an input expression against possible values (like you have there) vs. arbitrary expressions to be checked in order (think SQL CASE $input WHEN $a THEN 1 WHEN $b THEN 2 ELSE 0 END vs. CASE WHEN $input = $a THEN 1 WHEN $input = $b THEN 2 ELSE 0 END, with the latter being more general but also more verbose). jq accomplishes this with if-then-else-end, which falls into the second pattern. JMESPath is less imperative, so that's probably not a good fit, but I do like the generality for cases like partitioning a value into one of N intervals. I guess my first inclination would be to just follow SQL's lead here, if necessary mapped to something similar that doesn't create parsing or human comprehension ambiguities (but I don't think it is, because neither case when nor case $expression when are currently valid).

[springcomp]

Ternary Operator Expression

This is a work-in-progress draft for an upcoming proposal to introduce a ternary operator (or expression) to the language. Please, use this discussion page to discuss the merits and other finer points about this draft.

Abstract

Motivation

Most languages do have a ternary operator that is akin to an if-then-else syntax as a single statement.
For instance, many languages do have the following syntax:

<condition> ? <true-result> : <false-result>

While JMESPath does not have a ternary operator, the closest approximation using an expression like ( x || y ) && z unfortunately suffers from a limitation that makes it not really a true ternary operator. Specifically, if both x and y are false, the expression still falls back to evaluating z.

More complicated, 'object-wrapping' expressions are possible such as (x && [y] || [z])[0]. Unfortunately, these appear to be more like a trick and are not user-friendly, especially for newcomers to the language.

For those reasons, we propose introducing a true ternary operator expression to the language.

Grammar Changes

The following updates to the grammar support a ternary operation:

expression =/ ternary-expression

ternary-expression = expression "?" expression ":" expression

A ternary-expression (short for ternary operator expression) is an expression taking the following form:

condition ? true-expression : false-expression

Where condition, true-expression and false-expression are JMESPath expressions.
A ternary operator expression will evaluate to either its "true" expression or its "false" expression.
If the evaluation of the condition is not false, then the "true" expression is evaluated and used as the return value.
Otherwise, the "false" epression is evaluated and used as the return value.

The following values are considered to be false values in JMESPath:

• The boolean false JSON value
• The null JSON value
• An empty "" JSON string
• An empty {} JSON objects
• An empty [] JSON array

Expressions within a ternary operator expression are evaluated using a right-associative reading.
This means that a chain of ternary expression can be expressed without parentheses:

a ? b :
c ? d :
e

// TODO discuss precedence
// TODO expression false ? foo | bar @ : bar should be evaluated as false ? ( foo | bar | @ ) : bar
// TODO expression foo ? bar ? baz : qux : quux should be evaluated as foo ? ( bar ? baz : qux ) : quux
**// Current POC: https://github.com/jmespath-community/python-jmespath/tree/feature/ternary-operator

Compliance Tests

Alternatives

// TODO: this page discussioncomment-11824335
// TODO: wiki

[springcomp]

Shall this be called:

• Ternary operator?
• Ternary operator expression?
• Ternary expression?
• Ternary conditional expression?
• Ternary conditional?

I quite like the last Ternary conditional moniker.

[springcomp]

Compliance Tests

[
	{
		"given": {
			"true": true,
			"false": false,
			"foo": "foo",
			"bar": "bar",
			"baz": "baz",
			"qux": "qux",
			"quux": "quux"
		},
		"cases": [
			{ "expression": "true ? foo : bar", "result": "foo" },
			{ "expression": "false ? foo : bar", "result": "bar" },
			{ "expression": "`null` ? foo : bar", "result": "bar" },
			{ "expression": "`[]` ? foo : bar", "result": "bar" },
			{ "expression": "`{}` ? foo : bar", "result": "bar" },
			{ "expression": "'' ? foo : bar", "result": "bar" },
			{ "expression": "false ? foo | bar | @ : baz", "result": "baz" },
			{ "expression": "foo ? bar ? baz : qux : quux", "result": "baz" }
		]
	}
]