Proposal - Truthiness (Mainly to Decide Empty Object)

[TotalTechGeek]

Background

I'm hopeful this proposal can pass through quickly, it mostly solidifies some conventions that already exist in tests.json, but we do need to decide if:

• Empty Objects are Truthy or Falsey
• Objects are Truthy

Proposal

Based on community input, I believe we're deciding to make empty objects falsy, while other objects are truthy.

Historically, json-logic-js and json-logic-php treat empty object as truthy, but this is not codified in tests.json.

Tests

[
    "# This can also be seen as a test suite for !!",
    "# Primitive Truthiness tests",
    {
        "description": "Truthy: true",
        "rule": { "!!": true },
        "result": true,
        "data": null
    },
    {
        "description": "Falsey: false",
        "rule": { "!!": false },
        "result": false,
        "data": null
    },
    {
        "description": "Truthy: 1",
        "rule": { "!!": 1 },
        "result": true,
        "data": null
    },
    {
        "description": "Falsey: 0",
        "rule": { "!!": 0 },
        "result": false,
        "data": null
    },
    {
        "description": "Truthy: -1",
        "rule": { "!!": -1 },
        "result": true,
        "data": null
    },
    {
        "description": "Falsey: []",
        "rule": { "!!": [[]] },
        "result": false,
        "data": null
    },
    {
        "description": "Truthy: {}, Direct",
        "rule": { "!!": {} },
        "result": false,
        "data": null
    },
    {
        "description": "Truthy: {}",
        "rule": { "!!": [{}] },
        "result": false,
        "data": null
    },
    {
        "description": "Falsey: ''",
        "rule": { "!!": "" },
        "result": false,
        "data": null
    },
    {
        "description": "Falsey: null",
        "rule": { "!!": null },
        "result": false,
        "data": null
    },
    "# Context Object Tests",
    {
        "description": "Truthy: Zero Key Object",
        "rule": { "!!": { "val": "obj" } },
        "result": false,
        "data": { "obj": {} }
    },
    {
        "description": "Truthy: Single Key Object",
        "rule": { "!!": { "val": "obj" } },
        "result": true,
        "data": { "obj": { "a": 0 } }
    },
    {
        "description": "Truthy: Multi Key Object",
        "rule": { "!!": { "val": "obj" } },
        "result": true,
        "data": { "obj": { "a": 0, "b": 0 } }
    },
    {
        "description": "Truthy: Single Key Object (Empty Key)",
        "rule": { "!!": { "val": "obj" } },
        "result": true,
        "data": { "obj": { "": 0 } }
    }
]

Out of Scope / Author's Opinion

The following is my stance / guidance for implementers:

If your JSON Logic implementation supports non-JSON constructs being passed into context (ecosystem specific, for example, native Map or Set structures or class instantiations), I recommend the following interpretation:

"Any empty iterable structure should be falsy in JSON Logic".

Therefore, strings, arrays, dictionaries, sets, tree structures, and more can be appropriately handled for falsiness. Otherwise, class instances should be truthy.

[TotalTechGeek]

This guy is kinda holding up my if and or proposal, I figure it might be best to decide on object truthiness before I start hammering out those guys.

[dslmeinte]

@TotalTechGeek I guess time works differently for everyone. For me personally, I can look at things coming in as a trickle, but unfortunately, I don't have time for a deluge of discussions on 3 separate GitHub issues. If you'd like my input on something specifically, please ping me.

[TotalTechGeek]

Sorry about that! I'll try to keep it to a trickle going forward.

Had a bit of a deluge of things pop up; so I wasn't able to publish some things when intended.

Most of these guys are relatively small, "should empty object pass through", "is empty object truthy"

But I understand the frustration 😄

[beeme1mr]

I think treating empty objects as truthy would be the expected behavior for most users.

[TotalTechGeek]

It is kind of what I'd expect, but since empty array is falsy, I could understand the argument for the other side 😂

I'm going to interpret this as a +1 for the current proposal though.

[gregsdennis]

I would expect an empty object to be falsy.

[TotalTechGeek]

Self +1.

Current Votes

Aggregate	TC Votes in Favor	Votes
5	4	@TotalTechGeek (+1) @beeme1mr (+1) @codetiger (+1) @toddbaert (+1) @gregsdennis (+1)

(Dropped @dslmeinte's vote due to a modification from truthy to falsy)

Here is a link to our voting procedures.

[codetiger]

+1

[TotalTechGeek]

Need just one more @json-logic/tc approval for this to move forward.

[toddbaert]

+1

[toddbaert]

It's not may favorite that [] is falsy and {} is truthy, but I think in this case, adding another unexpectedly falsy thing (empty objects) is better than consistency.

[gregsdennis]

+1 for both truthy or both falsy. Either way is fine with me, as long as they're the same.

[dslmeinte]

For CertLogic, I chose to consider the empty object truthy: https://github.com/ehn-dcc-development/eu-dcc-business-rules/blob/main/certlogic/specification/README.md#truthy-and-falsy-values
But then again, we were catering for a very specific context then — see also the remark “Note: null, the empty string, the zero integer, the empty array, and the empty object all being falsy (and not truthy) is useful for checking the presence/existence of values in the data context.”

For the case of JSON Logic, I'm guessing that all objects being (universally) truthy is probably the most consistent choice.

[TotalTechGeek]

I'm going to interpret this as a +1 for the proposal.

[gregsdennis]

Can someone explain why it makes sense to them that {} is truthy and [] is falsy? This makes no sense to me. These should be the same: either both truthy or both falsy.

[dslmeinte]

That was definitely the main reason to (keep) consider(-ing) [] falsy in CertLogic!

[TotalTechGeek]

My only other justification for objects being truthy is admittedly weak:

If you pass a class instance into JSON Logic via context, checking the key length may cause it to see the object as empty even if it's actually not. (Private values)

Which leads to slightly more convoluted code to check the item's constructor.

I feel this argument is weak because passing in non-JSON data is not explicitly part of JSON Logic; it would be environment specific, plus you can work around it.

Overall, I think @toddbaert and @codetiger are indifferent as to whether it's truthy or not. I'm mostly indifferent myself. I think it's a rare edge case.

So I'm genuinely happy to make the swap if anyone feels strongly.

[TotalTechGeek]

(Side note: making it falsy makes my Handlebars implementation simpler; won't have to configure the truthy function on the engine 😉)

[beeme1mr]

Originally I voted for truthy, partially because that's the behavior in JS. However, I'd like to change my non-binding vote to falsy. It should really be treated as an edge case anyway. I can't think of a valid reason why you would write a rule that relied on the truthiness of an empty object 😆. It's probably safer to assume that's a misconfiguration and treat it as false.

[TotalTechGeek]

Last thought:

My one concern with changing it is that because json-logic-js is the most used implementation,

Making it falsy actually might break a slightly more than trivial logic in the wild.

This is UB, and we have decided that this is OK for us to redefine, but it is a point to consider.

[TotalTechGeek]

@json-logic/tc

I've modified the proposal to switch {} to be falsy.

@codetiger and @toddbaert I believe y'all communicated y'all were largely indifferent towards this choice, so I haven't dropped your votes.

I added an opinion though to this discussion to refer back to later, I think if implementations support non-JSON items as context, they should take care to support their truthiness in an idiomatic way.

[codetiger]

Agree with your opinion, and my vote shall still hold true. +1

[toddbaert]

I was somewhat indifferent, but after some recent bugs in OpenFeature, I'm more inclined to prefer consistency here between empty arrays and object. So I'm changing my opinion on that one

[toddbaert]

@TotalTechGeek will you be making this change? I still see {} is truthy in the description.

[TotalTechGeek]

It was changed on 2/27;

It asks in the background if empty objects are truthy, but the proposal & test cases show it as falsy.

The table and tests also reflect the change: https://github.com/json-logic/.github/blob/main/ACCEPTED_PROPOSALS.md

😄