Problems with arrays stored in vars

[sampaio96]

jsonLogic.apply(
  {"+": {"var": "array"}}, // Logic
  {"array": [1,2,3]}   // Data
);

returns 1 instead of 6

jsonLogic.apply(
  {"max": {"var": "array"}}, // Logic
  {"array": [1,2,3]}   // Data
);

returns null
(Already pointed out in #19 (comment))

Tested on jsonlogic.com.

[TotalTechGeek]

Hey there, this is related to the implicit sugaring that JSON Logic performs,

Some implementations have adopted a different approach, (essentially sugaring after eval, rather than before), but this is a behavior we may end up standardizing in JSON Logic Core.

See discussion here: https://github.com/orgs/json-logic/discussions/28
And: https://github.com/orgs/json-logic/discussions/2

Similar issue here:
jwadhams/json-logic-js#54

At the time, Jeremy considered this a bug, though at different points in time I believe he's felt differently.

What you're requesting here is essentially an "implicit application" or "chaining of logic", as you're implicitly applying the output of one operator to another. This may be something implementations support in the future.

[TotalTechGeek]

This is one of the differences between json-logic-engine and json-logic-js

There are also a few other implementations that handle it w/ implicit apply support. One of the hopes of the JSON Logic Core project is to unify this behavior across all implementations.

[TotalTechGeek]

@sampaio96

An update,

The good news: The proposal for removing sugaring & establishing the chaining convention passed our voting procedures.

The meh news: It may take time for this to be reflected in implementations, and we need to go through the process of defining which operators "chain".

A few implementations support chaining currently, namely the json-logic-engine and datalogic-rs implementations (there are a few others, but I don't quite have a comprehensive list).

But we will be trying to update all of the implementations with this capability.

[TotalTechGeek]

Hey, following up on this:

I've introduced a new proposal to codify these specific operators into the test suite with chaining support -
https://github.com/orgs/json-logic/discussions/34

For example, for max:

    {
        "description": "Max can chain with other operators",
        "rule": { "max": { "val": "arr" } },
        "data": { "arr": [1, 2, 3] },
        "result": 3
    },
    {
        "description": "Max can chain with other operators (2)",
        "rule": { "max": { "val": "arr" } },
        "data": { "arr": [6, 5, 4] },
        "result": 6
    },
    {
        "description": "Max can chain with other operators (3)",
        "rule": { "max": { "merge": [[1, 2], 3, [4, 5]] } },
        "data": null,
        "result": 5
    },
    {
        "description": "Max can chain with other operators (4)",
        "rule": { "max": { "map": [{ "val": "people" }, { "val": "age" }] } },
        "data": {
            "people": [
                { "name": "John", "age": 30 },
                { "name": "Jane", "age": 25 },
                { "name": "Bob", "age": 35 },
                { "name": "Alice", "age": 28 }
            ]
        },
        "result": 35
    }

In case you're wondering "What on earth is val", at a single layer of depth & no second argument, it's exactly the same as var.

We decided to move away from var in JSON Logic Core, which is explored a bit here: https://github.com/orgs/json-logic/discussions/18