@tuprolog/2p-full 0.30.5 → 0.31.1-dev02

package/2p-unify.js

@@ -0,0 +1,957 @@
+(function (_, kotlin_kotlin, kotlin_it_unibo_tuprolog_core, kotlin_it_unibo_tuprolog_utils) {
+  'use strict';
+  //region block: imports
+  var imul = Math.imul;
+  var Unit_getInstance = kotlin_kotlin.$_$.r2;
+  var asSequence = kotlin_kotlin.$_$.f3;
+  var plus = kotlin_kotlin.$_$.g9;
+  var map = kotlin_kotlin.$_$.c9;
+  var Companion_getInstance = kotlin_it_unibo_tuprolog_core.$_$.e1;
+  var ArrayList_init_$Create$ = kotlin_kotlin.$_$.c1;
+  var toCollection = kotlin_kotlin.$_$.n9;
+  var Pair = kotlin_kotlin.$_$.qb;
+  var lazy = kotlin_kotlin.$_$.xb;
+  var asSequence_0 = kotlin_kotlin.$_$.g3;
+  var classMeta = kotlin_kotlin.$_$.m6;
+  var setMetadataFor = kotlin_kotlin.$_$.j7;
+  var KProperty1 = kotlin_kotlin.$_$.d8;
+  var getPropertyCallableRef = kotlin_kotlin.$_$.r6;
+  var Companion_getInstance_0 = kotlin_it_unibo_tuprolog_utils.$_$.a;
+  var Triple = kotlin_kotlin.$_$.ub;
+  var Some = kotlin_it_unibo_tuprolog_utils.$_$.k;
+  var zip = kotlin_kotlin.$_$.u9;
+  var flatMap = kotlin_kotlin.$_$.u8;
+  var sequenceOf = kotlin_kotlin.$_$.i9;
+  var THROW_CCE = kotlin_kotlin.$_$.sb;
+  var castTo = kotlin_it_unibo_tuprolog_utils.$_$.f;
+  var to = kotlin_kotlin.$_$.ec;
+  var objectMeta = kotlin_kotlin.$_$.i7;
+  var getKClass = kotlin_kotlin.$_$.c;
+  var ClassCastException_init_$Create$ = kotlin_kotlin.$_$.o1;
+  var Companion_getInstance_1 = kotlin_it_unibo_tuprolog_core.$_$.d1;
+  var Castable = kotlin_it_unibo_tuprolog_utils.$_$.g;
+  var collectionSizeOrDefault = kotlin_kotlin.$_$.j3;
+  var ArrayList_init_$Create$_0 = kotlin_kotlin.$_$.b1;
+  var IllegalArgumentException_init_$Create$ = kotlin_kotlin.$_$.p1;
+  var interfaceMeta = kotlin_kotlin.$_$.u6;
+  //endregion
+  //region block: pre-declaration
+  function mgu(term1, term2) {
+    return this.c1k(term1, term2, true);
+  }
+  function matchWithOccurCheck(term1, term2, occurCheckEnabled) {
+    return !(this.c1k(term1, term2, occurCheckEnabled) === Companion_getInstance().failed());
+  }
+  function match(term1, term2) {
+    return this.matchWithOccurCheck(term1, term2, true);
+  }
+  function unifyWithOccurCheck(term1, term2, occurCheckEnabled) {
+    var substitution = this.c1k(term1, term2, occurCheckEnabled);
+    return substitution.r12() ? null : term1.getSubstituted(substitution, []);
+  }
+  function unify(term1, term2) {
+    return this.unifyWithOccurCheck(term1, term2, true);
+  }
+  function merge(substitution1, substitution2) {
+    return this.mergeWithOccurCheck(substitution1, substitution2, true);
+  }
+  setMetadataFor(Unificator, 'Unificator', interfaceMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(AbstractUnificator, 'AbstractUnificator', classMeta, undefined, [Unificator], undefined, undefined, []);
+  setMetadataFor(CachedUnificator, 'CachedUnificator', classMeta, undefined, [Unificator], undefined, undefined, []);
+  setMetadataFor(Equation, 'Equation', classMeta, undefined, [Castable], undefined, undefined, []);
+  setMetadataFor(Identity, 'Identity', classMeta, Equation, undefined, undefined, undefined, []);
+  setMetadataFor(Assignment, 'Assignment', classMeta, Equation, undefined, undefined, undefined, []);
+  setMetadataFor(Comparison, 'Comparison', classMeta, Equation, undefined, undefined, undefined, []);
+  setMetadataFor(Contradiction, 'Contradiction', classMeta, Equation, undefined, undefined, undefined, []);
+  setMetadataFor(Companion, 'Companion', objectMeta, undefined, undefined, undefined, undefined, []);
+  setMetadataFor(Unificator$Companion$naive$1, undefined, classMeta, AbstractUnificator, undefined, undefined, undefined, []);
+  setMetadataFor(Unificator$Companion$strict$1, undefined, classMeta, AbstractUnificator, undefined, undefined, undefined, []);
+  setMetadataFor(Companion_0, 'Companion', objectMeta, undefined, undefined, undefined, undefined, []);
+  //endregion
+  function _get_contextEquations__x0dd77($this) {
+    var tmp$ret$0;
+    // Inline function 'kotlin.getValue' call
+    var tmp0_getValue = contextEquations$factory();
+    tmp$ret$0 = $this.j1j_1.b1();
+    return tmp$ret$0;
+  }
+  function occurrenceCheck($this, variable, term) {
+    var tmp;
+    if (term.bx()) {
+      tmp = $this.k1j(variable, term);
+    } else if (term.lw()) {
+      var tmp$ret$1;
+      $l$block: {
+        // Inline function 'kotlin.sequences.any' call
+        var tmp0_any = term.hw();
+        var tmp0_iterator = tmp0_any.j();
+        while (tmp0_iterator.m()) {
+          var element = tmp0_iterator.p();
+          var tmp$ret$0;
+          // Inline function 'it.unibo.tuprolog.unify.AbstractUnificator.occurrenceCheck.<anonymous>' call
+          tmp$ret$0 = occurrenceCheck($this, variable, element);
+          if (tmp$ret$0) {
+            tmp$ret$1 = true;
+            break $l$block;
+          }
+        }
+        tmp$ret$1 = false;
+      }
+      tmp = tmp$ret$1;
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  }
+  function equationsFor($this, term1, term2) {
+    var tmp = Companion_getInstance_2();
+    return tmp.l1j(term1, term2, AbstractUnificator$checkTermsEquality$ref($this));
+  }
+  function equationsFor_0($this, substitution1, substitution2) {
+    var tmp = Companion_getInstance_2();
+    var tmp_0 = plus(asSequence(substitution1), asSequence(substitution2));
+    var tmp_1 = map(tmp_0, AbstractUnificator$equationsFor$lambda);
+    return tmp.m1j(tmp_1, null, 2, null);
+  }
+  function applySubstitutionToEquations($this, substitution, equations, exceptIndex) {
+    var changed = {_v: false};
+    var inductionVariable = 0;
+    if (inductionVariable < exceptIndex)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        applySubstitutionToEquations$handleIndex(equations, substitution, $this, changed, i);
+      }
+       while (inductionVariable < exceptIndex);
+    var inductionVariable_0 = exceptIndex + 1 | 0;
+    var last = equations.o();
+    if (inductionVariable_0 < last)
+      do {
+        var i_0 = inductionVariable_0;
+        inductionVariable_0 = inductionVariable_0 + 1 | 0;
+        applySubstitutionToEquations$handleIndex(equations, substitution, $this, changed, i_0);
+      }
+       while (inductionVariable_0 < last);
+    return changed._v;
+  }
+  function mgu_0($this, equations, occurCheckEnabled) {
+    var changed = true;
+    while (changed) {
+      changed = false;
+      var eqIterator = equations.bb();
+      while (eqIterator.m()) {
+        var eq = eqIterator.p();
+        if (eq.r1j()) {
+          return Companion_getInstance().failed();
+        } else if (eq.s1j()) {
+          eqIterator.u4();
+          changed = true;
+        } else if (eq.z1j()) {
+          var assignment = eq.u1j();
+          if (occurCheckEnabled ? occurrenceCheck($this, assignment.x1j_1, eq.q1j()) : false) {
+            return Companion_getInstance().failed();
+          } else {
+            changed = changed ? true : applySubstitutionToEquations($this, assignment.toSubstitution(), equations, eqIterator.sa());
+          }
+        } else if (eq.t1j()) {
+          eqIterator.u4();
+          var tmp0_iterator = equationsFor($this, eq.p1j(), eq.q1j()).j();
+          insertion: while (tmp0_iterator.m()) {
+            var it = tmp0_iterator.p();
+            if (it.s1j())
+              continue insertion;
+            else if (it.r1j())
+              return Companion_getInstance().failed();
+            else {
+              eqIterator.va(it);
+            }
+          }
+          changed = true;
+        }
+      }
+    }
+    var tmp$ret$2;
+    // Inline function 'kotlin.collections.filter' call
+    var tmp$ret$1;
+    // Inline function 'kotlin.collections.filterTo' call
+    var tmp0_filterTo = ArrayList_init_$Create$();
+    var tmp0_iterator_0 = equations.j();
+    while (tmp0_iterator_0.m()) {
+      var element = tmp0_iterator_0.p();
+      var tmp$ret$0;
+      // Inline function 'it.unibo.tuprolog.unify.AbstractUnificator.mgu.<anonymous>' call
+      tmp$ret$0 = element.z1j();
+      if (tmp$ret$0) {
+        tmp0_filterTo.g(element);
+      }
+    }
+    tmp$ret$1 = tmp0_filterTo;
+    tmp$ret$2 = tmp$ret$1;
+    return toSubstitution(tmp$ret$2);
+  }
+  function newDeque($this, items) {
+    var tmp$ret$0;
+    // Inline function 'kotlin.collections.arrayListOf' call
+    tmp$ret$0 = ArrayList_init_$Create$();
+    return toCollection(items, tmp$ret$0);
+  }
+  function applySubstitutionToEquations$handleIndex($equations, $substitution, this$0, changed, i) {
+    if ($equations.n(i).r1j() ? true : $equations.n(i).s1j())
+      return Unit_getInstance();
+    var currentEq = $equations.n(i);
+    var tmp0_container = currentEq.a1k($substitution, null, 2, null).toPair();
+    var newLhs = tmp0_container.n3();
+    var newRhs = tmp0_container.o3();
+    if (!currentEq.p1j().equals(newLhs) ? true : !currentEq.q1j().equals(newRhs)) {
+      var tmp = Companion_getInstance_2();
+      $equations.s4(i, tmp.b1k(newLhs, newRhs, AbstractUnificator$checkTermsEquality$ref_0(this$0)));
+      changed._v = true;
+    }
+  }
+  function AbstractUnificator$contextEquations$delegate$lambda(this$0) {
+    return function () {
+      return toEquations(this$0.j5());
+    };
+  }
+  function AbstractUnificator$checkTermsEquality$ref($boundThis) {
+    var l = function (p0, p1) {
+      return $boundThis.k1j(p0, p1);
+    };
+    l.callableName = 'checkTermsEquality';
+    return l;
+  }
+  function AbstractUnificator$equationsFor$lambda(it) {
+    var tmp$ret$0;
+    // Inline function 'kotlin.collections.toPair' call
+    tmp$ret$0 = new Pair(it.a1(), it.b1());
+    return tmp$ret$0;
+  }
+  function AbstractUnificator$checkTermsEquality$ref_0($boundThis) {
+    var l = function (p0, p1) {
+      return $boundThis.k1j(p0, p1);
+    };
+    l.callableName = 'checkTermsEquality';
+    return l;
+  }
+  function AbstractUnificator(context) {
+    this.i1j_1 = context;
+    var tmp = this;
+    tmp.j1j_1 = lazy(AbstractUnificator$contextEquations$delegate$lambda(this));
+  }
+  AbstractUnificator.prototype.j5 = function () {
+    return this.i1j_1;
+  };
+  AbstractUnificator.prototype.c1k = function (term1, term2, occurCheckEnabled) {
+    if (this.j5().r12())
+      return Companion_getInstance().failed();
+    var equations = newDeque(this, plus(asSequence_0(_get_contextEquations__x0dd77(this)), equationsFor(this, term1, term2)));
+    return mgu_0(this, equations, occurCheckEnabled);
+  };
+  AbstractUnificator.prototype.d1k = function (substitution1, substitution2, occurCheckEnabled) {
+    if ((this.j5().r12() ? true : substitution1.r12()) ? true : substitution2.r12())
+      return Companion_getInstance().failed();
+    if (!occurCheckEnabled) {
+      var quickMerge = this.j5().plus(substitution1).plus(substitution2);
+      if (quickMerge.q12()) {
+        return quickMerge;
+      }
+    }
+    var equations = newDeque(this, plus(asSequence_0(_get_contextEquations__x0dd77(this)), equationsFor_0(this, substitution1, substitution2)));
+    return mgu_0(this, equations, occurCheckEnabled);
+  };
+  AbstractUnificator.prototype.mergeWithOccurCheck = function (substitution1, substitution2, occurCheckEnabled) {
+    return this.d1k(substitution1, substitution2, occurCheckEnabled);
+  };
+  function contextEquations$factory() {
+    return getPropertyCallableRef('contextEquations', 1, KProperty1, function (receiver) {
+      return _get_contextEquations__x0dd77(receiver);
+    }, null);
+  }
+  function CachedUnificator(decorated, cacheCapacity) {
+    this.e1k_1 = decorated;
+    this.f1k_1 = Companion_getInstance_0().gq(cacheCapacity);
+  }
+  CachedUnificator.prototype.c1k = function (term1, term2, occurCheckEnabled) {
+    var mguRequest = new Triple(term1, term2, occurCheckEnabled);
+    var cached = this.f1k_1.a3(mguRequest);
+    var tmp;
+    if (cached instanceof Some) {
+      tmp = cached.jq_1;
+    } else {
+      var mguResult = this.e1k_1.c1k(term1, term2, occurCheckEnabled);
+      this.f1k_1.hq(mguRequest, mguResult);
+      tmp = mguResult;
+    }
+    return tmp;
+  };
+  CachedUnificator.prototype.d1k = function (substitution1, substitution2, occurCheckEnabled) {
+    var mguRequest = new Triple(substitution1, substitution2, occurCheckEnabled);
+    var cached = this.f1k_1.a3(mguRequest);
+    var tmp;
+    if (cached instanceof Some) {
+      tmp = cached.jq_1;
+    } else {
+      var mguResult = this.e1k_1.mergeWithOccurCheck(substitution1, substitution2, occurCheckEnabled);
+      this.f1k_1.hq(mguRequest, mguResult);
+      tmp = mguResult;
+    }
+    return tmp;
+  };
+  CachedUnificator.prototype.mergeWithOccurCheck = function (substitution1, substitution2, occurCheckEnabled) {
+    return this.d1k(substitution1, substitution2, occurCheckEnabled);
+  };
+  function allOfLists($this, lhs, rhs, equalityChecker) {
+    var tmp = zip(lhs.unfold(), rhs.unfold());
+    return flatMap(tmp, Equation$Companion$allOfLists$lambda(equalityChecker));
+  }
+  function allOfTuples($this, lhs, rhs, equalityChecker) {
+    var tmp = zip(lhs.unfold(), rhs.unfold());
+    return flatMap(tmp, Equation$Companion$allOfTuples$lambda(equalityChecker));
+  }
+  function Term$equals$ref() {
+    var l = function (p0, p1) {
+      return p0.equals(p1);
+    };
+    l.callableName = 'equals';
+    return l;
+  }
+  function Term$equals$ref_0() {
+    var l = function (p0, p1) {
+      return p0.equals(p1);
+    };
+    l.callableName = 'equals';
+    return l;
+  }
+  function Term$equals$ref_1() {
+    var l = function (p0, p1) {
+      return p0.equals(p1);
+    };
+    l.callableName = 'equals';
+    return l;
+  }
+  function Equation$Companion$from$lambda($equalityChecker) {
+    return function (it) {
+      return Companion_getInstance_2().g1k(it, $equalityChecker);
+    };
+  }
+  function Term$equals$ref_2() {
+    var l = function (p0, p1) {
+      return p0.equals(p1);
+    };
+    l.callableName = 'equals';
+    return l;
+  }
+  function Term$equals$ref_3() {
+    var l = function (p0, p1) {
+      return p0.equals(p1);
+    };
+    l.callableName = 'equals';
+    return l;
+  }
+  function Term$equals$ref_4() {
+    var l = function (p0, p1) {
+      return p0.equals(p1);
+    };
+    l.callableName = 'equals';
+    return l;
+  }
+  function Equation$Companion$allOfLists$lambda($equalityChecker) {
+    return function (_name_for_destructuring_parameter_0__wldtmu) {
+      var l = _name_for_destructuring_parameter_0__wldtmu.n3();
+      var r = _name_for_destructuring_parameter_0__wldtmu.o3();
+      return (l.sw() ? r.sw() : false) ? sequenceOf([Companion_getInstance_2().b1k(l.castToCons().ly(), r.castToCons().ly(), $equalityChecker)]) : (l.rw() ? r.rw() : false) ? sequenceOf([Companion_getInstance_2().b1k(l.castToList(), r.castToList(), $equalityChecker)]) : Companion_getInstance_2().l1j(l, r, $equalityChecker);
+    };
+  }
+  function Equation$Companion$allOfTuples$lambda($equalityChecker) {
+    return function (_name_for_destructuring_parameter_0__wldtmu) {
+      var l = _name_for_destructuring_parameter_0__wldtmu.n3();
+      var r = _name_for_destructuring_parameter_0__wldtmu.o3();
+      return (l.qw() ? r.qw() : false) ? sequenceOf([Companion_getInstance_2().b1k(l.castToTuple().zx(), r.castToTuple().zx(), $equalityChecker)]) : Companion_getInstance_2().l1j(l, r, $equalityChecker);
+    };
+  }
+  function Term$equals$ref_5() {
+    var l = function (p0, p1) {
+      return p0.equals(p1);
+    };
+    l.callableName = 'equals';
+    return l;
+  }
+  function Equation$Companion$allOf$lambda($equalityChecker) {
+    return function (it) {
+      return Companion_getInstance_2().g1k(it, $equalityChecker);
+    };
+  }
+  function Identity(lhs, rhs) {
+    Equation.call(this, lhs, rhs);
+    this.j1k_1 = lhs;
+    this.k1k_1 = rhs;
+  }
+  Identity.prototype.p1j = function () {
+    return this.j1k_1;
+  };
+  Identity.prototype.q1j = function () {
+    return this.k1k_1;
+  };
+  Identity.prototype.s1j = function () {
+    return true;
+  };
+  Identity.prototype.toString = function () {
+    return 'Identity(lhs=' + this.j1k_1 + ', rhs=' + this.k1k_1 + ')';
+  };
+  Identity.prototype.hashCode = function () {
+    var result = this.j1k_1.hashCode();
+    result = imul(result, 31) + this.k1k_1.hashCode() | 0;
+    return result;
+  };
+  Identity.prototype.equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Identity))
+      return false;
+    var tmp0_other_with_cast = other instanceof Identity ? other : THROW_CCE();
+    if (!this.j1k_1.equals(tmp0_other_with_cast.j1k_1))
+      return false;
+    if (!this.k1k_1.equals(tmp0_other_with_cast.k1k_1))
+      return false;
+    return true;
+  };
+  function Assignment(lhs, rhs) {
+    Equation.call(this, lhs, rhs);
+    this.x1j_1 = lhs;
+    this.y1j_1 = rhs;
+  }
+  Assignment.prototype.p1j = function () {
+    return this.x1j_1;
+  };
+  Assignment.prototype.q1j = function () {
+    return this.y1j_1;
+  };
+  Assignment.prototype.toSubstitution = function () {
+    return Companion_getInstance().unifier(this.x1j_1, this.y1j_1);
+  };
+  Assignment.prototype.n1k = function () {
+    return to(this.x1j_1, this.y1j_1);
+  };
+  Assignment.prototype.toPair = function () {
+    return this.n1k();
+  };
+  Assignment.prototype.z1j = function () {
+    return true;
+  };
+  Assignment.prototype.l1k = function () {
+    return this;
+  };
+  Assignment.prototype.toString = function () {
+    return 'Assignment(lhs=' + this.x1j_1 + ', rhs=' + this.y1j_1 + ')';
+  };
+  Assignment.prototype.hashCode = function () {
+    var result = this.x1j_1.hashCode();
+    result = imul(result, 31) + this.y1j_1.hashCode() | 0;
+    return result;
+  };
+  Assignment.prototype.equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Assignment))
+      return false;
+    var tmp0_other_with_cast = other instanceof Assignment ? other : THROW_CCE();
+    if (!this.x1j_1.equals(tmp0_other_with_cast.x1j_1))
+      return false;
+    if (!this.y1j_1.equals(tmp0_other_with_cast.y1j_1))
+      return false;
+    return true;
+  };
+  function Comparison(lhs, rhs) {
+    Equation.call(this, lhs, rhs);
+    this.q1k_1 = lhs;
+    this.r1k_1 = rhs;
+  }
+  Comparison.prototype.p1j = function () {
+    return this.q1k_1;
+  };
+  Comparison.prototype.q1j = function () {
+    return this.r1k_1;
+  };
+  Comparison.prototype.t1j = function () {
+    return true;
+  };
+  Comparison.prototype.toString = function () {
+    return 'Comparison(lhs=' + this.q1k_1 + ', rhs=' + this.r1k_1 + ')';
+  };
+  Comparison.prototype.hashCode = function () {
+    var result = this.q1k_1.hashCode();
+    result = imul(result, 31) + this.r1k_1.hashCode() | 0;
+    return result;
+  };
+  Comparison.prototype.equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Comparison))
+      return false;
+    var tmp0_other_with_cast = other instanceof Comparison ? other : THROW_CCE();
+    if (!this.q1k_1.equals(tmp0_other_with_cast.q1k_1))
+      return false;
+    if (!this.r1k_1.equals(tmp0_other_with_cast.r1k_1))
+      return false;
+    return true;
+  };
+  function Contradiction(lhs, rhs) {
+    Equation.call(this, lhs, rhs);
+    this.u1k_1 = lhs;
+    this.v1k_1 = rhs;
+  }
+  Contradiction.prototype.p1j = function () {
+    return this.u1k_1;
+  };
+  Contradiction.prototype.q1j = function () {
+    return this.v1k_1;
+  };
+  Contradiction.prototype.r1j = function () {
+    return true;
+  };
+  Contradiction.prototype.toString = function () {
+    return 'Contradiction(lhs=' + this.u1k_1 + ', rhs=' + this.v1k_1 + ')';
+  };
+  Contradiction.prototype.hashCode = function () {
+    var result = this.u1k_1.hashCode();
+    result = imul(result, 31) + this.v1k_1.hashCode() | 0;
+    return result;
+  };
+  Contradiction.prototype.equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Contradiction))
+      return false;
+    var tmp0_other_with_cast = other instanceof Contradiction ? other : THROW_CCE();
+    if (!this.u1k_1.equals(tmp0_other_with_cast.u1k_1))
+      return false;
+    if (!this.v1k_1.equals(tmp0_other_with_cast.v1k_1))
+      return false;
+    return true;
+  };
+  function Companion() {
+    Companion_instance = this;
+  }
+  Companion.prototype.of = function (lhs, rhs, equalityChecker) {
+    var tmp;
+    if (equalityChecker === void 1) {
+      tmp = Term$equals$ref();
+    } else {
+      tmp = equalityChecker;
+    }
+    return this.b1k(lhs, rhs, tmp);
+  };
+  Companion.prototype.b1k = function (lhs, rhs, equalityChecker) {
+    var tmp;
+    if (lhs.bx() ? rhs.bx() : false) {
+      var tmp_0;
+      if (equalityChecker(lhs, rhs)) {
+        tmp_0 = new Identity(lhs, rhs);
+      } else {
+        tmp_0 = new Assignment(lhs.castToVar(), rhs);
+      }
+      tmp = tmp_0;
+    } else if (lhs.bx()) {
+      tmp = new Assignment(lhs.castToVar(), rhs);
+    } else if (rhs.bx()) {
+      tmp = new Assignment(rhs.castToVar(), lhs);
+    } else if (lhs.ex() ? rhs.ex() : false) {
+      var tmp_1;
+      if (equalityChecker(lhs, rhs)) {
+        tmp_1 = new Identity(lhs, rhs);
+      } else {
+        tmp_1 = new Contradiction(lhs, rhs);
+      }
+      tmp = tmp_1;
+    } else if (lhs.ex() ? true : rhs.ex()) {
+      tmp = new Contradiction(lhs, rhs);
+    } else if (lhs.lw() ? rhs.lw() : false) {
+      var lhsStruct = lhs.castToStruct();
+      var rhsStruct = rhs.castToStruct();
+      var tmp_2;
+      if (!(lhsStruct.zv() === rhsStruct.zv()) ? true : !(lhsStruct.fw() === rhsStruct.fw())) {
+        tmp_2 = new Contradiction(lhsStruct, rhsStruct);
+      } else {
+        tmp_2 = new Comparison(lhsStruct, rhsStruct);
+      }
+      tmp = tmp_2;
+    } else {
+      tmp = new Comparison(lhs, rhs);
+    }
+    return tmp;
+  };
+  Companion.prototype.w1k = function (lhs, rhs, equalityChecker, $mask0, $handler) {
+    if (!(($mask0 & 4) === 0)) {
+      equalityChecker = Term$equals$ref();
+    }
+    return this.b1k(lhs, rhs, equalityChecker);
+  };
+  Companion.prototype.ofPair = function (pair, equalityChecker) {
+    var tmp;
+    if (equalityChecker === void 1) {
+      tmp = Term$equals$ref_0();
+    } else {
+      tmp = equalityChecker;
+    }
+    return this.x1k(pair, tmp);
+  };
+  Companion.prototype.x1k = function (pair, equalityChecker) {
+    return this.b1k(pair.g4_1, pair.h4_1, equalityChecker);
+  };
+  Companion.prototype.fromSequence = function (pairs, equalityChecker) {
+    var tmp;
+    if (equalityChecker === void 1) {
+      tmp = Term$equals$ref_1();
+    } else {
+      tmp = equalityChecker;
+    }
+    return this.y1k(pairs, tmp);
+  };
+  Companion.prototype.y1k = function (pairs, equalityChecker) {
+    return flatMap(pairs, Equation$Companion$from$lambda(equalityChecker));
+  };
+  Companion.prototype.m1j = function (pairs, equalityChecker, $mask0, $handler) {
+    if (!(($mask0 & 2) === 0)) {
+      equalityChecker = Term$equals$ref_1();
+    }
+    return this.y1k(pairs, equalityChecker);
+  };
+  Companion.prototype.fromIterable = function (pairs, equalityChecker) {
+    var tmp;
+    if (equalityChecker === void 1) {
+      tmp = Term$equals$ref_2();
+    } else {
+      tmp = equalityChecker;
+    }
+    return this.z1k(pairs, tmp);
+  };
+  Companion.prototype.z1k = function (pairs, equalityChecker) {
+    return this.y1k(asSequence_0(pairs), equalityChecker);
+  };
+  Companion.prototype.from = function (pairs, equalityChecker) {
+    var tmp;
+    if (equalityChecker === void 1) {
+      tmp = Term$equals$ref_3();
+    } else {
+      tmp = equalityChecker;
+    }
+    return this.a1l(pairs, tmp);
+  };
+  Companion.prototype.a1l = function (pairs, equalityChecker) {
+    return this.y1k(sequenceOf(pairs.slice()), equalityChecker);
+  };
+  Companion.prototype.allOfPair = function (pair, equalityChecker) {
+    var tmp;
+    if (equalityChecker === void 1) {
+      tmp = Term$equals$ref_4();
+    } else {
+      tmp = equalityChecker;
+    }
+    return this.g1k(pair, tmp);
+  };
+  Companion.prototype.g1k = function (pair, equalityChecker) {
+    return this.l1j(pair.g4_1, pair.h4_1, equalityChecker);
+  };
+  Companion.prototype.allOf = function (lhs, rhs, equalityChecker) {
+    var tmp;
+    if (equalityChecker === void 1) {
+      tmp = Term$equals$ref_5();
+    } else {
+      tmp = equalityChecker;
+    }
+    return this.l1j(lhs, rhs, tmp);
+  };
+  Companion.prototype.l1j = function (lhs, rhs, equalityChecker) {
+    var tmp;
+    if (lhs.aw() ? rhs.aw() : false) {
+      tmp = sequenceOf([this.b1k(lhs, rhs, equalityChecker)]);
+    } else if (lhs.rw() ? rhs.rw() : false) {
+      tmp = allOfLists(this, lhs.castToList(), rhs.castToList(), equalityChecker);
+    } else if (lhs.qw() ? rhs.qw() : false) {
+      tmp = allOfTuples(this, lhs.castToTuple(), rhs.castToTuple(), equalityChecker);
+    } else if (lhs.lw() ? rhs.lw() : false) {
+      var lhsStruct = lhs.castToStruct();
+      var rhsStruct = rhs.castToStruct();
+      var tmp_0;
+      if (lhsStruct.zv() === rhsStruct.zv() ? lhsStruct.fw() === rhsStruct.fw() : false) {
+        var tmp_1 = zip(lhsStruct.yw(), rhsStruct.yw());
+        tmp_0 = flatMap(tmp_1, Equation$Companion$allOf$lambda(equalityChecker));
+      } else {
+        tmp_0 = sequenceOf([this.b1k(lhs, rhs, equalityChecker)]);
+      }
+      tmp = tmp_0;
+    } else {
+      tmp = sequenceOf([this.b1k(lhs, rhs, equalityChecker)]);
+    }
+    return tmp;
+  };
+  var Companion_instance;
+  function Companion_getInstance_2() {
+    if (Companion_instance == null)
+      new Companion();
+    return Companion_instance;
+  }
+  function Term$equals$ref_6() {
+    var l = function (p0, p1) {
+      return p0.equals(p1);
+    };
+    l.callableName = 'equals';
+    return l;
+  }
+  function Equation(lhs, rhs) {
+    Companion_getInstance_2();
+    this.n1j_1 = lhs;
+    this.o1j_1 = rhs;
+  }
+  Equation.prototype.p1j = function () {
+    return this.n1j_1;
+  };
+  Equation.prototype.q1j = function () {
+    return this.o1j_1;
+  };
+  Equation.prototype.s1j = function () {
+    return false;
+  };
+  Equation.prototype.z1j = function () {
+    return false;
+  };
+  Equation.prototype.l1k = function () {
+    return null;
+  };
+  Equation.prototype.u1j = function () {
+    var tmp0_elvis_lhs = this.l1k();
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      throw ClassCastException_init_$Create$('Cannot cast ' + this + ' to ' + getKClass(Assignment).kd());
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    return tmp;
+  };
+  Equation.prototype.t1j = function () {
+    return false;
+  };
+  Equation.prototype.r1j = function () {
+    return false;
+  };
+  Equation.prototype.r1i = function () {
+    return Companion_getInstance_1().of('=', [this.p1j(), this.q1j()]);
+  };
+  Equation.prototype.toTerm = function () {
+    return this.r1i();
+  };
+  Equation.prototype.toPair = function () {
+    return new Pair(this.p1j(), this.q1j());
+  };
+  Equation.prototype.swap = function () {
+    var tmp = Companion_getInstance_2();
+    var tmp_0 = this.q1j();
+    var tmp_1 = this.p1j();
+    return tmp.w1k(tmp_0, tmp_1, null, 4, null);
+  };
+  Equation.prototype.apply = function (substitution, equalityChecker) {
+    var tmp;
+    if (equalityChecker === void 1) {
+      tmp = Term$equals$ref_6();
+    } else {
+      tmp = equalityChecker;
+    }
+    return this.m1k(substitution, tmp);
+  };
+  Equation.prototype.m1k = function (substitution, equalityChecker) {
+    return Companion_getInstance_2().b1k(this.p1j().getSubstituted(substitution, []), this.q1j().getSubstituted(substitution, []), equalityChecker);
+  };
+  Equation.prototype.a1k = function (substitution, equalityChecker, $mask0, $handler) {
+    if (!(($mask0 & 2) === 0)) {
+      equalityChecker = Term$equals$ref_6();
+    }
+    return this.m1k(substitution, equalityChecker);
+  };
+  Object.defineProperty(Equation.prototype, 'lhs', {
+    configurable: true,
+    get: function () {
+      return this.p1j();
+    }
+  });
+  Object.defineProperty(Equation.prototype, 'rhs', {
+    configurable: true,
+    get: function () {
+      return this.q1j();
+    }
+  });
+  function toEquations(_this__u8e3s4) {
+    var tmp$ret$4;
+    // Inline function 'kotlin.collections.map' call
+    var tmp0_map = _this__u8e3s4.z();
+    var tmp$ret$3;
+    // Inline function 'kotlin.collections.mapTo' call
+    var tmp0_mapTo = ArrayList_init_$Create$_0(collectionSizeOrDefault(tmp0_map, 10));
+    var tmp0_iterator = tmp0_map.j();
+    while (tmp0_iterator.m()) {
+      var item = tmp0_iterator.p();
+      var tmp$ret$2;
+      // Inline function 'it.unibo.tuprolog.unify.toEquations.<anonymous>' call
+      var tmp$ret$0;
+      // Inline function 'kotlin.collections.component1' call
+      tmp$ret$0 = item.a1();
+      var variable = tmp$ret$0;
+      var tmp$ret$1;
+      // Inline function 'kotlin.collections.component2' call
+      tmp$ret$1 = item.b1();
+      var term = tmp$ret$1;
+      tmp$ret$2 = new Assignment(variable, term);
+      tmp0_mapTo.g(tmp$ret$2);
+    }
+    tmp$ret$3 = tmp0_mapTo;
+    tmp$ret$4 = tmp$ret$3;
+    return tmp$ret$4;
+  }
+  function toSubstitution(_this__u8e3s4) {
+    var tmp = Companion_getInstance();
+    var tmp_0 = asSequence_0(_this__u8e3s4);
+    return tmp.ofSequence(map(tmp_0, toSubstitution$lambda));
+  }
+  function toAssignmentPair(_this__u8e3s4) {
+    var tmp;
+    if (_this__u8e3s4.z1j()) {
+      tmp = _this__u8e3s4.u1j().n1k();
+    } else if (_this__u8e3s4.p1j().bx()) {
+      tmp = to(_this__u8e3s4.p1j().castToVar(), _this__u8e3s4.q1j());
+    } else if (_this__u8e3s4.q1j().bx()) {
+      tmp = to(_this__u8e3s4.q1j().castToVar(), _this__u8e3s4.p1j());
+    } else {
+      throw IllegalArgumentException_init_$Create$('Equation contains no variables: ' + _this__u8e3s4);
+    }
+    return tmp;
+  }
+  function toSubstitution$lambda(it) {
+    return toAssignmentPair(it);
+  }
+  function Unificator$Companion$default$delegate$lambda() {
+    return Companion_getInstance_3().strict();
+  }
+  function Unificator$Companion$naive$1($context) {
+    AbstractUnificator.call(this, $context);
+  }
+  Unificator$Companion$naive$1.prototype.k1j = function (first, second) {
+    var tmp;
+    if (first.gx() ? second.gx() : false) {
+      tmp = first.castToInteger().b1().lk(second.castToInteger().b1()) === 0;
+    } else if (first.fx() ? second.fx() : false) {
+      tmp = first.castToNumeric().x10().ck(second.castToNumeric().x10()) === 0;
+    } else {
+      tmp = first.equals(second);
+    }
+    return tmp;
+  };
+  function Unificator$Companion$strict$1($context) {
+    AbstractUnificator.call(this, $context);
+  }
+  Unificator$Companion$strict$1.prototype.k1j = function (first, second) {
+    return first.equals(second);
+  };
+  function Companion_0() {
+    Companion_instance_0 = this;
+    var tmp = this;
+    tmp.f1l_1 = lazy(Unificator$Companion$default$delegate$lambda);
+    this.g1l_1 = 32;
+  }
+  Companion_0.prototype.h1l = function () {
+    var tmp$ret$0;
+    // Inline function 'kotlin.getValue' call
+    var tmp0_getValue = default$factory();
+    tmp$ret$0 = this.f1l_1.b1();
+    return tmp$ret$0;
+  };
+  Companion_0.prototype.mguWith = function (_this__u8e3s4, other) {
+    return this.h1l().mgu(_this__u8e3s4, other);
+  };
+  Companion_0.prototype.matches = function (_this__u8e3s4, other) {
+    return this.h1l().match(_this__u8e3s4, other);
+  };
+  Companion_0.prototype.unifyWith = function (_this__u8e3s4, other) {
+    return this.h1l().unify(_this__u8e3s4, other);
+  };
+  Companion_0.prototype.mergeWith = function (_this__u8e3s4, other) {
+    return this.h1l().merge(_this__u8e3s4, other);
+  };
+  Companion_0.prototype.naiveWithContext = function (context) {
+    return new Unificator$Companion$naive$1(context);
+  };
+  Companion_0.prototype.naive = function () {
+    return this.naiveWithContext(Companion_getInstance().empty());
+  };
+  Companion_0.prototype.strictWithContext = function (context) {
+    return new Unificator$Companion$strict$1(context);
+  };
+  Companion_0.prototype.strict = function () {
+    return this.strictWithContext(Companion_getInstance().empty());
+  };
+  Companion_0.prototype.cached = function (other, capacity) {
+    return this.i1l(other, capacity === void 1 ? 32 : capacity);
+  };
+  Companion_0.prototype.i1l = function (other, capacity) {
+    var tmp;
+    if (other instanceof CachedUnificator) {
+      tmp = new CachedUnificator(other.e1k_1, capacity);
+    } else {
+      tmp = new CachedUnificator(other, capacity);
+    }
+    return tmp;
+  };
+  Object.defineProperty(Companion_0.prototype, 'default', {
+    configurable: true,
+    get: Companion_0.prototype.h1l
+  });
+  var Companion_instance_0;
+  function Companion_getInstance_3() {
+    if (Companion_instance_0 == null)
+      new Companion_0();
+    return Companion_instance_0;
+  }
+  function Unificator() {
+  }
+  function default$factory() {
+    return getPropertyCallableRef('default', 1, KProperty1, function (receiver) {
+      return receiver.h1l();
+    }, null);
+  }
+  //region block: post-declaration
+  AbstractUnificator.prototype.mgu = mgu;
+  AbstractUnificator.prototype.matchWithOccurCheck = matchWithOccurCheck;
+  AbstractUnificator.prototype.match = match;
+  AbstractUnificator.prototype.unifyWithOccurCheck = unifyWithOccurCheck;
+  AbstractUnificator.prototype.unify = unify;
+  AbstractUnificator.prototype.merge = merge;
+  CachedUnificator.prototype.mgu = mgu;
+  CachedUnificator.prototype.matchWithOccurCheck = matchWithOccurCheck;
+  CachedUnificator.prototype.match = match;
+  CachedUnificator.prototype.unifyWithOccurCheck = unifyWithOccurCheck;
+  CachedUnificator.prototype.unify = unify;
+  CachedUnificator.prototype.merge = merge;
+  Equation.prototype.qq = castTo;
+  Identity.prototype.qq = castTo;
+  Assignment.prototype.qq = castTo;
+  Comparison.prototype.qq = castTo;
+  Contradiction.prototype.qq = castTo;
+  Unificator$Companion$naive$1.prototype.mgu = mgu;
+  Unificator$Companion$naive$1.prototype.merge = merge;
+  Unificator$Companion$naive$1.prototype.matchWithOccurCheck = matchWithOccurCheck;
+  Unificator$Companion$naive$1.prototype.match = match;
+  Unificator$Companion$naive$1.prototype.unifyWithOccurCheck = unifyWithOccurCheck;
+  Unificator$Companion$naive$1.prototype.unify = unify;
+  Unificator$Companion$strict$1.prototype.mgu = mgu;
+  Unificator$Companion$strict$1.prototype.merge = merge;
+  Unificator$Companion$strict$1.prototype.matchWithOccurCheck = matchWithOccurCheck;
+  Unificator$Companion$strict$1.prototype.match = match;
+  Unificator$Companion$strict$1.prototype.unifyWithOccurCheck = unifyWithOccurCheck;
+  Unificator$Companion$strict$1.prototype.unify = unify;
+  //endregion
+  //region block: exports
+  _.$_$ = _.$_$ || {};
+  _.$_$.a = Companion_getInstance_3;
+  //endregion
+  return _;
+}(module.exports, require('./kotlin-kotlin-stdlib-js-ir.js'), require('./2p-core.js'), require('./2p-utils.js')));
+
+//# sourceMappingURL=2p-unify.js.map