Proposal - Array Containment Operators (contains_all / contains_any / contains_none)

[iyk2h]

Summary

This proposes three array containment operators — as a community array extension (not JSON Logic Core), per @TotalTechGeek's recommendation in json-logic-engine#58:

Operator	Description	Example
contains_all	true if every element of B exists in A	{"contains_all": [["a","b","c"], ["a","b"]]} → true
contains_any	true if at least one element of B exists in A	{"contains_any": [["a","b"], ["b","c"]]} → true
contains_none	true if no element of B exists in A	{"contains_none": [["a","b"], ["c","d"]]} → true

All three take [haystack, probe] and return a boolean.

Background and use cases

Workflow/rule builders where non-technical users compose conditions in a UI:

• "If selected options contain all of ['VIP', 'Premium'] → send to Slack"
• "If tags contain any of ['urgent', 'important'] → notify immediately"
• "If categories contain none of ['blocked', 'spam'] → proceed"

Multi-select / checkbox answers are arrays, and the condition value picked in the UI is also an array, so array-to-array containment comes up constantly. in only covers scalar-in-array.

These are expressible today via scoped iterators, e.g. {"all": [["a","b"], {"in": [{"var": ""}, {"var": "../../selected"}]}]} — but rules built by a visual condition builder map naturally to {operator: [haystack, probe]}. Emitting a scoped iterator with a relative var/val path just to express "A contains all of B" makes generated rules significantly harder to produce, validate, and read back into the UI.

Proposed semantics

• contains_all(A, []) → true (vacuous truth); contains_any(A, []) → false; contains_none(A, []) → true
• Empty haystack: contains_all([], B) → false (for non-empty B); contains_any([], B) → false; contains_none([], B) → true
• Non-array operands are treated as empty arrays, consistent with how in treats a null haystack
• Element equality follows the same equality the implementation uses for in membership (SameValueZero in JS engines); a Set/hash-set gives O(n+m)

Potential roadblocks

1. "Just use some + in." True — these are sugar. The claim is that the sugar carries its weight for UI-generated rules (flat {op: [haystack, probe]} shape round-trips cleanly through a condition builder) and that the pattern is common enough to standardize. If the TC feels iterator composition is the intended answer, this proposal should be rejected rather than fragmenting.
2. Cross-language equality. JS includes is SameValueZero; other runtimes have different native equality (e.g. deep equality for objects in some Go implementations). The proposal deliberately pins element equality to "whatever the implementation's in uses" to stay consistent within each runtime — but if the extension should mandate a single cross-runtime equality (e.g. scalars only, or RFC 8259 value equality), that needs deciding here. The attached test suite only exercises strings and numbers, where all implementations agree.
3. Naming. contains_all / contains_any / contains_none follow the snake_case precedent of missing_some, and match the names already shipped in the Go ecosystem (see below). Alternatives like supersetOf / intersects / disjoint are more set-theoretic but less approachable for the rule-builder audience.
4. Non-array coercion vs. hard error. Treating non-array operands as empty arrays matches in's lenient style, but an implementation with strict error semantics might prefer {"type": "Invalid Arguments"}. Open to tightening this.

Existing implementations

• Go — diegoholiveira/jsonlogic merged all three operators with these names and semantics: diegoholiveira/jsonlogic#130 (from proposal #129)
• JS — reference implementation for json-logic-engine in json-logic-engine#59 (kept as draft pending this proposal)

Test suite

Formatted per TEST_FORMAT.md; these match the merged Go implementation's test matrix.

[
  "Tests for contains_all, contains_any and contains_none.",
  { "description": "contains_all is true when every probe element is present", "rule": { "contains_all": [["a", "b", "c"], ["a", "b"]] }, "data": null, "result": true },
  { "description": "contains_all is true when arrays are identical", "rule": { "contains_all": [["a", "b"], ["a", "b"]] }, "data": null, "result": true },
  { "description": "contains_all is false when a probe element is missing", "rule": { "contains_all": [["a", "b"], ["a", "b", "c"]] }, "data": null, "result": false },
  { "description": "contains_all is vacuously true for an empty probe", "rule": { "contains_all": [["a", "b", "c"], []] }, "data": null, "result": true },
  { "description": "contains_all is false when the haystack is empty", "rule": { "contains_all": [[], ["a"]] }, "data": null, "result": false },
  { "description": "contains_all is true when both arrays are empty", "rule": { "contains_all": [[], []] }, "data": null, "result": true },
  { "description": "contains_all works with numbers", "rule": { "contains_all": [[1, 2, 3, 4], [1, 3]] }, "data": null, "result": true },
  { "description": "contains_all ignores duplicates in the probe", "rule": { "contains_all": [["a", "b"], ["a", "a", "b"]] }, "data": null, "result": true },
  { "description": "contains_all resolves the haystack from data", "rule": { "contains_all": [{ "var": "selected" }, ["vip", "premium"]] }, "data": { "selected": ["vip", "premium", "basic"] }, "result": true },
  { "description": "contains_all resolves the haystack from data, failing", "rule": { "contains_all": [{ "var": "selected" }, ["vip", "diamond"]] }, "data": { "selected": ["vip", "premium", "basic"] }, "result": false },
  { "description": "contains_all treats a missing haystack as empty", "rule": { "contains_all": [{ "var": "selected" }, ["vip"]] }, "data": null, "result": false },

  { "description": "contains_any is true when at least one probe element is present", "rule": { "contains_any": [["a", "b", "c"], ["x", "b"]] }, "data": null, "result": true },
  { "description": "contains_any is true when every probe element is present", "rule": { "contains_any": [["a", "b", "c"], ["a", "c"]] }, "data": null, "result": true },
  { "description": "contains_any is false when no probe element is present", "rule": { "contains_any": [["a", "b", "c"], ["x", "y"]] }, "data": null, "result": false },
  { "description": "contains_any is false for an empty probe", "rule": { "contains_any": [["a", "b", "c"], []] }, "data": null, "result": false },
  { "description": "contains_any is false when the haystack is empty", "rule": { "contains_any": [[], ["a"]] }, "data": null, "result": false },
  { "description": "contains_any works with numbers", "rule": { "contains_any": [[1, 2, 3], [5, 3, 7]] }, "data": null, "result": true },
  { "description": "contains_any resolves the haystack from data", "rule": { "contains_any": [{ "var": "tags" }, ["urgent", "important"]] }, "data": { "tags": ["urgent", "todo"] }, "result": true },
  { "description": "contains_any resolves the haystack from data, failing", "rule": { "contains_any": [{ "var": "tags" }, ["urgent", "important"]] }, "data": { "tags": ["todo", "later"] }, "result": false },
  { "description": "contains_any treats a missing haystack as empty", "rule": { "contains_any": [{ "var": "tags" }, ["urgent"]] }, "data": null, "result": false },

  { "description": "contains_none is true when no probe element is present", "rule": { "contains_none": [["a", "b", "c"], ["x", "y"]] }, "data": null, "result": true },
  { "description": "contains_none is false when one probe element is present", "rule": { "contains_none": [["a", "b", "c"], ["x", "b"]] }, "data": null, "result": false },
  { "description": "contains_none is false when every probe element is present", "rule": { "contains_none": [["a", "b", "c"], ["a", "b"]] }, "data": null, "result": false },
  { "description": "contains_none is vacuously true for an empty probe", "rule": { "contains_none": [["a", "b", "c"], []] }, "data": null, "result": true },
  { "description": "contains_none is true when the haystack is empty", "rule": { "contains_none": [[], ["a"]] }, "data": null, "result": true },
  { "description": "contains_none works with numbers", "rule": { "contains_none": [[1, 2, 3], [7, 8, 9]] }, "data": null, "result": true },
  { "description": "contains_none resolves the haystack from data", "rule": { "contains_none": [{ "var": "content" }, ["spam", "blocked"]] }, "data": { "content": ["hello", "world"] }, "result": true },
  { "description": "contains_none resolves the haystack from data, failing", "rule": { "contains_none": [{ "var": "content" }, ["spam", "blocked"]] }, "data": { "content": ["hello", "spam"] }, "result": false },
  { "description": "contains_none treats a missing haystack as empty", "rule": { "contains_none": [{ "var": "content" }, ["spam"]] }, "data": null, "result": true }
]

Happy to adjust naming, semantics, or scope to whatever the TC prefers.