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