JSON Logic
Proposal - Arithmetic Operators #21
Replies: 7 comments 40 replies
-
|
Self Happy to try to account for community feedback. |
Beta Was this translation helpful? Give feedback.
-
|
+1 from me |
Beta Was this translation helpful? Give feedback.
-
|
Should we consider covering test cases for null and other extreme cases [
{
"description": "Addition with null values",
"rule": { "+": [null, 1, null] },
"result": 1,
"data": null
},
{
"description": "Addition with empty string",
"rule": { "+": ["", 1] },
"result": 1,
"data": null
},
{
"description": "Addition with non-numeric strings",
"rule": { "+": ["abc", 1] },
"result": 1,
"data": null
},
{
"description": "Addition with undefined/missing values",
"rule": { "+": [{"var": "missing"}, 1] },
"result": 1,
"data": {}
},
{
"description": "Addition with arrays",
"rule": { "+": [[1,2], 3] },
"result": 3,
"data": null
},
{
"description": "Addition with objects",
"rule": { "+": [{"foo": "bar"}, 1] },
"result": 1,
"data": null
}
] |
Beta Was this translation helpful? Give feedback.
-
|
Or introduce an explicit representation of an error, which can be “bubbled up”. |
Beta Was this translation helpful? Give feedback.
-
|
@gregsdennis @dslmeinte I might copy this input into this discussion here: https://github.com/orgs/json-logic/discussions/20 We need to decide on whether JSON Logic has "Soft Errors" that emit from operators (NaN or some explicit error representation), or strictly "Hard Errors" that halt AST execution. And how we can check for that in our test spec. I'm open to many options here, but I think we do need to mandate it to be consistent. |
Beta Was this translation helpful? Give feedback.
-
|
(I think we'd encounter significant pain if some implementations Hard Errored while others Soft Errored -- what I meant by consistency. So if we defined that coercion of an array is a soft error, I think it should be represented that way across all implementations) |
Beta Was this translation helpful? Give feedback.
-
In which case a |
Beta Was this translation helpful? Give feedback.
-
|
@JTeeuwissen I'm copying this over to the other thread (for errors). 😄 |
Beta Was this translation helpful? Give feedback.
-
|
It's my impression that a lot/most of the JSON Logic operators are “implied |
Beta Was this translation helpful? Give feedback.
-
|
I agree with this mental model & your assessment it's a bit weird for divide and modulo 😀 (I've personally been calling those operators "variadic") I think it might be good to mention this terminology in the proposals; thank you! For consistency between arithmetic operators, I did decide to include variadic / foldLeft test cases for divide and modulo; even though I anticipate this will be rarely used |
Beta Was this translation helpful? Give feedback.
-
|
To be petulantly nerdy here: I think the term “variadic” pertains to functions/operations/operators having a variable (in the sense of: any) number of arguments. The foldLeft semantics are orthogonal to that: you could also say that the function/operation/operator has 1 “listy” (or maybe even
|
Beta Was this translation helpful? Give feedback.
-
|
Oh for sure! there are definitely additional nuances implied by foldLeft: I'll probably incorporate this descriptor in. (However, for the comparison operators which will likely be next, those will probably be best described as variadic -- should we decide to upgrade them) |
Beta Was this translation helpful? Give feedback.
-
|
Could you please highlight any differences between this proposal and what's currently defined in JSON Logic? The proposal makes sense, so I'll give it a |
Beta Was this translation helpful? Give feedback.
-
|
Keeping the spec and test cases agnostic to precision was the main intention. |
Beta Was this translation helpful? Give feedback.
-
|
Only two small changes from the main implementation,
I've basically carried forward all of the tests from the original and added more cases around each. |
Beta Was this translation helpful? Give feedback.
-
|
To help communicate expectations, most of the incoming proposals will just be codifying test cases for existing operators and better defining edge-case behaviors and trying to improve consistency in between families of operators. |
Beta Was this translation helpful? Give feedback.
-
|
Perhaps I've missed it, but I feel like type coercion should be a discussion on its own. Especially when considering future equality operators. I personally would like to avoid coercion as much as possible, since I feel like their use case is rare, easily solved with explicit conversions and that implicit coercion is error prone for users. Additionally, when defining string parsing (preferably explicitly), I think it would be better to accept any valid json number as string (e.g. including scientific notation). |
Beta Was this translation helpful? Give feedback.
-
|
Ah! The scientific notation! Good catch, I can revise the proposal for that immediately. Part of the issue with avoiding coercion is that the mainline tests.json include tests that use both strings & numbers, and they implicitly coerce for the arithmetic and comparison operators. (Except the strict ones) As much as possible, I'd like to be backwards compatible with existing logic & implementations. Personally, I don't love implicit conversions, but I feel it's important to not break compatibility. I don't think any other operators should feature coercion though. |
Beta Was this translation helpful? Give feedback.
-
|
Hey -- while I can come off pretty aggressive about the backwards compat thing, I promise I'm open to exploring options 😅. Like: If the community felt But for the purposes of substr and other operators which can receive numeric arguments, I don't intend to mandate implicit coercion. Just passively noting the following, "as defined"
|
Beta Was this translation helpful? Give feedback.
-
|
@json-logic/tc Calling for a revote, I've amended this to include error boundaries to answer https://github.com/orgs/json-logic/discussions/21#discussioncomment-11871756 I'm giving this a self +1. (For non-TC members, I'm going to assume the error boundaries did not change the vote unless otherwise announced... based on convos I've had) Current Votes
|
Beta Was this translation helpful? Give feedback.
-
|
+1 |
Beta Was this translation helpful? Give feedback.
-
|
@codetiger I'm leaving your vote intact; the zero and single argument behaviors have been amended a bit, if this changes your vote, please lmk. |
Beta Was this translation helpful? Give feedback.
-
|
Unless I've misread intentions, I think @gregsdennis's vote is a +1. So this guy marches forward |
Beta Was this translation helpful? Give feedback.
-
I take this to mean that you're recommending division with a single argument means an implied divisor of 1? I think that there's a stronger argument to be made that this can just as easily be interpreted as having an implicit dividend of 1. That is
This also has functional symmetry with
The identity for Moreover, with this setup,
|
Beta Was this translation helpful? Give feedback.
-
|
I think |
Beta Was this translation helpful? Give feedback.
-
|
I think if we express the unary I think if we define But I don't have a strong preference for it erroring vs producing a 1 (maybe a slight leaning towards the Does anyone have thoughts on the |
Beta Was this translation helpful? Give feedback.
-
|
Okay, if folks are okay with it... I think I'm going to recommend: This creates symmetries between And I'm okay with If folks prefer, we could just make |
Beta Was this translation helpful? Give feedback.
-
|
Eh; I feel like Let's maybe just simplify down to that, I believe this is more defensible & logical. |
Beta Was this translation helpful? Give feedback.
-
|
Alright! I've modified the proposal with the errors, single, and zero argument adjustments. 😄 Lmk if we should explore any additional changes |
Beta Was this translation helpful? Give feedback.
-
Background
JSON Logic includes various arithmetic operators, namely:
+,-,/,*and%.This proposal seeks to evaluate these operators and tests to recognize them in JSON Logic Core.
Proposal
As decided in a previous proposal, these operators are being defined with agnostic precision and from a pure mathematical perspective.
These operators are expected to coerce booleans and strings into numeric values.
{ operator: 2 })+0 + X, (ex. 2)*1 * X, (ex. 2)-0 - X, (ex. -2)/1 / X, (ex. 0.5)%The coercion behavior being defined at this time is the following:
stringis parsed as a JSON Number (e.g.1,1.23,1e5should be valid). Empty string becomes 0.truebecomes 1falsebecomes 0nullbecomes 0There are a few changes from mainline json-logic:
%will emit an error when given < 2 arguments./with one argument will perform1 / X, so{ "/": 2 }will emit0.5/and%also support variadic functionality, for consistency.For the purposes of tests, I am not distinguishing between
-0and0to try to remain precision / implementation agnostic.-0does not seem purely mathematical.These operators are variadic, with an implied foldLeft behavior.
{ "+": [1, 2, 3] }is1 + 2 + 3.Controversial: I am marking the tests that use fractional numbers with a
"decimal": trueproperty. The original JSON Logictests.jsondid have a division test that resulted in a fractional number. Normally I'd omit it, but I'll carry the test for it forward as it is relatively precision agnostic, and we are aiming to honor the originaltests.json.If someone chose to implement an integer-based version of JSON Logic Core, they can decide how they want to handle those tests (like truncating).
For our purposes, it changes nothing; it's just an annotation.
Tests
+Operator[ "# Collection of Plus Operator Tests", { "description": "Addition", "rule": { "+": [1, 2] }, "result": 3, "data": null }, { "description": "Addition (2)", "rule": { "+": [5, 12] }, "result": 17, "data": null }, { "description": "Addition with Multiple Operands", "rule": { "+": [1, 2, 3, 4] }, "result": 10, "data": null }, { "description": "Addition with Negative Numbers", "rule": { "+": [-1, 0, 5] }, "result": 4, "data": null }, { "description": "Addition with Strings", "rule": { "+": ["1", "2", "3"] }, "result": 6, "data": null }, { "description": "Addition with Booleans", "rule": { "+": [true, false, true] }, "result": 2, "data": null }, { "description": "Addition with Multiple Value Types", "rule": { "+": [1, "2", 3, "4", "", true, false, null] }, "result": 11, "data": null }, { "description": "Plus Operator with Single Operand (Number)", "rule": { "+": [1] }, "result": 1, "data": null }, { "description": "Plus Operator with Single Operand (Negative Number)", "rule": { "+": [-1] }, "result": -1, "data": null }, { "description": "Plus Operator with zero operands is zero", "rule": { "+": [] }, "result": 0, "data": null }, { "description": "Plus Operator with Single Operand, Direct (Number)", "rule": { "+": 1 }, "result": 1, "data": null }, { "description": "Plus Operator with Single Operand, Direct (0)", "rule": { "+": 0 }, "result": 0, "data": null }, { "description": "Plus Operator with Single Operand (String)", "rule": { "+": ["1"] }, "result": 1, "data": null }, { "description": "Plus Operator with Single Operand, Direct (Negative Number String)", "rule": { "+": "-1" }, "result": -1, "data": null }, { "description": "Plus Operator with Single Operand, Direct (String Decimal)", "rule": { "+": "1.5" }, "result": 1.5, "data": null, "decimal": true }, { "description": "Plus Operator with Single Operand, Direct (String Negative Decimal)", "rule": { "+": "-1.5" }, "result": -1.5, "data": null, "decimal": true }, { "description": "Plus Operator with Single Operand, Direct (String 0.5)", "rule": { "+": "0.5" }, "result": 0.5, "data": null, "decimal": true }, { "description": "Plus Operator with Single Operand, Direct (String 1e2)", "rule": { "+": "1e2" }, "result": 100, "data": null }, { "description": "Plus Operator with Single Operand, Direct (String 0)", "rule": { "+": "0" }, "result": 0, "data": null }, { "description": "Plus Operator with Single Operand, Direct (true)", "rule": { "+": true }, "result": 1, "data": null }, { "description": "Plus Operator with Single Operand, Direct (false)", "rule": { "+": false }, "result": 0, "data": null }, { "description": "Plus Operator with Single Operand, Direct (Empty String)", "rule": { "+": "" }, "result": 0, "data": null }, { "description": "Plus Operator with a Single Operand, Direct (null)", "rule": { "+": null }, "result": 0, "data": null }, { "description": "Addition with val", "rule": { "+": [{ "val": "x" }, { "val": "y" }] }, "result": 3, "data": { "x": 1, "y": 2 } }, { "description": "Addition with string produces NaN", "rule": { "+": ["Hey", 1] }, "error": { "type": "NaN" }, "data": null }, { "description": "Addition with Array produces NaN", "rule": { "+": [[1], 1] }, "error": { "type": "NaN" }, "data": null }, { "description": "Addition with Array from context produces NaN", "rule": { "+": [{ "val": "x" }, 1] }, "error": { "type": "NaN" }, "data": { "x": [1] } }, { "description": "Addition with Object produces NaN", "rule": { "+": [{ "val": "x" }, 1] }, "error": { "type": "NaN" }, "data": { "x": {} } }, { "description": "Plus Operator with Single Operand, Invalid String Produces NaN", "rule": { "+": "Hello" }, "error": { "type": "NaN" }, "data": null }, { "description": "Plus Operator with Single Operand, Array Input Produces NaN", "rule": { "+": [[1]] }, "error": { "type": "NaN" }, "data": null }, { "description": "Plus Operator with Single Operand, Object Input Produces NaN", "rule": { "+": [{}] }, "error": { "type": "NaN" }, "data": null }, { "description": "Plus Operator with Single Operand, Direct Object Input Produces NaN", "rule": { "+": {} }, "error": { "type": "NaN" }, "data": null } ]-Operator[ "# Collection of Minus Operator Tests", { "description": "Subtraction", "rule": { "-": [1, 2] }, "result": -1, "data": null }, { "description": "Subtraction (2)", "rule": { "-": [5, 12] }, "result": -7, "data": null }, { "description": "Subtraction with Multiple Operands", "rule": { "-": [1, 2, 3, 4] }, "result": -8, "data": null }, { "description": "Subtraction with Negative Numbers", "rule": { "-": [-1, 0, 5] }, "result": -6, "data": null }, { "description": "Subtraction with Strings", "rule": { "-": ["1", "2", "3"] }, "result": -4, "data": null }, { "description": "Subtraction with Booleans", "rule": { "-": [true, false, true] }, "result": 0, "data": null }, { "description": "Subtraction with Multiple Value Types", "rule": { "-": [1, "2", 3, "4", "", true, false, null] }, "result": -9, "data": null }, { "description": "Minus Operator with Single Operand (Number)", "rule": { "-": [1] }, "result": -1, "data": null }, { "description": "Minus Operator with Single Operand (Negative Number)", "rule": { "-": [-1] }, "result": 1, "data": null }, { "description": "Minus with zero operands is an error", "rule": { "-": [] }, "error": { "type": "Invalid Arguments" }, "data": null }, { "description": "Minus Operator with Single Operand, Direct (Number)", "rule": { "-": 1 }, "result": -1, "data": null }, { "description": "Minus Operator with Single Operand, Direct (0)", "rule": { "-": 0 }, "result": 0, "data": null }, { "description": "Minus Operator with Single Operand (String)", "rule": { "-": ["1"] }, "result": -1, "data": null }, { "description": "Minus Operator with Single Operand, Direct (Negative Number String)", "rule": { "-": "-1" }, "result": 1, "data": null }, { "description": "Minus Operator with Single Operand, Direct (String 0)", "rule": { "-": "0" }, "result": 0, "data": null }, { "description": "Minus Operator with Single Operand, Direct (true)", "rule": { "-": true }, "result": -1, "data": null }, { "description": "Minus Operator with Single Operand, Direct (false)", "rule": { "-": false }, "result": 0, "data": null }, { "description": "Minus Operator with Single Operand, Direct (Empty String)", "rule": { "-": "" }, "result": 0, "data": null }, { "description": "Minus Operator with a Single Operand, Direct (null)", "rule": { "-": null }, "result": 0, "data": null }, { "description": "Subtraction with val", "rule": { "-": [{ "val": "x" }, { "val": "y" }] }, "data": { "x": 1, "y": 2 }, "result": -1 }, { "description": "Subtraction with string produces NaN", "rule": { "-": ["Hey", 1] }, "error": { "type": "NaN" }, "data": null }, { "description": "Subtraction with Array produces NaN", "rule": { "-": [[1], 1] }, "error": { "type": "NaN" }, "data": null } ]*Operator[ "# Collection of Multiply Operator Tests", { "description": "Multiply", "rule": { "*": [3, 2] }, "result": 6, "data": null }, { "description": "Multiply with Multiple Operands", "rule": { "*": [5, 10, 2] }, "result": 100, "data": null }, { "description": "Multiply with Multiple Operands (2)", "rule": { "*": [2, 2, 2] }, "result": 8, "data": null }, { "description": "Multiply with Negative Numbers", "rule": { "*": [-1, 2, 5] }, "result": -10, "data": null }, { "description": "Multiply with Strings", "rule": { "*": ["1", "2", "3"] }, "result": 6, "data": null }, { "description": "Multiply with Booleans", "rule": { "*": [true, false, true] }, "result": 0, "data": null }, { "description": "Multiply with Multiple Value Types", "rule": { "*": [1, "2", 3, "4", true] }, "result": 24, "data": null }, { "description": "Multiply with Multiple Value Types (2)", "rule": { "*": [1, "1"] }, "result": 1, "data": null }, { "description": "Multiply with Multiple Value Types (3)", "rule": { "*": ["1", null] }, "result": 0, "data": null }, { "description": "Multiply with Single Operand (Number)", "rule": { "*": [1] }, "result": 1, "data": null }, { "description": "Multiply with Single Operand, Direct (Number)", "rule": { "*": 1 }, "result": 1, "data": null }, { "description": "Multiply with Single Operand, Direct (0)", "rule": { "*": 0 }, "result": 0, "data": null }, { "description": "Multiply Operator with Single Operand (Number)", "rule": { "*": [1] }, "result": 1, "data": null }, { "description": "Multiply Operator with Single Operand (Negative Number)", "rule": { "*": [-1] }, "result": -1, "data": null }, { "description": "Multiply with zero operands is 1 (Product)", "rule": { "*": [] }, "result": 1, "data": null }, { "description": "Multiply Operator with Single Operand, Direct (Number)", "rule": { "*": 1 }, "result": 1, "data": null }, { "description": "Multiply Operator with Single Operand, Direct (0)", "rule": { "*": 0 }, "result": 0, "data": null }, { "description": "Multiply Operator with Single Operand (String)", "rule": { "*": ["1"] }, "result": 1, "data": null }, { "description": "Multiply Operator with Single Operand, Direct (Negative Number String)", "rule": { "*": "-1" }, "result": -1, "data": null }, { "description": "Multiply Operator with Single Operand, Direct (String 0)", "rule": { "*": "0" }, "result": 0, "data": null }, { "description": "Multiply Operator with Single Operand, Direct (true)", "rule": { "*": true }, "result": 1, "data": null }, { "description": "Multiply Operator with Single Operand, Direct (false)", "rule": { "*": false }, "result": 0, "data": null }, { "description": "Multiply Operator with Single Operand, Direct (Empty String)", "rule": { "*": "" }, "result": 0, "data": null }, { "description": "Multiply Operator with a Single Operand, Direct (null)", "rule": { "*": null }, "result": 0, "data": null }, { "description": "Multiply with val", "rule": { "*": [{ "val": "x" }, { "val": "y" }] }, "data": { "x": 8, "y": 2 }, "result": 16 }, { "description": "Multiply with string produces NaN", "rule": { "*": ["Hey", 1] }, "error": { "type": "NaN" }, "data": null }, { "description": "Multiply with a single string produces NaN", "rule": { "*": ["Hey"] }, "error": { "type": "NaN" }, "data": null }, { "description": "Multiply with Array produces NaN", "rule": { "*": [[1], 1] }, "error": { "type": "NaN" }, "data": null } ]/Operator[ "# Collection of Divide Operator Tests", { "description": "Divide", "rule": { "/": [4, 2] }, "result": 2, "data": null }, { "description": "Divide to Decimal", "rule": { "/": [2, 4] }, "result": 0.5, "data": null, "decimal": true }, { "description": "Divide with Multiple Operands", "rule": { "/": [8, 2, 2] }, "result": 2, "data": null }, { "description": "Divide with Multiple Operands (2)", "rule": { "/": [2, 2, 1] }, "result": 1, "data": null }, { "description": "Divide with Negative Numbers", "rule": { "/": [-1, 2] }, "result": -0.5, "data": null, "decimal": true }, { "description": "Divide with Strings", "rule": { "/": ["8", "2", "2"] }, "result": 2, "data": null }, { "description": "Divide with Booleans", "rule": { "/": [false, true] }, "result": 0, "data": null }, { "description": "Divide with Multiple Value Types", "rule": { "/": ["8", true, 2] }, "result": 4, "data": null }, { "description": "Divide with Multiple Value Types (2)", "rule": { "/": ["1", 1] }, "result": 1, "data": null }, { "description": "Divide with Single Operand (Number)", "rule": { "/": [1] }, "result": 1, "data": null }, { "description": "Divide with zero operands is an error", "rule": { "/": [] }, "error": { "type": "Invalid Arguments" }, "data": null }, { "description": "Divide with Single Operand, Direct (Number)", "rule": { "/": 1 }, "result": 1, "data": null }, { "description": "Divide with Single Operand, Direct (0)", "rule": { "/": 0 }, "error": { "type": "NaN" }, "data": null }, { "description": "Divide Operator with Single Operand (Number)", "rule": { "/": [1] }, "result": 1, "data": null }, { "description": "Divide Operator with Single Operand (Negative Number)", "rule": { "/": [-1] }, "result": -1, "data": null }, { "description": "Divide Operator with Single Operand, Direct (Number)", "rule": { "/": 1 }, "result": 1, "data": null }, { "description": "Divide Operator with Single Operand, Direct (2)", "rule": { "/": 2 }, "result": 0.5, "decimal": true, "data": null }, { "description": "Divide Operator with Single Operand, Direct (0)", "rule": { "/": 0 }, "error": { "type": "NaN" }, "data": null }, { "description": "Divide Operator with Single Operand (String)", "rule": { "/": ["1"] }, "result": 1, "data": null }, { "description": "Divide Operator with Single Operand, Direct (Negative Number String)", "rule": { "/": "-1" }, "result": -1, "data": null }, { "description": "Divide Operator with Single Operand, Direct (String 0)", "rule": { "/": "0" }, "error": { "type": "NaN" }, "data": null }, { "description": "Divide Operator with Single Operand, Direct (true)", "rule": { "/": true }, "result": 1, "data": null }, { "description": "Divide Operator with Single Operand, Direct (false)", "rule": { "/": false }, "error": { "type": "NaN" }, "data": null }, { "description": "Divide Operator with Single Operand, Direct (Empty String)", "rule": { "/": "" }, "error": { "type": "NaN" }, "data": null }, { "description": "Divide Operator with a Single Operand, Direct (null)", "rule": { "/": null }, "error": { "type": "NaN" }, "data": null }, { "description": "Divide with val", "rule": { "/": [{ "val": "x" }, { "val": "y" }] }, "data": { "x": 8, "y": 2 }, "result": 4 }, { "description": "Divide by Zero", "rule": { "/": [0, 0] }, "error": { "type": "NaN" }, "data": null }, { "description": "Divide with String produces NaN", "rule": { "/": [1, "a"] }, "error": { "type": "NaN" }, "data": null }, { "description": "Divide with Array produces NaN", "rule": { "/": [1, [1]] }, "error": { "type": "NaN" }, "data": null }, { "description": "Any division by zero should return NaN", "rule": { "/": [1, 0] }, "error": { "type": "NaN" }, "data": null }, { "description": "Any division by zero should return NaN (2)", "rule": { "/": [8, 2, 0] }, "error": { "type": "NaN" }, "data": null } ]%Operator[ "# Collection of Modulo Operator Tests", { "description": "Modulo", "rule": { "%": [4, 2] }, "result": 0, "data": null }, { "description": "Modulo (2)", "rule": { "%": [2, 2] }, "result": 0, "data": null }, { "description": "Modulo (3)", "rule": { "%": [3, 2] }, "result": 1, "data": null }, { "description": "Modulo with a Decimal Operand", "rule": { "%": [1, 0.5] }, "result": 0, "data": null, "decimal": true }, { "description": "Modulo with Multiple Operands", "rule": { "%": [8, 6, 3] }, "result": 2, "data": null }, { "description": "Modulo with Multiple Operands (2)", "rule": { "%": [2, 2, 1] }, "result": 0, "data": null }, { "description": "Modulo with Negative Numbers", "rule": { "%": [-1, 2] }, "result": -1, "data": null }, { "description": "Modulo with Strings", "rule": { "%": ["8", "2"] }, "result": 0, "data": null }, { "description": "Modulo with Booleans", "rule": { "%": [false, true] }, "result": 0, "data": null }, { "description": "Modulo with Multiple Value Types", "rule": { "%": ["8", 3, true] }, "result": 0, "data": null }, { "description": "Modulo with Multiple Value Types (2)", "rule": { "%": ["1", 1] }, "result": 0, "data": null }, { "description": "Modulo with Single Operand (Number)", "rule": { "%": [1] }, "error": { "type": "Invalid Arguments"}, "data": null }, { "description": "Modulo with Single Operand, Direct (Number)", "rule": { "%": 1 }, "error": { "type": "Invalid Arguments"}, "data": null }, { "description": "Modulo with Single Operand, Direct (0)", "rule": { "%": 0 }, "error": { "type": "Invalid Arguments"}, "data": null }, { "description": "Modulo Operator with Single Operand (Number)", "rule": { "%": [1] }, "error": { "type": "Invalid Arguments"}, "data": null }, { "description": "Modulo Operator with Single Operand (Negative Number)", "rule": { "%": [-1] }, "error": { "type": "Invalid Arguments"}, "data": null }, { "description": "Modulo with zero operands is an error", "rule": { "%": [] }, "error": { "type": "Invalid Arguments" }, "data": null }, { "description": "Modulo Operator with Single Operand, Direct (Number)", "rule": { "%": 1 }, "error": { "type": "Invalid Arguments"}, "data": null }, { "description": "Modulo Operator with Single Operand, Direct (0)", "rule": { "%": 0 }, "error": { "type": "Invalid Arguments"}, "data": null }, { "description": "Modulo Operator with Single Operand (String)", "rule": { "%": ["1"] }, "error": { "type": "Invalid Arguments"}, "data": null }, { "description": "Modulo Operator with Single Operand, Direct (Negative Number String)", "rule": { "%": "-1" }, "error": { "type": "Invalid Arguments"}, "data": null }, { "description": "Modulo Operator with Single Operand, Direct (String 0)", "rule": { "%": "0" }, "error": { "type": "Invalid Arguments"}, "data": null }, { "description": "Modulo Operator with Single Operand, Direct (true)", "rule": { "%": true }, "error": { "type": "Invalid Arguments"}, "data": null }, { "description": "Modulo Operator with Single Operand, Direct (false)", "rule": { "%": false }, "error": { "type": "Invalid Arguments"}, "data": null }, { "description": "Modulo Operator with Single Operand, Direct (Empty String)", "rule": { "%": "" }, "error": { "type": "Invalid Arguments"}, "data": null }, { "description": "Modulo Operator with a Single Operand, Direct (null)", "rule": { "%": null }, "error": { "type": "Invalid Arguments"}, "data": null }, { "description": "Modulo with val", "rule": { "%": [{ "val": "x" }, { "val": "y" }] }, "data": { "x": 11, "y": 6 }, "result": 5 }, { "description": "Modulo with string produces NaN", "rule": { "%": ["Hey", 1] }, "error": { "type": "NaN" }, "data": null }, { "description": "Modulo with array produces NaN", "rule": { "%": [[1], 1] }, "error": { "type": "NaN" }, "data": null }, { "description": "Modulo with a negative dividend", "rule": { "%": [-8, 3] }, "result": -2, "data": null }, { "description": "Modulo with a negative divisor", "rule": { "%": [8, -3] }, "result": 2, "data": null } ]Beta Was this translation helpful? Give feedback.
All reactions