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]

I think we can stick to a simple ternary operator for now.

[springcomp]

Ternary Conditional Expression

JEP	JEP-21
Author	Maxime Labelle
Status	draft
Created	13-05-2025

Abstract

This JEP introduces a new expression to support an it-then-else ternary operation.

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 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 conditional 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 conditional 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 conditional 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

Precedence

The ternary condition expression is a new infix operator that has a higher precedence than the | pipe expression and lower precedence than the || and && logical expressions. Thus the precedence of various expressions goes like this, from lowest to highest:

• | pipe expression
• … ? … : … ternary conditional expression
• || OR logical expression
• && AND logical expression

Compliance Tests

A new ternary.json test file will be added to the suite of 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" },

			{ "expression": "true || false ? foo : bar", "result": "foo" },
			{ "expression": "true && false ? foo : bar", "result": "bar" }
		]
	}
]

Alternatives

Although achieving the same result is possible within the current specification, the "array-wrapping" trick referred to in the motivation section is not user-friendly.

Other alternatives considered introducing a more general "switch-case-when-else" syntax but we feel that a ternary operator is so ubiquitous in most languages that it is worth introducing in the language. This does not preclude revisiting a more general syntax in the future.

Finally, we considered adding this feature as a function. Although this can be done today in most implementations that provide an extension point, we think a ternary operator is the most user-friendly least surprising way to include this feature.

History

Date	Description
2025-05-14	The proposal has been assigned number JEP-021
2025-05-16	Renamed "Ternary operation expression" to "Ternary conditional expression"
2025-05-16	Added mention of operator precedence and clarified with new compliance tests.

[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.

[gibson042]

Where would it sit in terms of operator precedence? Looking at https://jmespath.site/main/#spec-grammar , I see that this aspect of JMESPath is already underspecified (especially w.r.t. arithmetic and comparison), but it gets far worse with each new infix operator. Consider some examples:

• $a == $b ? $x : $y: ($a == $b) ? $x : $y vs. $a == ($b ? $x : $y)
• $a || $b ? $x : $y: ($a || $b) ? $x : $y vs. $a || ($b ? $x : $y)
• $a + $b ? $x : $y: ($a + $b) ? $x : $y vs. $a + ($b ? $x : $y)

[springcomp]

That is a really good point.

I’m not sure how to best surface this knowledge but I do think there are some mentions of this in various JEPs.

The spec has the following text:

"In addition to the grammar, there is the following token precedence that goes from weakest to tightest binding:

• pipe: |
• or: ||
• and: &&
• unary not: !
• rbracket: ]

"

This comes from:

• JEP-004 Pipes
• JEP-009 Improved filters
• From the JEP-007 Filter expressions accompanying filters.json compliance tests, we also know than comparison operators have higher precedence that logical operator.

The JEP-016 Arithmetic operators proposal includes the following text:

"Arithmetic operations adhere to the usual precedence rules, from lowest to highest:

• – subtraction operator and + addition operator
• / or ÷ division, * or × multiplication, % modulo and // integer division operators

In the absence of parentheses, operators of the same level of precedence are evaluated from left to right. Arithmetic operators have higher precedence than comparison operators and lower precedence than the . ‟dot‟ sub-expression token separator."

I will make sure to include a mention for precedence of ternary operator. That is actually quite interesting because, in our current Python and TypeScript prototypes, the ternary operator has different precedence 😏.

• In Python, I assumed a higher precedence than the | pipe and lower precedence than the logical expressions.
• In TypeScript, @cawalch assumed a higher precedence than the logical expressions, and a lower precedence than the comparison expressions.

Interestingly, this means that current compliance tests are not sufficient to leave the ambiguity.

@gibson042 What do you think would be the most reasonable choice ?

[gibson042]

I think the most reasonable choice would be to sidestep the problem by avoiding a new infix operator, which avoids comprehensibility issues for humans and divergence opportunities for implementations.

But if ternary does remain infix, then I think it should be lower precedence than the logical operators ($a || $b ? $x : $y reads to me like ($a || $b) ? $x : $y) and—although my intuition here is much weaker—higher precedence than | pipe (such that $a | $b ? $x : $y is equivalent to $a | ($b ? $x : $y)) just to keep it grouped with the logical operators.

[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" }
		]
	}
]