Implement ProperContains/ProperIn for both List and Interval (#369)

- Implement ProperContains/ProperIn operators for both List and Interval
- Expand unit/spec tests for List and Interval behavior and remove now-supported cases from the skip list
- Update cql-tests CqlListOperatorsTest.xml to the latest from upstream
- Add skip for Slice test group in CqlListOperators; Slice is CQL 2.0 and not yet implemented
- Rebuild test CQL & ELM

Author: dehall

examples/browser/cql4browsers.js

@@ -1891,6 +1891,15 @@ class Interval {
         }
         return logic_1.ThreeValuedLogic.and(lowFn(this.low, item, precision), highFn(this.high, item, precision));
     }
+    properContains(item, precision) {
+        if (item == null) {
+            return null;
+        }
+        else if (item.isInterval) {
+            throw new Error('Argument to contains must be a point');
+        }
+        return logic_1.ThreeValuedLogic.and(cmp.lessThan(this.start(), item, precision), cmp.greaterThan(this.end(), item, precision));
+    }
     properlyIncludes(other, precision) {
         if (other == null || !other.isInterval) {
             throw new Error('Argument to properlyIncludes must be an interval');
@@ -4800,7 +4809,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.doContains = exports.doExcept = exports.doIncludes = exports.doIntersect = exports.doProperIncludes = exports.doAfter = exports.doUnion = exports.doBefore = void 0;
+exports.doProperContains = exports.doContains = exports.doExcept = exports.doIncludes = exports.doIntersect = exports.doProperIncludes = exports.doAfter = exports.doUnion = exports.doBefore = void 0;
 __exportStar(require("./expression"), exports);
 __exportStar(require("./aggregate"), exports);
 __exportStar(require("./arithmetic"), exports);
@@ -4839,6 +4848,7 @@ Object.defineProperty(exports, "doIntersect", { enumerable: true, get: function
 Object.defineProperty(exports, "doIncludes", { enumerable: true, get: function () { return interval_1.doIncludes; } });
 Object.defineProperty(exports, "doExcept", { enumerable: true, get: function () { return interval_1.doExcept; } });
 Object.defineProperty(exports, "doContains", { enumerable: true, get: function () { return interval_1.doContains; } });
+Object.defineProperty(exports, "doProperContains", { enumerable: true, get: function () { return interval_1.doProperContains; } });
 
 },{"./aggregate":15,"./arithmetic":16,"./clinical":18,"./comparison":19,"./conditional":20,"./datetime":21,"./declaration":22,"./expression":23,"./external":25,"./instance":26,"./interval":27,"./list":29,"./literal":30,"./logical":31,"./message":32,"./nullological":33,"./overloaded":34,"./parameters":35,"./quantity":36,"./query":37,"./ratio":38,"./reusable":39,"./string":40,"./structured":41,"./type":42}],25:[function(require,module,exports){
 "use strict";
@@ -4991,6 +5001,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Collapse = exports.Expand = exports.Ends = exports.Starts = exports.End = exports.Start = exports.Size = exports.Width = exports.OverlapsBefore = exports.OverlapsAfter = exports.Overlaps = exports.MeetsBefore = exports.MeetsAfter = exports.Meets = exports.Interval = void 0;
 exports.doContains = doContains;
+exports.doProperContains = doProperContains;
 exports.doIncludes = doIncludes;
 exports.doProperIncludes = doProperIncludes;
 exports.doAfter = doAfter;
@@ -5050,6 +5061,10 @@ exports.Interval = Interval;
 function doContains(interval, item, precision) {
     return interval.contains(item, precision);
 }
+// Delegated to by overloaded#ProperContains and overloaded#ProperIn
+function doProperContains(interval, item, precision) {
+    return interval.properContains(item, precision);
+}
 // Delegated to by overloaded#Includes and overloaded#IncludedIn
 function doIncludes(interval, subinterval, precision) {
     return interval.includes(subinterval, precision);
@@ -5861,6 +5876,7 @@ exports.doUnion = doUnion;
 exports.doExcept = doExcept;
 exports.doIntersect = doIntersect;
 exports.doContains = doContains;
+exports.doProperContains = doProperContains;
 exports.doIncludes = doIncludes;
 exports.doProperIncludes = doProperIncludes;
 const immutable_1 = require("immutable");
@@ -5990,6 +6006,15 @@ exports.IndexOf = IndexOf;
 function doContains(container, item) {
     return container.some((element) => (0, comparison_1.equals)(element, item) || (element == null && item == null));
 }
+// Delegated to by overloaded#ProperContains and overloaded#ProperIn
+function doProperContains(container, item) {
+    // The "proper" membership operators have list semantics, not set semantics.
+    // The intent here is that given list semantics and a `distinct` operator,
+    // one can achieve set semantics, but the reverse isn't possible.
+    // These proper membership operators can then be described as
+    // the regular membership operators, plus the list is strictly larger.
+    return container.length > 1 && doContains(container, item);
+}
 // Delegated to by overloaded#Includes and overloaded@IncludedIn
 function doIncludes(list, sublist) {
     if (list == null || sublist == null) {
@@ -6427,7 +6452,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Precision = exports.SameOrBefore = exports.SameOrAfter = exports.SameAs = exports.Before = exports.After = exports.Length = exports.ProperIncludedIn = exports.ProperIncludes = exports.IncludedIn = exports.Includes = exports.Contains = exports.In = exports.Indexer = exports.Intersect = exports.Except = exports.Union = exports.NotEqual = exports.Equivalent = exports.Equal = void 0;
+exports.Precision = exports.SameOrBefore = exports.SameOrAfter = exports.SameAs = exports.Before = exports.After = exports.Length = exports.ProperContains = exports.ProperIn = exports.ProperIncludedIn = exports.ProperIncludes = exports.IncludedIn = exports.Includes = exports.Contains = exports.In = exports.Indexer = exports.Intersect = exports.Except = exports.Union = exports.NotEqual = exports.Equivalent = exports.Equal = void 0;
 /* eslint-disable @typescript-eslint/ban-ts-comment */
 const expression_1 = require("./expression");
 const logic_1 = require("../datatypes/logic");
@@ -6675,6 +6700,44 @@ class ProperIncludedIn extends expression_1.Expression {
     }
 }
 exports.ProperIncludedIn = ProperIncludedIn;
+class ProperIn extends expression_1.Expression {
+    constructor(json) {
+        super(json);
+        this.precision = json.precision != null ? json.precision.toLowerCase() : undefined;
+    }
+    async exec(ctx) {
+        const [item, container] = await this.execArgs(ctx);
+        if (container == null) {
+            return false;
+        }
+        if ((0, util_1.typeIsArray)(container)) {
+            return LIST.doProperContains(container, item);
+        }
+        else {
+            return IVL.doProperContains(container, item, this.precision);
+        }
+    }
+}
+exports.ProperIn = ProperIn;
+class ProperContains extends expression_1.Expression {
+    constructor(json) {
+        super(json);
+        this.precision = json.precision != null ? json.precision.toLowerCase() : undefined;
+    }
+    async exec(ctx) {
+        const [container, item] = await this.execArgs(ctx);
+        if (container == null) {
+            return false;
+        }
+        if ((0, util_1.typeIsArray)(container)) {
+            return LIST.doProperContains(container, item);
+        }
+        else {
+            return IVL.doProperContains(container, item, this.precision);
+        }
+    }
+}
+exports.ProperContains = ProperContains;
 class Length extends expression_1.Expression {
     constructor(json) {
         super(json);

src/datatypes/interval.ts

@@ -114,6 +114,18 @@ export class Interval {
     );
   }
 
+  properContains(item: any, precision?: any) {
+    if (item == null) {
+      return null;
+    } else if (item.isInterval) {
+      throw new Error('Argument to contains must be a point');
+    }
+    return ThreeValuedLogic.and(
+      cmp.lessThan(this.start(), item, precision),
+      cmp.greaterThan(this.end(), item, precision)
+    );
+  }
+
   properlyIncludes(other: any, precision?: any) {
     if (other == null || !other.isInterval) {
       throw new Error('Argument to properlyIncludes must be an interval');

src/elm/expressions.ts

@@ -36,7 +36,8 @@ import {
   doIntersect,
   doIncludes,
   doExcept,
-  doContains
+  doContains,
+  doProperContains
 } from './interval';
 
 export {
@@ -47,5 +48,6 @@ export {
   doIntersect,
   doIncludes,
   doExcept,
-  doContains
+  doContains,
+  doProperContains
 };

src/elm/interval.ts

@@ -67,6 +67,11 @@ export function doContains(interval: any, item: any, precision?: any) {
   return interval.contains(item, precision);
 }
 
+// Delegated to by overloaded#ProperContains and overloaded#ProperIn
+export function doProperContains(interval: any, item: any, precision?: any) {
+  return interval.properContains(item, precision);
+}
+
 // Delegated to by overloaded#Includes and overloaded#IncludedIn
 export function doIncludes(interval: any, subinterval: any, precision?: any) {
   return interval.includes(subinterval, precision);

src/elm/list.ts

@@ -141,6 +141,16 @@ export function doContains(container: any[], item: any) {
   );
 }
 
+// Delegated to by overloaded#ProperContains and overloaded#ProperIn
+export function doProperContains(container: any[], item: any) {
+  // The "proper" membership operators have list semantics, not set semantics.
+  // The intent here is that given list semantics and a `distinct` operator,
+  // one can achieve set semantics, but the reverse isn't possible.
+  // These proper membership operators can then be described as
+  // the regular membership operators, plus the list is strictly larger.
+  return container.length > 1 && doContains(container, item);
+}
+
 // Delegated to by overloaded#Includes and overloaded@IncludedIn
 export function doIncludes(list: any, sublist: any) {
   if (list == null || sublist == null) {

src/elm/overloaded.ts

@@ -269,6 +269,48 @@ export class ProperIncludedIn extends Expression {
   }
 }
 
+export class ProperIn extends Expression {
+  precision?: any;
+
+  constructor(json: any) {
+    super(json);
+    this.precision = json.precision != null ? json.precision.toLowerCase() : undefined;
+  }
+
+  async exec(ctx: Context) {
+    const [item, container] = await this.execArgs(ctx);
+    if (container == null) {
+      return false;
+    }
+    if (typeIsArray(container)) {
+      return LIST.doProperContains(container, item);
+    } else {
+      return IVL.doProperContains(container, item, this.precision);
+    }
+  }
+}
+
+export class ProperContains extends Expression {
+  precision?: any;
+
+  constructor(json: any) {
+    super(json);
+    this.precision = json.precision != null ? json.precision.toLowerCase() : undefined;
+  }
+
+  async exec(ctx: Context) {
+    const [container, item] = await this.execArgs(ctx);
+    if (container == null) {
+      return false;
+    }
+    if (typeIsArray(container)) {
+      return LIST.doProperContains(container, item);
+    } else {
+      return IVL.doProperContains(container, item, this.precision);
+    }
+  }
+}
+
 export class Length extends Expression {
   constructor(json: any) {
     super(json);