Proposal - If / And / Or

[TotalTechGeek]

Background

This proposal is meant to codify tests and boundaries for some of the notable control structures in JSON Logic, namely if, or and and.

Each of these operators are "lazy" (with full control of their traversal) and short circuit without evaluating unnecessary branches.

Proposal

Most of the test cases come from tests.json, with some additional checks thrown in.

Some notable additions:

• Non-array arguments for these operators throw. No sugaring takes place. Implicit application is intentionally being avoided here and also trying to prevent ambiguity (like, a string could be treated like an array)
• The tests try to check for proper short circuiting / traversal with throw.

Tests

if

[
    "Boolean checks",
    {
        "description": "true is true, and uses the then",
        "rule": { "if": [true, "apple", "banana"] },
        "data": null,
        "result": "apple"
    },
    {
        "description": "false is false, and uses the fallback",
        "rule": { "if": [false, "apple", "banana"] },
        "data": null,
        "result": "banana"
    },
    "Null check",
    {
        "description": "null is falsy",
        "rule": { "if": [null, "apple", "banana"] },
        "data": null,
        "result": "banana"
    },
    "Object checks",
    {
        "description": "Empty object is falsy.",
        "rule": { "if": [{}, "apple", "banana"] },
        "data": null,
        "result": "banana"
    },
    {
        "description": "Objects are truthy, with keys defined",
        "rule": { "if": [{ "val": [] }, "apple", "banana"] },
        "data": { "some": "value" },
        "result": "apple"
    },
    "Array checks",
    {
        "description": "Empty array is falsy",
        "rule": { "if": [[], "apple", "banana"] },
        "data": null,
        "result": "banana"
    },
    {
        "description": "Array with single element is truthy",
        "rule": { "if": [[1], "apple", "banana" ] },
        "data": null,
        "result": "apple"
    },
    {
        "description": "Array with multiple elements is truthy",
        "rule": { "if": [[1, 2, 3, 4], "apple", "banana" ] },
        "data": null,
        "result": "apple"
    },
    "String checks",
    {
        "description": "Empty string is falsy",
        "rule": { "if": ["", "apple", "banana"] },
        "data": null,
        "result": "banana"
    },
    {
        "description": "Any non-empty string is truthy",
        "rule": { "if": ["zucchini", "apple", "banana"] },
        "data": null,
        "result": "apple"
    },
    {
        "description": "Any non-empty string is truthy, even 0",
        "rule": { "if": ["0", "apple", "banana"] },
        "data": null,
        "result": "apple"
    },
    "Too few arguments",
    { 
        "description": "No arguments is just null.", 
        "rule": { "if": [] }, 
        "data": null, 
        "result": null 
    },
    {
        "description": "If no 'then' is defined, it should return the first argument (true)",
        "rule": { "if": [true] },
        "data": null,
        "result": true
    },
    {
        "description": "If no 'then' is defined, it should return the first argument (false)",
        "rule": { "if": [false] },
        "data": null,
        "result": false
    },
    {
        "description": "If no 'then' is defined, it should return the first argument (apple string)",
        "rule": { "if": ["apple"] },
        "data": null,
        "result": "apple"
    },
    {
        "description": "When truthy, it'll return the 'then' even if no fallback is defined.",
        "rule": { "if": [true, "apple"] },
        "data": null,
        "result": "apple"
    },
    {
        "description": "When falsy, it'll return null if the fallback is not defined, even if the 'then' is defined.",
        "rule": { "if": [false, "apple"] },
        "data": null,
        "result": null
    },
    "Variadic Tests",
    {
        "description": "Returns the first truthy if condition",
        "rule": { "if": [true, "apple", false, "banana"] },
        "data": null,
        "result": "apple"
    },
    {
        "description": "Returns the first truthy then condition, even if multiple conditions are true",
        "rule": { "if": [true, "apple", true, "banana"] },
        "data": null,
        "result": "apple"
    },
    {
        "description": "Retuns the first truthy condition, with the fallback defined.",
        "rule": { "if": [true, "apple", false, "banana", "carrot"] },
        "data": null,
        "result": "apple"
    },
    {
        "description": "Returns the first truthy condition, with the fallback defined; multiple true conditions.",
        "rule": { "if": [true, "apple", true, "banana", "carrot"] },
        "data": null,
        "result": "apple"
    },
    {
        "description": "Returns the first truthy condition, with the first condition falsy. Fallback defined.",
        "rule": { "if": [false, "apple", true, "banana", "carrot"] },
        "data": null,
        "result": "banana"
    },
    {
        "description": "Returns the first truthy condition, in this case it's the 2nd one.",
        "rule": { "if": [false, "apple", true, "banana"] },
        "data": null,
        "result": "banana"
    },
    {
        "description": "When none of the conditions are true, it returns the fallback.",
        "rule": { "if": [false, "apple", false, "banana", "carrot"] },
        "data": null,
        "result": "carrot"
    },
    {
        "description": "When none of the conditions are true, it returns the fallback. In this case the fallback is not defined, so it is null.",
        "rule": { "if": [false, "apple", false, "banana"] },
        "data": null,
        "result": null
    },
    {
        "description": "3 Conditions, all falsy. Returns fallback.",
        "rule": { "if": [false, "apple", false, "banana", false, "carrot", "date"] },
        "data": null,
        "result": "date"
    },
    {
        "description": "3 Conditions, all falsy, no fallback defined. Returns null.",
        "rule": { "if": [false, "apple", false, "banana", false, "carrot"] },
        "data": null,
        "result": null
    },
    {
        "description": "First condition truthy, 3 conditions.",
        "rule": { "if": [true, "apple", false, "banana", false, "carrot", "date"] },
        "data": null,
        "result": "apple"
    },

    {
        "description": "2nd Condition is Truthy",
        "rule": { "if": [false, "apple", true, "banana", false, "carrot", "date"] },
        "data": null,
        "result": "banana"
    },
    {
        "description": "Third Condition is Truthy",
        "rule": { "if": [false, "apple", false, "banana", true, "carrot", "date"] },
        "data": null,
        "result": "carrot"
    },
    {
        "description": "Returns first truthy value, some conditions truthy",
        "rule": { "if": [false, "apple", true, "banana", true, "carrot", "date"] },
        "data": null,
        "result": "banana"
    },
    {
        "description": "Returns first truthy value, some conditions truthy (2)",
        "rule": { "if": [true, "apple", false, "banana", true, "carrot", "date"] },
        "data": null,
        "result": "apple"
    },
    {
        "description": "Returns first truthy value, some conditions truthy (3)",
        "rule": { "if": [true, "apple", true, "banana", false, "carrot", "date"] },
        "data": null,
        "result": "apple"
    },
    {
        "description": "Returns first truthy value, all conditions truthy",
        "rule": { "if": [true, "apple", true, "banana", true, "carrot", "date"] },
        "data": null,
        "result": "apple"
    },
    "Some Variadic Checks with Other Types",
    {
        "description": "Returns first truthy value, some conditions truthy (4)",
        "rule": { "if": [false, "apple", [1], "banana", true, "carrot", "date"] },
        "data": null,
        "result": "banana"
    },   
    {
        "description": "Returns first truthy value, some conditions truthy (5)",
        "rule": { "if": [false, "apple", "This is true", "banana", true, "carrot", "date"] },
        "data": null,
        "result": "banana"
    },   
    {
        "description": "Returns first truthy value, some conditions truthy (6)",
        "rule": { "if": [null, "apple", 0, "banana", 7, "carrot", "date"] },
        "data": null,
        "result": "carrot"
    },
    {
        "description": "Returns first truthy value, some conditions truthy (7)",
        "rule": { "if": ["0", "apple", 0, "banana", 7, "carrot", "date"] },
        "data": null,
        "result": "apple"
    },
    {
        "description": "Returns first truthy value, some conditions truthy (8)",
        "rule": { "if": [{}, "apple", 0, "banana", 7, "carrot", "date"] },
        "data": null,
        "result": "carrot"
    },
    {
        "description": "Returns first truthy value, some conditions truthy (9)",
        "rule": { "if": [{ "val": "a" }, "apple", 0, "banana", 7, "carrot", "date"] },
        "data": { "a": { "b": 1 } },
        "result": "apple"
    },
    "Bad Arguments",
    {
        "description": "If with non-array arguments throws",
        "rule": { "if": "apple" },
        "data": null,
        "error": { "type": "Invalid Arguments" }
    },
    "Short circuiting check",
    {
        "description": "If will not evaluate then branch if the condition is false",
        "rule": { "if": [false, { "throw": "Not Lazy" }, "banana"] },
        "data": null,
        "result": "banana"
    },
    {
        "description": "If will not evaluate fallback branch if the condition is true",
        "rule": { "if": [true, "apple", { "throw": "Not Lazy" }] },
        "data": null,
        "result": "apple"
    },
    {
        "description": "If will not evaluate other branches or checks if a prior condition is true",
        "rule": { "if": [false, { "throw": "Not Lazy" }, true, "apple", { "throw": "Not Lazy" }, { "throw": "Not Lazy" }, { "throw": "Not Lazy" }] },
        "data": null,
        "result": "apple"
    },
    {
        "description": "No branches except the fallback check will be evaluated if the condition is false",
        "rule": { "if": [false, { "throw": "Not Lazy" }, false, { "throw": "Not Lazy" }, false, { "throw": "Not Lazy" }, "carrot"] },
        "data": null,
        "result": "carrot"
    }
]

and

[
    "Basic Checks",
    {
        "description": "Two true values should be true",
        "rule": { "and": [true, true] },
        "data": null,
        "result": true
    },
    {
        "description": "false and true should be false",
        "rule": { "and": [false, true] },
        "data": null,
        "result": false
    },
    {
        "description": "true and false should be false",
        "rule": { "and": [true, false] },
        "data": null,
        "result": false
    },
    {
        "description": "Two false values should be false",
        "rule": { "and": [false, false] },
        "data": null,
        "result": false
    },
    {
        "description": "All true values should be true",
        "rule": { "and": [true, true, true] },
        "data": null,
        "result": true
    },
    {
        "description": "Any false value should be false",
        "rule": { "and": [true, true, false] },
        "data": null,
        "result": false
    },
    {
        "description": "And with a single false value should be false",
        "rule": { "and": [false] },
        "data": null,
        "result": false
    },
    {
        "description": "When all values are truthy, the last truthy value should be returned",
        "rule": { "and": [1, 2, 3] },
        "data": null,
        "result": 3
    },
    {
        "description": "When all values are truthy, the last truthy value should be returned (2)",
        "rule": { "and": [true, 1, {}] },
        "data": null,
        "result": {}
    },
    {
        "description": "And with a single falsey value should be return the falsy value",
        "rule": { "and": [[]] },
        "data": null,
        "result": []
    },
    {
        "description": "And with a single falsey value should be return the falsy value (2)",
        "rule": { "and": [0] },
        "data": null,
        "result": 0
    },
    {
        "description": "And with a single falsey value should be return the falsy value (3)",
        "rule": { "and": [""] },
        "data": null,
        "result": ""
    },
    {
        "description": "And with a single true value should be true",
        "rule": { "and": [true] },
        "data": null,
        "result": true
    },
    {
        "description": "And with 2 truthy values should return the last truthy value",
        "rule": { "and": [1, 3] },
        "data": null,
        "result": 3
    },
    {
        "description": "And with a truthy value and a false value should return the false value",
        "rule": { "and": [3, false] },
        "data": null,
        "result": false
    },
    {
        "description": "And with a truthy value and a false value should return the false value (2)",
        "rule": { "and": [false, 3] },
        "data": null,
        "result": false
    },
    {
        "description": "Empty array is falsy, so it is returned",
        "rule": { "and": [[], true] },
        "data": null,
        "result": []
    },
    {
        "description": "0 is falsy, so it is returned",
        "rule": { "and": [0, true] },
        "data": null,
        "result": 0
    },
    {
        "description": "Empty string is falsy, so it is returned",
        "rule": { "and": ["", true] },
        "data": null,
        "result": ""
    },
    {
        "description": "0 as a string is truthy, so the last truthy value is returned",
        "rule": { "and": ["0", true] },
        "data": null,
        "result": true
    },
    {
        "description": "And with no arguments should return null",
        "rule": { "and": [] },
        "data": null,
        "result": null
    },
    "Valid Arguments Checks",
    {
        "description": "And with non-array arguments should throw",
        "rule": { "and": true },
        "data": null,
        "error": { "type": "Invalid Arguments" }
    },
    "Short Circuiting Checks",
    {
        "description": "And will not interpret the second argument if the first is false",
        "rule": { "and": [false, { "throw": "Not Lazy" }] },
        "data": null,
        "result": false
    },
    {
        "description": "And will not interpret the second argument if the first is falsy",
        "rule": { "and": [0, { "throw": "Not Lazy" }] },
        "data": null,
        "result": 0
    },
    {
        "description": "And will not interpret the nth argument if any value before it is false",
        "rule": { "and": [true, 1, 2, 3, 4, [], { "throw": "Not Lazy" }] },
        "data": null,
        "result": []
    }
]

or

[
    "Basic Checks",
    {
        "description": "Two true values should be true",
        "rule": { "or": [true, true] },
        "data": null,
        "result": true
    },
    {
        "description": "false or true should be true",
        "rule": { "or": [false, true] },
        "data": null,
        "result": true
    },
    {
        "description": "true or false should be true",
        "rule": { "or": [true, false] },
        "data": null,
        "result": true
    },
    {
        "description": "Two false values should be false",
        "rule": { "or": [false, false] },
        "data": null,
        "result": false
    },
    {
        "description": "All true values should be true",
        "rule": { "or": [true, true, true] },
        "data": null,
        "result": true
    },
    {
        "description": "Any true value should be true",
        "rule": { "or": [true, true, false] },
        "data": null,
        "result": true
    },
    {
        "description": "Or with a single true value should be true",
        "rule": { "or": [true] },
        "data": null,
        "result": true
    },
    {
        "description": "When all values are truthy, the first truthy value should be returned",
        "rule": { "or": [1, 2, 3] },
        "data": null,
        "result": 1
    },
    {
        "description": "When all values are truthy, the first truthy value should be returned (2)",
        "rule": { "or": [true, 1, {}] },
        "data": null,
        "result": true
    },
    {
        "description": "Or with a single falsey value should be return the falsy value",
        "rule": { "or": [[]] },
        "data": null,
        "result": []
    },
    {
        "description": "Or with a single falsey value should be return the falsy value (2)",
        "rule": { "or": [0] },
        "data": null,
        "result": 0
    },
    {
        "description": "Or with a single falsey value should be return the falsy value (3)",
        "rule": { "or": [""] },
        "data": null,
        "result": ""
    },
    {
        "description": "Or with a single false value should be false",
        "rule": { "or": [false] },
        "data": null,
        "result": false
    },
    {
        "description": "Or with 2 truthy values should return the first truthy value",
        "rule": { "or": [1, 3] },
        "data": null,
        "result": 1
    },
    {
        "description": "Or with a truthy value and a false value should return the truthy value",
        "rule": { "or": [3, false] },
        "data": null,
        "result": 3
    },
    {
        "description": "Or with a truthy value and a false value should return the truthy value (2)",
        "rule": { "or": [false, 3] },
        "data": null,
        "result": 3
    },
    {
        "description": "Empty array is falsy, so it is not returned if the second argument is truthy",
        "rule": { "or": [[], true] },
        "data": null,
        "result": true
    },
    {
        "description": "0 is falsy, so it is not returned if the second argument is truthy",
        "rule": { "or": [0, true] },
        "data": null,
        "result": true
    },
    {
        "description": "Empty string is falsy, so it is not returned if the second argument is truthy",
        "rule": { "or": ["", true] },
        "data": null,
        "result": true
    },
    {
        "description": "0 as a string is truthy, so the first truthy value is returned",
        "rule": { "or": ["0", true] },
        "data": null,
        "result": "0"
    },
    {
        "description": "Or with no arguments should return null",
        "rule": { "or": [] },
        "data": null,
        "result": null
    },
    "Valid Arguments Checks",
    {
        "description": "Or with non-array arguments should throw",
        "rule": { "or": true },
        "data": null,
        "error": { "type": "Invalid Arguments" }
    },
    "Short Circuiting Checks",
    {
        "description": "Or will not interpret the second argument if the first is false",
        "rule": { "or": [true, { "throw": "Not Lazy" }] },
        "data": null,
        "result": true
    },
    {
        "description": "Or will not interpret the second argument if the first is falsy",
        "rule": { "or": [1, { "throw": "Not Lazy" }] },
        "data": null,
        "result": 1
    },
    {
        "description": "Or will not interpret the nth argument if any value before it is false",
        "rule": { "or": [false, 0, null, { "val": [] }, [], 4, { "throw": "Not Lazy" }] },
        "data": null,
        "result": 4
    }
]

[TotalTechGeek]

Comments from Slack:

@JTeeuwissen: I feel like zero argument and should result in true , like all. Whilst zero argument or should result in false.
@TotalTechGeek: I get that, and for a while it was kinda the main difference between json-logic-engine and json-logic-js in our implementations of all,
jwadhams/json-logic-js#119 (comment)
Because all returns "false" with zero arguments, which is similar in concept to "and", it seems like it might be best for "and" to return false as well
@JTeeuwissen: All returning false for zero arguments doesn't make sense either.
@TotalTechGeek: I agree! That's why it took me 4 years to begrudgingly change it. But the behavior is pinned by tests.json.

I actually kinda agree with @JTeeuwissen, but I'm also aiming for consistency across the operators + backwards compat, hence why I recommended { "and": [] } and { "or": [] } both be false.

[toddbaert]

TBH this one seems a bit arbitrary to me, so deferring to backwards compatibility makes sense.

+1

[codetiger]

Same here. The choice doesn’t make a huge difference in my usecase, but voting (+1) for maintaining backward compatibility as a main reason.

[TotalTechGeek]

To be clear; we can actually deviate / decide whatever behavior we want for and and or, as it has no defined behavior.

I borrowed the false to try to stay consistent with all and none.

But...

I think there's an alternative interpretation that might work equally well / better.

Essentially, if the criteria for and / or is not met, it always returns the last item. Maybe a better choice is to return null instead of false here?

• or: Return the first truthy item, otherwise return the last item.
• and: Return the first falsy item, otherwise return the last item.
  If there are no items, maybe it should return null, instead of false? This is also consistent with ??

What are your thoughts? (i'm starting to lean towards null)

[TotalTechGeek]

Placeholder for tracking votes.

Current Votes

Aggregate	TC Votes in Favor	Votes
3	3	@TotalTechGeek (+1) @toddbaert* (+1) @codetiger* (+1)

Here is a link to our voting procedures.

[TotalTechGeek]

Self +1

[TotalTechGeek]

@toddbaert Wasn't completely sure if you were +1'ing the consistency specifically or the whole proposal, so I'm assuming proposal, but I can modify if I misinterpreted 😄, thanks!

[codetiger]

+1

[TotalTechGeek]

Hey folks... I made a modification that changed the false to a null, since y'all didn't seem to feel strongly about it, I'm assuming the approval is still in place.

So I'm calling for lazy consensus, if I don't hear objections on the change, we'll move this proposal forward.

[TotalTechGeek]

Removing Draft Status as Truthiness Proposal has advanced.

[TotalTechGeek]

I've modifed the proposal here to switch {} towards being falsy.

I'm... still leaving it in pending, there's some discussion in Slack right now that I think we need to get sync'd on,

There's debate over whether if, and and or should chain or not.