discombobulator 1.0.0

package/src/set.mjs

@@ -0,0 +1,1159 @@
+// Set
+//
+// Base class for sets and sequences.
+
+import util from "util";
+
+import { Element } from "./element.mjs";
+
+export class Set extends Element {
+  elements = []; // Array of elements for concrete sets.
+  #isAbstract = false; // True if set is abstract, false if concrete.
+  #allowDuplicates = false; // True if duplicates are allowed (sequence), false if not (set).
+  #strict = true; // True if strict equality should be applied to elements in the set.
+  #allowedElementTypes = undefined; // Explicitly specified allowed element types for
+  // arbitrary sets (those created from Set directly rather than
+  // being inherited from it)
+
+  // Construct a Set.
+  //
+  // options may contain:
+  //  isAbstract      true if this set is abstract, otherwise it will be concrete.
+  //  allowDuplicates true if this set may contain duplicates, making it a sequence.
+  //  add             an element or array of elements to be added to this set upon construction.
+  //  strict          true if strict equality comparisons should be made between elements.
+  constructor(options = {}) {
+    super();
+
+    const defaults = {
+      isAbstract: false,
+      allowDuplicates: false,
+      add: undefined,
+      strict: true,
+      allowedElements: undefined,
+    };
+    options = { ...defaults, ...options };
+
+    this.#isAbstract = options.isAbstract;
+    this.#allowDuplicates = options.allowDuplicates;
+    this.#strict = options.strict;
+    this.#allowedElementTypes = options.allowedElements;
+
+    if (!this.isAbstract && options.add !== undefined) {
+      this.add(options.add);
+    }
+  }
+
+  // Returns an array of allowed element types. MUST BE IMPLEMENTED IN SUB CLASS.
+  get allowedElements() {
+    return this.#allowedElementTypes;
+  }
+
+  get [Symbol.toStringTag]() {
+    return "Set";
+  }
+
+  get isAbstract() {
+    return this.#isAbstract;
+  }
+
+  get allowDuplicates() {
+    return this.#allowDuplicates;
+  }
+
+  get isStrict() {
+    return this.#strict;
+  }
+
+  get size() {
+    return this.elements.length;
+  }
+
+  // If possible and necessary, promotes the given element to the same
+  // type as this element.
+  //
+  // If the given element is already of the same type as this one, then
+  // the given element is returned unchanged.
+  //
+  // If the element can be promoted by the element, then it is added to
+  // this set.
+  //
+  // If the element cannot be promoted, undefined is returned.
+  promote(element) {
+    if (!(element && element instanceof Element)) return undefined;
+
+    if (this.constructor === element.constructor) {
+      return element;
+    }
+
+    if (!this.isAbstract) {
+      const allowedElements = this.allowedElements;
+
+      // Allow any Element if no allowedElements specified.
+      if (!allowedElements) return element;
+
+      // Check the immediately allowable element types.
+      for (const elementClass of allowedElements) {
+        if (element instanceof elementClass) {
+          this.internalAdd(element);
+          return this;
+        }
+      }
+
+      // Now try to follow up the promotion chain.
+      let promoted = undefined;
+
+      for (const elementClass of allowedElements) {
+        let proxy = new elementClass();
+        promoted = proxy.promote(element);
+
+        if (promoted !== undefined) {
+          this.internalAdd(promoted);
+          return this;
+        }
+      }
+    }
+
+    return undefined;
+  }
+
+  isEqual(other) {
+    if (!super.isEqual(other)) return false;
+
+    if (this.size !== other.size) return false;
+
+    if (this.isStrict) {
+      let otherIterator = other[Symbol.iterator]();
+
+      for (let element of this) {
+        let value = otherIterator.next().value;
+
+        if (!element.isEqual(value)) {
+          return false;
+        }
+      }
+    }
+
+    return this.isStrict || (this.isSubsetOf(other) && other.isSubsetOf(this));
+  }
+
+  #assertMutable() {
+    if (this.isAbstract) throw new Error("Attempt to modify immutable set");
+  }
+
+  [util.inspect.custom](depth, opts) {
+    return `${this[Symbol.toStringTag]} {${util.inspect(this.elements)}}`;
+  }
+
+  // Set generator/iterator. By default, just enumerate the elements in the set.
+  *[Symbol.iterator]() {
+    for (let element of this.elements) {
+      yield element;
+    }
+  }
+
+  // SetOf provides a canonical way of describing a set as a hierarchy of sets of
+  // other sets or primitive types (Elements). It allows unambiguous comparison of
+  // set type independent of the class inheritence hierarchy.
+  static SetOf = class extends Set {
+    #setof = undefined;
+
+    constructor(setof, deep = false) {
+      if (setof === undefined) {
+        throw new Error(
+          "SetOf requires a set of allowed elements or another SetOf"
+        );
+      }
+
+      super();
+
+      this.#setof = [];
+
+      if (Array.isArray(setof)) {
+        for (let elementType of setof) {
+          this.#initSetOf(elementType, deep);
+        }
+      } else {
+        this.#initSetOf(setof, deep);
+      }
+    }
+
+    #initSetOf(elementType, deep = false) {
+      if (elementType !== undefined) {
+        let element = new elementType();
+
+        if (element instanceof Element) {
+          if (deep && typeof elementType === "function") {
+            if (element instanceof Set) {
+              this.#setof.push(new Set.SetOf(element.allowedElements, true));
+            } else {
+              this.#setof.push(elementType);
+            }
+          } else {
+            this.#setof.push(elementType);
+          }
+        } else {
+          throw new Error(
+            `SetOf: elements must derive from Element: ${elementType}`
+          );
+        }
+      } else {
+        throw new Error("SetOf: element type undefined");
+      }
+    }
+
+    get setof() {
+      return this.#setof;
+    }
+
+    get [Symbol.toStringTag]() {
+      return "SetOf";
+    }
+
+    [util.inspect.custom](depth, opts) {
+      return `${this[Symbol.toStringTag]} {${util.inspect(this.#setof)}}`;
+    }
+
+    get name() {
+      return this[util.inspect.custom]();
+    }
+
+    equals(other) {
+      let thisSetOf = this.#setof;
+      let otherSetOf = other.#setof;
+
+      if (thisSetOf.length != otherSetOf.length) return false;
+
+      let index = 0;
+      let otherElementType;
+
+      // Note: testing is done in lock step because SetOf are generated based on the
+      // static definition of the classes, so should always be in the same order.
+      for (let elementType of thisSetOf) {
+        otherElementType = otherSetOf[index++];
+
+        if (elementType instanceof Set.SetOf) {
+          if (
+            !(otherElementType instanceof Set.SetOf) ||
+            !elementType.equals(otherElementType)
+          ) {
+            return false;
+          }
+        } else {
+          if (
+            otherElementType instanceof Set.SetOf ||
+            elementType !== otherElementType
+          ) {
+            return false;
+          }
+        }
+      }
+
+      return true;
+    }
+  };
+
+  #setof = {};
+
+  asSetOf(deep = false) {
+    return this.#setof[deep] !== undefined
+      ? this.#setof[deep]
+      : (this.#setof[deep] = new Set.SetOf(this.allowedElements, deep));
+  }
+
+  // Validates that the other Set given is of the same type as this one
+  // by ensuring both sets allow the same set of element types.
+  validateOther(other) {
+    return this.asSetOf(true).equals(other.asSetOf(true));
+  }
+
+  // Determines whether the given element is allowable in this set (even for derived Sets).
+  //
+  // An element is allowed if:
+  //  * it is derived from Element, and
+  //  * this set allows any element type (ie. does not define #allowedElements), or
+  //  * the element is of a type in the allowed elements for this set, or
+  //  * the element can be promoted to a type in the allowed elements for this set.
+  //
+  // If the element is allowed then a reference to itself, or a promoted version of
+  // itself, is returned. If the element is not allowed, undefined is returned.
+  isElementAllowed(element) {
+    if (!(element && element instanceof Element)) return undefined;
+
+    const allowedElements = this.allowedElements;
+
+    // Allow any Element if no allowedElements specified.
+    if (!allowedElements) return element;
+
+    // Check if element is an allowed element type.
+    for (const elementClass of allowedElements) {
+      if (element instanceof elementClass) {
+        return element;
+      }
+    }
+
+    // It's not an allowed element type, but might be promotable to an allowed type.
+    let promoted = undefined;
+
+    for (const elementClass of allowedElements) {
+      let proxy = new elementClass();
+      promoted = proxy.promote(element);
+
+      if (promoted !== undefined) {
+        return promoted;
+      }
+    }
+
+    return undefined;
+  }
+
+  // Do the hard work of adding an element to this set, if it allows it.
+  // If the element already exists in the set and duplicates are not allowed,
+  // then the index of the existing element in the set is returned, otherwise
+  // -1 is returned. This allows derived classes to take custom action when
+  // an existing element is added. For example, Chord overides internalAdd to
+  // allow equivalent Notes to be merged.
+  //
+  // strict is passed through to isEqual, and if true ensures strict equality
+  // is applied. This is relevant for Notes, whose equality semantics varies
+  // depending on whether they are being stored in a Chord or NoteSet.
+  internalAdd(element) {
+    if (this.allowDuplicates || this.elements.length < 1) {
+      this.elements.push(element);
+    } else {
+      const found = this.elements.findIndex((e) =>
+        e.isEqual(element, this.isStrict)
+      );
+
+      if (found < 0) {
+        this.elements.push(element);
+      } else {
+        return found;
+      }
+    }
+
+    return -1;
+  }
+
+  // Add an element to the set.
+  //
+  // The element must be an array of allowable elements,
+  // or an allowable Element type for the Set,
+  // or a Set, in which case any allowable elements it contains
+  // are added to this set.
+  add(element) {
+    this.#assertMutable();
+
+    if (Array.isArray(element)) {
+      for (let arrayElement of element) {
+        this.add(arrayElement);
+      }
+    } else {
+      let promoted = this.isElementAllowed(element);
+
+      if (promoted === undefined) {
+        if (element instanceof Set) {
+          for (let e of element) {
+            e = this.isElementAllowed(e);
+
+            if (e !== undefined) {
+              this.internalAdd(e);
+            }
+          }
+        } else {
+          throw new Error("Attempt to add incorrect element type to set");
+        }
+      } else {
+        this.internalAdd(promoted);
+      }
+    }
+
+    return this;
+  }
+
+  // Append the elements of the given set to this one. The other set must be equivalent to this one.
+  //
+  // Note that this is intended to be used with a concrete set, but will work with an abstract set.
+  // Just be aware that it will attempt to append every element of the other set, so if it is a large
+  // abstract set, this could involve considerable overhead. It is better to form a union with an
+  // abstract set.
+  append(set) {
+    this.#assertMutable();
+
+    if (!(set && set.constructor === this.constructor))
+      throw new Error("Attempt to append incorrect set type to set");
+
+    for (let element of set) {
+      this.internalAdd(element);
+    }
+
+    return this;
+  }
+
+  // Clears all the elements from this Set.
+  // Only effective on concrete sets. Ignored on abstract sets.
+  clear() {
+    this.#assertMutable();
+
+    this.elements = [];
+
+    return this;
+  }
+
+  // Return a clone of this set.
+  //
+  // If deep is true and this set is mutable, each element will also be deeply cloned,
+  // otherwise the elements contained by this set will be copied by reference.
+  clone(deep = false, options = {}) {
+    let clone = new this.constructor({
+      isAbstract: this.#isAbstract,
+      allowDuplicates: this.#allowDuplicates,
+      strict: this.#strict,
+      allowedElements: this.#allowedElementTypes,
+      ...options,
+    });
+
+    if (!this.isAbstract && this.elements !== undefined) {
+      for (let element of this) {
+        if (deep && element.clone !== undefined) {
+          clone.add(element.clone(deep));
+        } else {
+          clone.add(element);
+        }
+      }
+    }
+
+    return clone;
+  }
+
+  // Delete the specified element from the Set if it exists.
+  // Only effective on concrete sets. Ignored on abstract sets.
+
+  // Throws an Error if this set is immutable.
+  // Returns true of the element was found and deleted, false if it
+  // wasn't found.
+  delete(element) {
+    this.#assertMutable();
+
+    const found = this.elements.findIndex((e) => e.isEqual(element));
+
+    if (found >= 0) {
+      this.elements.splice(found, 1);
+      return true;
+    }
+
+    return false;
+  }
+
+  // Return the element at the given index in the set.
+  elementAt(index = 0) {
+    if (index >= 0 && index < this.elements.length) return this.elements[index];
+
+    throw new Error("Invalid index");
+  }
+
+  // Performs the given callbackFn on each element in the Set.
+  //
+  // The callbackFn is called as:
+  //  callbackFn(element, element, this) to be consistent with Map and array.
+  forEach(callbackFn) {
+    for (let element of this) {
+      callbackFn(element, element, this);
+    }
+  }
+
+  // Returns whether the given Set contains no elements in common with this one.
+  //
+  // The other Set must be the same type as this one.
+  isDisjointFrom(other) {
+    if (!this.validateOther(other))
+      throw new Error("Set.isDisjointFrom requires equivalent set types");
+
+    for (const e of this) {
+      if (other.has(e)) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  // Returns whether this Set is a subset of another one.
+  //
+  // The other Set must be the same class as this one.
+  // Returns false if this set is empty.
+  isSubsetOf(other) {
+    if (!this.validateOther(other))
+      throw new Error("Set.isSubsetOf requires equivalent set types");
+
+    if (this.size === 0) return false;
+
+    for (const e of this) {
+      if (!other.has(e)) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  // Returns whether the given element exists in this Set.
+  //
+  // If element is actually a non-empty set of the same type as this one, then
+  // true is returned if it is a subset of this one, false is returned if it is
+  // empty or not a subset.
+  //
+  // Other elements may be promoted prior to searching.
+  has(element) {
+    if (this.size === 0) return false;
+
+    if (element.constructor === this.constructor) {
+      return element.size > 0 ? element.isSubsetOf(this) : false;
+    }
+
+    const promoted = this.isElementAllowed(element);
+
+    return promoted !== undefined
+      ? this.elements.findIndex((e) => e.isEqual(promoted)) >= 0
+      : false;
+  }
+
+  // Returns the index of the element in the set, if it exists, -1 otherwise.
+  indexOf(element, after = -1) {
+    if (element === undefined || !(element instanceof Element)) {
+      throw new Error("indexOf requires an element derived from Element");
+    }
+
+    const promoted = this.isElementAllowed(element);
+
+    let index = 0;
+
+    for (let e of this) {
+      if (index > after && e.isEqual(promoted)) return index;
+
+      ++index;
+    }
+
+    return -1;
+  }
+
+  // Operator creation methods----------------------------------------------
+
+  static createCross = undefined;
+
+  // Returns a Set that is the Cartesian product of this Set and the other Set.
+  //
+  // The other Set must be the same type as this one. The returned Set will also
+  cross(other) {
+    return Set.createCross(this, other);
+  }
+
+  // Returns a Set that is the difference between this Set and the other Set.
+  //
+  // The other Set must be the same type as this one. The returned Set will also
+  // be the same class as this one.
+  difference(other) {
+    return new Set.Difference(this, other);
+  }
+
+  // Returns a Set that is the intersection of this Set and the other Set.
+  //
+  // The other Set must be the same type as this one. The returned Set will also
+  // be the same class as this one.
+  intersection(other) {
+    return new Set.Intersection(this, other);
+  }
+
+  // Returns an abstract set that contains the set of rotations of each element of this set.
+  //
+  // options may contain:
+  //  rotateLeft  If true rotation is performed to the left, otherwise to the right.
+  rotate(options = {}) {
+    return new Set.Rotation(this, this.constructor, {
+      ...options,
+    });
+  }
+
+  // Returns a Set that is the symmetric difference between this Set and the other Set.
+  // ie. the resultant Set contains all the elements from this Set and the other one that
+  // are not in both Sets.
+  //
+  // The other Set must be the same class as this one. The returned Set will also
+  // be the same class as this one.
+  symmetricDifference(other) {
+    return new Set.SymmetricDifference(this, other);
+  }
+
+  // Returns a new Set of the same class as this one that is the union of this Set and the other one.
+  //
+  // The other Set must be the same class as this one. The returned Set will also
+  // be the same class as this one.
+  union(other) {
+    return new Set.Union(this, other);
+  }
+
+  // Operator Definitions------------------------------------------------------
+
+  // Operator: Base class for set operators.
+  static Operator = class extends Set {
+    constructor(options = {}) {
+      options = { ...options, isAbstract: true };
+
+      super(options);
+    }
+
+    get [Symbol.toStringTag]() {
+      return "Operator";
+    }
+
+    get smallestSet() {
+      return this.elements[0].size <= this.elements[1].size ? 0 : 1;
+    }
+
+    inspect() {
+      let inspect = "";
+
+      for (let element of this) {
+        inspect += (inspect.length > 0 ? ", " : "") + util.inspect(element);
+      }
+
+      return inspect;
+    }
+
+    [util.inspect.custom](depth, opts) {
+      return `${this[Symbol.toStringTag]} {${this.inspect()}}`;
+    }
+
+    get size() {
+      throw new Error("Derived class does not implement size getter");
+    }
+
+    internalHas(element) {
+      throw new Error("Derived class does not implement has()");
+    }
+
+    has(element) {
+      if (this.isElementAllowed(element)) {
+        // The element is an allowed element as is, check to see if it matches.
+        return this.internalHas(element);
+      } else if (this.validateOther(element)) {
+        // The element is actually an equivalent set to this one and each
+        // item in element needs to be checked individually.
+        for (let item of element) {
+          if (!this.has(item)) return false;
+        }
+
+        return true;
+      }
+
+      return false;
+    }
+  };
+
+  static UnaryOperator = class extends Set.Operator {
+    #setClass = undefined; // Class of elements represented in this rotation set.
+
+    // set      The set to be operatoed on. The given set is promoted to setClass if possible.
+    // setClass The class expected for the set to be operated on (or a constructor).
+    constructor(set, setClass, options = {}) {
+      options = {
+        ...options,
+        allowDuplicates: false,
+        allowedElements: [setClass],
+      };
+
+      if (!setClass || typeof setClass !== "function") {
+        throw new Error("Invalid argument - set class missing or invalid");
+      }
+
+      let promoted = new setClass();
+      set = promoted.promote(set);
+
+      if (!set || !(set instanceof Set)) {
+        throw new Error("Invalid argument - incompatible set class");
+      }
+
+      super(options);
+
+      this.#setClass = setClass;
+      this.elements = [set];
+    }
+
+    get setClass() {
+      return this.#setClass;
+    }
+
+    get set() {
+      return this.elements[0];
+    }
+
+    [util.inspect.custom](depth, opts) {
+      let elements = "";
+
+      for (const element of this) {
+        elements += (elements.length == 0 ? "" : ", ") + util.inspect(element);
+      }
+
+      return `${this[Symbol.toStringTag]} {[${elements}]}`;
+    }
+
+    get size() {
+      return this.set.size;
+    }
+
+    internalHas(element) {
+      if (this.isElementAllowed(element)) {
+        // The element is an allowed element as is, check to see if it matches.
+        for (let item of this) {
+          if (item.isEqual(element)) return true;
+        }
+      } else if (this.validateOther(element)) {
+        // The element is actually an equivalent set to this one and each
+        // item in element needs to be checked individually.
+        for (let item of element) {
+          if (!this.has(item)) return false;
+        }
+
+        return true;
+      }
+
+      return false;
+    }
+  }
+
+  static BinaryOperator = class extends Set.Operator {
+    #skipValidation = false;
+
+    constructor(set1, set2, options = {}) {
+      if (set1 === undefined || set2 === undefined) {
+        throw new Error("Operator requires both sets to be defined");
+      }
+
+      options = { skipValidation: false, ...options };
+
+      // Set operations are only valid on sets of the same type.
+      if (!options.skipValidation && !set1.validateOther(set2)) {
+        throw new Error("Invalid sets");
+      }
+
+      super(options);
+
+      this.#skipValidation = options.skipValidation;
+
+      this.elements = [set1, set2];
+    }
+
+    get skipValidation() {
+      return this.#skipValidation;
+    }
+
+    get allowedElements() {
+      // Note: the Operator constructor ensures that both sets allow the exact same element
+      // types, so we could use either one to determine which elements an operator allows.
+      // One exception is when skipValidation is used in construction. In this case, it would
+      // matter, however, the calling class will have to sort that out in those special
+      // circumstances.
+      return this.elements[0].allowedElements;
+    }
+
+    get [Symbol.toStringTag]() {
+      return "BinaryOperator";
+    }
+
+    get smallestSet() {
+      return this.elements[0].size <= this.elements[1].size ? 0 : 1;
+    }
+
+    inspect() {
+      let inspect = "";
+
+      for (let element of this) {
+        inspect += (inspect.length > 0 ? ", " : "") + util.inspect(element);
+      }
+
+      return inspect;
+    }
+
+    [util.inspect.custom](depth, opts) {
+      return `${this[Symbol.toStringTag]} {${this.inspect()}}`;
+    }
+
+    clone(deep = false) {
+      const set1 = this.elements[0];
+      const set2 = this.elements[1];
+
+      const set1Clone = deep
+        ? set1 !== undefined
+          ? set1.clone(deep)
+          : undefined
+        : set1;
+
+      const set2Clone = deep
+        ? set2 !== undefined
+          ? set2.clone(deep)
+          : undefined
+        : set2;
+
+      let clone = new this.constructor(set1Clone, set2Clone, {
+        isAbstract: this.#isAbstract,
+        allowDuplicates: this.#allowDuplicates,
+        strict: this.#strict,
+        skipValidation: this.#skipValidation,
+      });
+
+      return clone;
+    }
+
+    elementAt(index = 0) {
+      if (index >= 0 && index < this.size) {
+        for (let element of this) {
+          if (index-- == 0) {
+            return element;
+          }
+        }
+      }
+
+      throw new Error("Invalid index");
+    }
+  }
+
+  // Difference: All elements in this set not in the other.
+  static Difference = class extends Set.BinaryOperator {
+    #calculatedSize = undefined;
+
+    constructor(set1, set2, options = {}) {
+      super(set1, set2, options);
+    }
+
+    get [Symbol.toStringTag]() {
+      return "Difference";
+    }
+
+    *[Symbol.iterator]() {
+      for (let element of this.elements[0]) {
+        if (!this.elements[1].has(element)) {
+          yield element;
+        }
+      }
+    }
+
+    #calculateSize() {
+      let size = 0;
+
+      for (let element of this.elements[0]) {
+        if (!this.elements[1].has(element)) {
+          ++size;
+        }
+      }
+
+      return size;
+    }
+
+    get size() {
+      if (this.#calculatedSize === undefined) {
+        this.#calculatedSize = this.#calculateSize();
+      }
+
+      return this.#calculatedSize;
+    }
+
+    internalHas(element) {
+      return this.elements[0].has(element) && !this.elements[1].has(element);
+    }
+  };
+
+  // Intersection: All elements in this set and the other.
+  static Intersection = class extends Set.BinaryOperator {
+    #calculatedSize = undefined;
+
+    constructor(set1, set2, options = {}) {
+      super(set1, set2, options);
+    }
+
+    get [Symbol.toStringTag]() {
+      return "Intersection";
+    }
+
+    *[Symbol.iterator]() {
+      const smallestSet = this.smallestSet;
+      const largestSet = 1 - smallestSet;
+
+      for (let element of this.elements[smallestSet]) {
+        if (this.elements[largestSet].has(element)) {
+          yield element;
+        }
+      }
+    }
+
+    #calculateSize() {
+      let size = 0;
+
+      const smallestSet = this.smallestSet;
+      const largestSet = 1 - smallestSet;
+
+      for (let element of this.elements[smallestSet]) {
+        if (this.elements[largestSet].has(element)) {
+          ++size;
+        }
+      }
+
+      return size;
+    }
+
+    get size() {
+      if (this.#calculatedSize === undefined) {
+        this.#calculatedSize = this.#calculateSize();
+      }
+
+      return this.#calculatedSize;
+    }
+
+    has(element) {
+      const smallestSet = this.smallestSet;
+      const largestSet = 1 - smallestSet;
+
+      return (
+        this.elements[smallestSet].has(element) &&
+        this.elements[largestSet].has(element)
+      );
+    }
+  };
+
+  // Rotation: Returns an abstract set that contains the set of rotations of each
+  // element of this set.
+  static Rotation = class extends Set.UnaryOperator {
+    #rotateLeft = true; // Rotate right if false.
+
+    // Rotation constructor.
+    //
+    // Generates an abstract set containing all the sets of rotations
+    // for a given set.
+    //
+    // set      The set to be rotated. The given set is promoted to setClass if possible.
+    // setClass The class expected for the set to be rotated (or a constructor).
+    // options  Options that affect this instance. May include those defined by Set, and
+    //            rotateLeft    If true the rotation is performed left-wise, otherwise
+    //                          it is performed right-wise.
+    constructor(set, setClass, options = {}) {
+      const defaults = { rotateLeft: true };
+
+      options = {
+        ...defaults,
+        ...options,
+      };
+
+      super(set, setClass, options);
+
+      this.#rotateLeft = options.rotateLeft;
+    }
+
+    get rotateLeft() {
+      return this.#rotateLeft;
+    }
+
+    get [Symbol.toStringTag]() {
+      return "Rotation";
+    }
+
+    *[Symbol.iterator]() {
+      const setSize = this.set.size;
+
+      let sets = setSize;
+      let elements = setSize;
+      let set = new this.set.constructor();
+      let skip = false;
+
+      while (sets > 0) {
+        for (let element of this.set) {
+          do {
+            if (this.rotateLeft && skip) {
+              skip = false;
+            } else {
+              skip = false;
+
+              set.add(element);
+              --elements;
+
+              if (elements === 0) {
+                yield set;
+
+                if (--sets > 0) {
+                  set = new this.set.constructor();
+                  elements = setSize;
+                  skip = true;
+                }
+              }
+            }
+          } while (skip && !this.rotateLeft);
+
+          if (sets === 0) break;
+        }
+      }
+    }
+
+    clone(deep = false, options = {}) {
+      return new this.constructor(
+        deep ? this.set.clone(deep) : this.set, this.setClass, {
+        isAbstract: this.#isAbstract,
+        allowDuplicates: this.#allowDuplicates,
+        strict: this.#strict,
+        allowedElements: this.#allowedElementTypes,
+        ...options,
+      });
+    }
+
+    elementAt(index = 0) {
+      let size = this.size;
+
+      if (index >= 0 && index < size) {
+        const delta = this.rotateLeft ? 1 : size - 1;
+        let at = this.rotateLeft ? index : (size - index) % size;
+        let set = new this.set.constructor();
+        let setSize = 0;
+
+        while (setSize < size) {
+          set.add(this.set.elementAt(at));
+          ++setSize;
+
+          at = ++at % size;
+        }
+
+        return set;
+      }
+
+      throw new Error("Invalid index");
+    }
+  };
+
+  // SymmetricDifference: All elements not shared by this set or the other.
+  static SymmetricDifference = class extends Set.BinaryOperator {
+    #calculatedSize = undefined;
+
+    constructor(set1, set2, options = {}) {
+      super(set1, set2, options);
+    }
+
+    get [Symbol.toStringTag]() {
+      return "SymmetricDifference";
+    }
+
+    *[Symbol.iterator]() {
+      for (let element of this.elements[0]) {
+        if (!this.elements[1].has(element)) {
+          yield element;
+        }
+      }
+
+      for (let element of this.elements[1]) {
+        if (!this.elements[0].has(element)) {
+          yield element;
+        }
+      }
+    }
+
+    #calculateSize() {
+      let size = 0;
+
+      for (let element of this.elements[0]) {
+        if (!this.elements[1].has(element)) {
+          ++size;
+        }
+      }
+
+      for (let element of this.elements[1]) {
+        if (!this.elements[0].has(element)) {
+          ++size;
+        }
+      }
+
+      return size;
+    }
+
+    get size() {
+      if (this.#calculatedSize === undefined) {
+        this.#calculatedSize = this.#calculateSize();
+      }
+
+      return this.#calculatedSize;
+    }
+
+    internalHas(element) {
+      const thisHasIt = this.elements[0].has(element);
+      const otherHasIt = this.elements[1].has(element);
+
+      return thisHasIt !== otherHasIt;
+    }
+  };
+
+  // Union: All elements from this set and the other.
+  static Union = class extends Set.BinaryOperator {
+    constructor(set1, set2, options = {}) {
+      super(set1, set2, options);
+    }
+
+    get [Symbol.toStringTag]() {
+      return "Union";
+    }
+
+    *[Symbol.iterator]() {
+      yield* this.elements[0];
+
+      if (this.allowDuplicates) {
+        yield* this.elements[1];
+      } else {
+        for (let element of this.elements[1]) {
+          if (!this.elements[0].has(element)) {
+            yield element;
+          }
+        }
+      }
+    }
+
+    get size() {
+      const smallestSet = this.smallestSet;
+      const largestSet = 1 - smallestSet;
+
+      let size = this.elements[largestSet].size;
+
+      if (this.allowDuplicates) {
+        size += this.elements[smallestSet].size;
+      } else {
+        for (let element of this.elements[smallestSet]) {
+          if (!this.elements[largestSet].has(element)) ++size;
+        }
+      }
+
+      return size;
+    }
+
+    elementAt(index = 0) {
+      if (index >= 0) {
+        let size = this.elements[0].size;
+
+        if (index < size) {
+          return this.elements[0].elementAt(index);
+        }
+
+        index -= size;
+        size = this.elements[1].size;
+
+        if (index < size) {
+          for (let element of this.elements[1]) {
+            if (!this.elements[0].has(element)) {
+              if (index-- == 0) {
+                return element;
+              }
+            }
+          }
+        }
+      }
+
+      throw new Error("Invalid index");
+    }
+
+    has(element) {
+      return this.elements[0].has(element) || this.elements[1].has(element);
+    }
+  };
+  // End Operator Definitions----------------------------------------------------
+}