Consistent Variadic Comparison Operators in JSONLogic

[codetiger]

Background

JSONLogic includes comparison operators (>, >=, <, <=). Current implementations are inconsistent:

• Original spec (jsonlogic.com): Accepts 3 arguments but 3rd argument only used in < and <=
• Some libraries: Only support 2 arguments
• Other libraries: Support 3 arguments
• Some implementations: Support variadic arguments

Proposal

This proposal seeks to standardize comparison operator behavior:

1. All comparison operators should support variadic arguments
2. Arguments are compared sequentially left-to-right
3. Returns true only if the entire chain of comparisons is true
4. Minimum 2 arguments required
5. No artificial limit on maximum arguments

Examples

{"<": [1, 2, 3]}           // true  (1 < 2 AND 2 < 3)
{"<": [1, 2, 2]}           // false (1 < 2 but 2 ≮ 2)
{"<=": [1, 2, 2, 3]}       // true  (1 ≤ 2 AND 2 ≤ 2 AND 2 ≤ 3)
{">": [5, 4, 3, 2, 1]}     // true  (5 > 4 > 3 > 2 > 1)
{">=": [5, 5, 4, 3]}       // true  (5 ≥ 5 AND 5 ≥ 4 AND 4 ≥ 3)

Benefits

1. Consistent behavior across operators
2. Enables natural sequence comparisons
3. Supports ascending/descending checks
4. More flexible than 2 or 3 argument limit
5. Matches mathematical notation

Test Cases

[
    "# Less Than (<) Operator Tests",
    
    "# Two Argument Tests",
    {
      "description": "Basic numbers comparison",
      "rule": {"<": [1, 2]},
      "data": null,
      "result": true
    },
    {
      "description": "Equal numbers",
      "rule": {"<": [2, 2]},
      "data": null,
      "result": false
    },
    {
      "description": "Reverse order numbers",
      "rule": {"<": [2, 1]},
      "data": null,
      "result": false
    },
    
    "# Three Argument Tests",
    {
      "description": "Three ascending numbers",
      "rule": {"<": [1, 2, 3]},
      "data": null,
      "result": true
    },
    {
      "description": "Three non-ascending numbers",
      "rule": {"<": [1, 3, 2]},
      "data": null,
      "result": false
    },
    
    "# Multiple Argument Tests",
    {
      "description": "Many ascending numbers",
      "rule": {"<": [1, 2, 3, 4, 5]},
      "data": null,
      "result": true
    },
    {
      "description": "Break in sequence",
      "rule": {"<": [1, 2, 2, 3]},
      "data": null,
      "result": false
    },
    
    "# Type Coercion Tests",
    {
      "description": "String numbers",
      "rule": {"<": ["1", "2"]},
      "data": null,
      "result": true
    },
    {
      "description": "Mixed types",
      "rule": {"<": [1, "2", 3]},
      "data": null,
      "result": true
    },
    {
      "description": "Boolean values",
      "rule": {"<": [false, true]},
      "data": null,
      "result": true
    },
    
    "# Data Context Tests",
    {
      "description": "Values from data",
      "rule": {"<": [{"var": "x"}, {"var": "y"}]},
      "data": {"x": 1, "y": 2},
      "result": true
    },
    {
      "description": "Mixed literal and data",
      "rule": {"<": [{"var": "x"}, 5, {"var": "y"}]},
      "data": {"x": 1, "y": 10},
      "result": true
    },
    
    "# Edge Cases",
    {
      "description": "Single argument",
      "rule": {"<": [1]},
      "data": null,
      "result": false
    },
    {
      "description": "Empty array",
      "rule": {"<": []},
      "data": null,
      "result": false
    },
    {
      "description": "Null values",
      "rule": {"<": [null, 1]},
      "data": null,
      "result": true
    },
    {
      "description": "Undefined var",
      "rule": {"<": [{"var": "missing"}, 1]},
      "data": {},
      "result": true
    },

    "# Less Than or Equal (<=) Operator Tests",
    
    "# Two Argument Tests",
    {
        "description": "Basic numbers comparison",
        "rule": {"<=": [1, 2]},
        "data": null,
        "result": true
    },
    {
        "description": "Equal numbers",
        "rule": {"<=": [2, 2]},
        "data": null,
        "result": true
    },
    {
        "description": "Reverse order numbers",
        "rule": {"<=": [2, 1]},
        "data": null,
        "result": false
    },
    
    "# Three Argument Tests",
    {
        "description": "Three ascending numbers",
        "rule": {"<=": [1, 2, 3]},
        "data": null,
        "result": true
    },
    {
        "description": "Three non-ascending numbers",
        "rule": {"<=": [1, 3, 2]},
        "data": null,
        "result": false
    },
    
    "# Multiple Argument Tests",
    {
        "description": "Many ascending numbers",
        "rule": {"<=": [1, 2, 3, 4, 5]},
        "data": null,
        "result": true
    },
    {
        "description": "Break in sequence",
        "rule": {"<=": [1, 2, 2, 3]},
        "data": null,
        "result": true
    },
    
    "# Type Coercion Tests",
    {
        "description": "String numbers",
        "rule": {"<=": ["1", "2"]},
        "data": null,
        "result": true
    },
    {
        "description": "Mixed types",
        "rule": {"<=": [1, "2", 3]},
        "data": null,
        "result": true
    },
    {
        "description": "Boolean values",
        "rule": {"<=": [false, true]},
        "data": null,
        "result": true
    },
    
    "# Data Context Tests",
    {
        "description": "Values from data",
        "rule": {"<=": [{"var": "x"}, {"var": "y"}]},
        "data": {"x": 1, "y": 2},
        "result": true
    },
    {
        "description": "Mixed literal and data",
        "rule": {"<=": [{"var": "x"}, 5, {"var": "y"}]},
        "data": {"x": 1, "y": 10},
        "result": true
    },
    
    "# Edge Cases",
    {
        "description": "Single argument",
        "rule": {"<=": [1]},
        "data": null,
        "result": false
    },
    {
        "description": "Empty array",
        "rule": {"<=": []},
        "data": null,
        "result": false
    },
    {
        "description": "Null values",
        "rule": {"<=": [null, 1]},
        "data": null,
        "result": true
    },
    {
        "description": "Undefined var",
        "rule": {"<=": [{"var": "missing"}, 1]},
        "data": {},
        "result": true
    },

    "# Greater Than (>) Operator Tests",
    
    "# Two Argument Tests",
    {
        "description": "Basic numbers comparison",
        "rule": {">": [2, 1]},
        "data": null,
        "result": true
    },
    {
        "description": "Equal numbers",
        "rule": {">": [2, 2]},
        "data": null,
        "result": false
    },
    {
        "description": "Reverse order numbers",
        "rule": {">": [1, 2]},
        "data": null,
        "result": false
    },
    
    "# Three Argument Tests",
    {
        "description": "Three descending numbers",
        "rule": {">": [3, 2, 1]},
        "data": null,
        "result": true
    },
    {
        "description": "Three non-descending numbers",
        "rule": {">": [3, 1, 2]},
        "data": null,
        "result": false
    },
    
    "# Multiple Argument Tests",
    {
        "description": "Many descending numbers",
        "rule": {">": [5, 4, 3, 2, 1]},
        "data": null,
        "result": true
    },
    {
        "description": "Break in sequence",
        "rule": {">": [3, 2, 2, 1]},
        "data": null,
        "result": false
    },
    
    "# Type Coercion Tests",
    {
        "description": "String numbers",
        "rule": {">": ["2", "1"]},
        "data": null,
        "result": true
    },
    {
        "description": "Mixed types",
        "rule": {">": [3, "2", 1]},
        "data": null,
        "result": true
    },
    {
        "description": "Boolean values",
        "rule": {">": [true, false]},
        "data": null,
        "result": true
    },
    
    "# Data Context Tests",
    {
        "description": "Values from data",
        "rule": {">": [{"var": "y"}, {"var": "x"}]},
        "data": {"x": 1, "y": 2},
        "result": true
    },
    {
        "description": "Mixed literal and data",
        "rule": {">": [{"var": "y"}, 5, {"var": "x"}]},
        "data": {"x": 1, "y": 10},
        "result": true
    },
    
    "# Edge Cases",
    {
        "description": "Single argument",
        "rule": {">": [1]},
        "data": null,
        "result": false
    },
    {
        "description": "Empty array",
        "rule": {">": []},
        "data": null,
        "result": false
    },
    {
        "description": "Null values",
        "rule": {">": [1, null]},
        "data": null,
        "result": true
    },
    {
        "description": "Undefined var",
        "rule": {">": [1, {"var": "missing"}]},
        "data": {},
        "result": true
    },

    "# Greater Than or Equal (>=) Operator Tests",
    
    "# Two Argument Tests",
    {
        "description": "Basic numbers comparison",
        "rule": {">=": [2, 1]},
        "data": null,
        "result": true
    },
    {
        "description": "Equal numbers",
        "rule": {">=": [2, 2]},
        "data": null,
        "result": true
    },
    {
        "description": "Reverse order numbers",
        "rule": {">=": [1, 2]},
        "data": null,
        "result": false
    },
    
    "# Three Argument Tests",
    {
        "description": "Three descending numbers",
        "rule": {">=": [3, 2, 1]},
        "data": null,
        "result": true
    },
    {
        "description": "Three non-descending numbers",
        "rule": {">=": [3, 1, 2]},
        "data": null,
        "result": false
    },
    
    "# Multiple Argument Tests",
    {
        "description": "Many descending numbers",
        "rule": {">=": [5, 4, 3, 2, 1]},
        "data": null,
        "result": true
    },
    {
        "description": "Break in sequence",
        "rule": {">=": [3, 2, 2, 1]},
        "data": null,
        "result": true
    },
    
    "# Type Coercion Tests",
    {
        "description": "String numbers",
        "rule": {">=": ["2", "1"]},
        "data": null,
        "result": true
    },
    {
        "description": "Mixed types",
        "rule": {">=": [3, "2", 1]},
        "data": null,
        "result": true
    },
    {
        "description": "Boolean values",
        "rule": {">=": [true, false]},
        "data": null,
        "result": true
    },
    
    "# Data Context Tests",
    {
        "description": "Values from data",
        "rule": {">=": [{"var": "y"}, {"var": "x"}]},
        "data": {"x": 1, "y": 2},
        "result": true
    },
    {
        "description": "Mixed literal and data",
        "rule": {">=": [{"var": "y"}, 5, {"var": "x"}]},
        "data": {"x": 1, "y": 10},
        "result": true
    },
    
    "# Edge Cases",
    {
        "description": "Single argument",
        "rule": {">=": [1]},
        "data": null,
        "result": false
    },
    {
        "description": "Empty array",
        "rule": {">=": []},
        "data": null,
        "result": false
    },
    {
        "description": "Null values",
        "rule": {">=": [1, null]},
        "data": null,
        "result": true
    },
    {
        "description": "Undefined var",
        "rule": {">=": [1, {"var": "missing"}]},
        "data": {},
        "result": true
    },
    
    "# Additional Sequential Comparison Tests",
    {
        "description": "Mixed equality in ascending sequence",
        "rule": {"<": [1, 2, 2, 2, 3]},
        "data": null,
        "result": false
    },
    {
        "description": "Mixed equality in descending sequence",
        "rule": {">": [3, 2, 2, 2, 1]},
        "data": null,
        "result": false
    },
    
    "# Extended Type Coercion Tests",
    {
        "description": "String and number mixed sequence",
        "rule": {"<=": ["1", 2, "2", 3, "3"]},
        "data": null,
        "result": true
    },
    {
        "description": "Complex mixed types",
        "rule": {">=": [true, 1, "0", false]},
        "data": null,
        "result": true
    },
    
    "# Short-Circuit Tests",
    {
        "description": "Early failure in sequence",
        "rule": {"<": [1, 3, 2, 4, 5]},
        "data": null,
        "result": false
    },
    {
        "description": "Late failure in sequence",
        "rule": {">": [5, 4, 3, 3, 2]},
        "data": null,
        "result": false
    }
]

Implementation Guidelines

1. Process arguments left to right
2. Short-circuit on first comparison failure
3. Return true only if all comparisons succeed
4. Maintain type coercion rules from core spec

[TotalTechGeek]

Heya -- Since var is not in Core, let's try to use val for defining test cases for proposals.

[gregsdennis]

Ideally, test cases need to be "pure" in that they should only test one feature (just < as opposed to "< with val"). I wonder if it makes sense to have two sections of tests, kind of a "unit test vs integration test" approach.

• Unit tests would verify the function of the operator with discrete values. All the different ways the operator can function (i.e. all of the variants above) could be tested thoroughly and simply
• Then integration tests would verify that the operator works in various contexts (as an argument for other Logic and accepting other Logic as operators).

This is probably a conversation for another proposal, but there's context here, so I thought I'd bring it up.

I think the above list of tests just needs to show the "unit" variety, and the "integration" variety could be implied unless explicitly stated. This would apply to all proposals.

[TotalTechGeek]

I think I agree with that; I tried to arrange my file structure that way in the arithmetic proposal (the val test is as the bottom, most of the tests don't involve data).

I do think for certain tests, it's might be easier to do so with val to allow you to pass in an object as an operand with no ambiguity.

[TotalTechGeek]

I'm putting this on hold for additional test cases + the error proposal to go through, if that's alright @codetiger.

I'll try to contribute some additional cases 😄

[codetiger]

I've updated the proposal with test cases for all comparison operators and some additional cases. Please review and share your feedback.

[codetiger]

Am ok, to put this on hold, in the meantime, I'll keep improving the proposal.

[TotalTechGeek]

Hold should be released soon with the error proposal through 😄

I'll try to recommend some test cases

[TotalTechGeek]

Been talking a bit with @codetiger over this,

This isn't fully organized at the time of linking this, but I've come up with the following set of tests:

> / < / >= / <=:

https://github.com/json-logic/json-logic-engine/blob/master/suites/comparison/greaterThan.json
https://github.com/json-logic/json-logic-engine/blob/master/suites/comparison/lessThan.json
https://github.com/json-logic/json-logic-engine/blob/master/suites/comparison/greaterThanEquals.json
https://github.com/json-logic/json-logic-engine/blob/master/suites/comparison/lessThanEquals.json

== / === / != / !==

https://github.com/json-logic/json-logic-engine/blob/master/suites/comparison/softEquals.json
https://github.com/json-logic/json-logic-engine/blob/master/suites/comparison/strictEquals.json
https://github.com/json-logic/json-logic-engine/blob/master/suites/comparison/softNotEquals.json
https://github.com/json-logic/json-logic-engine/blob/master/suites/comparison/strictNotEquals.json

Some things that we explored defining:

• Comparison Operators require at minimum two arguments, anything less will result in Invalid Arguments.
• The comparison operator must receive an arguments array directly (this nuance does not matter until we decide upon post or pre coercion of array arguments; don't worry about this)
• String vs Non-String comparison should throw NaN if the numeric coercion fails.
• String vs String comparison works via Ordinal.
• Bools, Numbers, Strings, Null, Arrays and Objects follow the coercion convention as defined in the Arithmetic proposal.
• All non-string comparisons coerce to number.
• Arrays and Objects inputs throw NaN in the comparsion operators that coerce, similar to the arithmetic operators.
• All of the non-strict comparison operators (< / <= / > / >= / == / !=) use the coercion rules.
• The strict comparison operators do not coerce (!== / ===)

Some notes about the proposed tests:

• We are using throw as a way to check for lazy evaluation.
• null == 0 is defined as true, which is true for json-logic-php, but not json-logic-js. I feel JS handles this in a weird way; I don't like it.
• These aren't quite organized how I'd like them, I'm kinda working out some of the edge cases & handling implementation changes as I go.

[TotalTechGeek]

As a note, this isn't final, we may wish to add additional tests to this suite, but I'm throwing this in here to recommend that these be added to the proposal / ask for feedback

[TotalTechGeek]

One unknown to explore:

With strict equality, should we support objects and arrays?

Allowing for something like:

{ "===": [{ "val": "a" }, { "val": "b"}] }

Where data could be:

{ "a": {}, b: {} } // Case A
{ "a": { "A": 1 }, "b": { "A": 1 } } // Case B
{ "a": { "A": { "B": 1 } }, "b": { "A": { "B": 1 } } } // Case C

I don't have strong leanings for or against this.

[gregsdennis]

I'm fine with all the strict equality, but we need to completely nail down coercion. It's woefully underspecified in the original, relying instead on the underlying language, and that isn't interoperable across languages. It was the most frustrating part of implementing in c#, which a very strongly-typed language.

[gregsdennis]

Are we going to have strict inequalities, e.g. <==?

[TotalTechGeek]

I'd be happy to pitch a more complete coercion table;

I actually did diverge from the language's implementation (JS's) to allow 0 == null, which I feel is more consistent with 0 <= null and +null.

Which aspects would you like to be fleshed out more though?

Right now, the operators only provide numeric and string comparisons,

For Numeric Coercion,

true = 1
false = 0
null = 0

Arrays throw NaN
Objects throw NaN

Strings are interpreted as JSON Numbers* or NaN; Empty String is 0.

Essentially consistent with the Arithmetic proposal.

Any non string-string comparison uses numeric comparison for the loose operators.

---

I wasn't intending to add strict inequality operators, but I'm not inherently against it.

I think the utility of them kinda depends on us deciding if objects / arrays can be compared in strict...

Like, what would it mean to compare { "a": 1 } <== { "b": 1 }?

Because I think that's not intuitive, I'd probably want to avoid allowing object / array operands,

And at that point, I think the most likely real world use for the strict inequality operator is to handle the nulls differently; perhaps on occasion preventing string and number comparisons, but most likely a null check.

How do you feel about it?

I'm personally a +0 for strict inequalities. If we want them, I'd kinda prefer they be a separate proposal.