@jakta/jakta-prolog-incarnation 0.0.0-bootstrap

package/2p-unify.js

@@ -0,0 +1,886 @@
+(function (factory) {
+  if (typeof define === 'function' && define.amd)
+    define(['exports', './kotlin-kotlin-stdlib.js', './2p-core.js', './2p-utils.js'], factory);
+  else if (typeof exports === 'object')
+    factory(module.exports, require('./kotlin-kotlin-stdlib.js'), require('./2p-core.js'), require('./2p-utils.js'));
+  else {
+    if (typeof globalThis['kotlin-kotlin-stdlib'] === 'undefined') {
+      throw new Error("Error loading module '2p-unify'. Its dependency 'kotlin-kotlin-stdlib' was not found. Please, check whether 'kotlin-kotlin-stdlib' is loaded prior to '2p-unify'.");
+    }
+    if (typeof globalThis['2p-core'] === 'undefined') {
+      throw new Error("Error loading module '2p-unify'. Its dependency '2p-core' was not found. Please, check whether '2p-core' is loaded prior to '2p-unify'.");
+    }
+    if (typeof globalThis['2p-utils'] === 'undefined') {
+      throw new Error("Error loading module '2p-unify'. Its dependency '2p-utils' was not found. Please, check whether '2p-utils' is loaded prior to '2p-unify'.");
+    }
+    globalThis['2p-unify'] = factory(typeof globalThis['2p-unify'] === 'undefined' ? {} : globalThis['2p-unify'], globalThis['kotlin-kotlin-stdlib'], globalThis['2p-core'], globalThis['2p-utils']);
+  }
+}(function (_, kotlin_kotlin, kotlin_it_unibo_tuprolog_core, kotlin_it_unibo_tuprolog_utils) {
+  'use strict';
+  //region block: imports
+  var imul = Math.imul;
+  var KProperty1 = kotlin_kotlin.$_$.f7;
+  var getPropertyCallableRef = kotlin_kotlin.$_$.v5;
+  var asSequence = kotlin_kotlin.$_$.y1;
+  var plus = kotlin_kotlin.$_$.h8;
+  var map = kotlin_kotlin.$_$.d8;
+  var Unit_instance = kotlin_kotlin.$_$.m;
+  var Companion_getInstance = kotlin_it_unibo_tuprolog_core.$_$.o;
+  var ArrayList_init_$Create$ = kotlin_kotlin.$_$.o;
+  var toCollection = kotlin_kotlin.$_$.o8;
+  var constructCallableReference = kotlin_kotlin.$_$.r5;
+  var Pair = kotlin_kotlin.$_$.fa;
+  var VOID = kotlin_kotlin.$_$.b;
+  var lazy = kotlin_kotlin.$_$.na;
+  var protoOf = kotlin_kotlin.$_$.n6;
+  var asSequence_0 = kotlin_kotlin.$_$.z1;
+  var THROW_CCE = kotlin_kotlin.$_$.ha;
+  var initMetadataForClass = kotlin_kotlin.$_$.y5;
+  var Companion_instance = kotlin_it_unibo_tuprolog_utils.$_$.a;
+  var Triple = kotlin_kotlin.$_$.ja;
+  var Some = kotlin_it_unibo_tuprolog_utils.$_$.k;
+  var zip = kotlin_kotlin.$_$.v8;
+  var flatMap = kotlin_kotlin.$_$.v7;
+  var sequenceOf = kotlin_kotlin.$_$.j8;
+  var to = kotlin_kotlin.$_$.sa;
+  var sequenceOf_0 = kotlin_kotlin.$_$.i8;
+  var initMetadataForCompanion = kotlin_kotlin.$_$.z5;
+  var toString = kotlin_kotlin.$_$.q6;
+  var getKClass = kotlin_kotlin.$_$.e7;
+  var ClassCastException_init_$Create$ = kotlin_kotlin.$_$.z;
+  var Companion_getInstance_0 = kotlin_it_unibo_tuprolog_core.$_$.n;
+  var castTo = kotlin_it_unibo_tuprolog_utils.$_$.e;
+  var defineProp = kotlin_kotlin.$_$.s5;
+  var Castable = kotlin_it_unibo_tuprolog_utils.$_$.f;
+  var collectionSizeOrDefault = kotlin_kotlin.$_$.b2;
+  var ArrayList_init_$Create$_0 = kotlin_kotlin.$_$.n;
+  var IllegalArgumentException_init_$Create$ = kotlin_kotlin.$_$.b1;
+  var initMetadataForInterface = kotlin_kotlin.$_$.a6;
+  //endregion
+  //region block: pre-declaration
+  function mguWithOccurCheck(term1, term2, occurCheckEnabled, $super) {
+    occurCheckEnabled = occurCheckEnabled === VOID ? true : occurCheckEnabled;
+    return $super === VOID ? this.q1g(term1, term2, occurCheckEnabled) : $super.q1g.call(this, term1, term2, occurCheckEnabled);
+  }
+  function mgu(term1, term2) {
+    return this.q1g(term1, term2, true);
+  }
+  function matchWithOccurCheck(term1, term2, occurCheckEnabled) {
+    return !(this.q1g(term1, term2, occurCheckEnabled) === Companion_getInstance().failed());
+  }
+  function match(term1, term2) {
+    return this.matchWithOccurCheck(term1, term2, true);
+  }
+  function unifyWithOccurCheck(term1, term2, occurCheckEnabled) {
+    var substitution = this.q1g(term1, term2, occurCheckEnabled);
+    return substitution.mz() ? null : term1.getSubstituted(substitution, []);
+  }
+  function unify(term1, term2) {
+    return this.unifyWithOccurCheck(term1, term2, true);
+  }
+  function merge(substitution1, substitution2) {
+    return this.mergeWithOccurCheck(substitution1, substitution2, true);
+  }
+  initMetadataForInterface(Unificator, 'Unificator');
+  initMetadataForClass(AbstractUnificator, 'AbstractUnificator', VOID, VOID, [Unificator]);
+  initMetadataForClass(CachedUnificator, 'CachedUnificator', VOID, VOID, [Unificator]);
+  initMetadataForClass(Equation, 'Equation', VOID, VOID, [Castable]);
+  initMetadataForClass(Identity, 'Identity', VOID, Equation);
+  initMetadataForClass(Assignment, 'Assignment', VOID, Equation);
+  initMetadataForClass(Comparison, 'Comparison', VOID, Equation);
+  initMetadataForClass(Contradiction, 'Contradiction', VOID, Equation);
+  initMetadataForCompanion(Companion);
+  initMetadataForClass(Unificator$Companion$naive$1, VOID, VOID, AbstractUnificator);
+  initMetadataForClass(Unificator$Companion$strict$1, VOID, VOID, AbstractUnificator);
+  initMetadataForCompanion(Companion_0);
+  //endregion
+  function _get_contextEquations__x0dd77($this) {
+    var tmp0 = $this.z1f_1;
+    var tmp = KProperty1;
+    // Inline function 'kotlin.getValue' call
+    getPropertyCallableRef('contextEquations', 1, tmp, AbstractUnificator$_get_contextEquations_$ref_7ajcte(), null);
+    return tmp0.c2();
+  }
+  function occurrenceCheck($this, variable, term) {
+    var tmp;
+    if (term.du()) {
+      tmp = $this.a1g(variable, term);
+    } else if (term.nt()) {
+      var tmp0 = term.jt();
+      var tmp$ret$0;
+      $l$block: {
+        // Inline function 'kotlin.sequences.any' call
+        var _iterator__ex2g4s = tmp0.m();
+        while (_iterator__ex2g4s.p()) {
+          var element = _iterator__ex2g4s.q();
+          if (occurrenceCheck($this, variable, element)) {
+            tmp$ret$0 = true;
+            break $l$block;
+          }
+        }
+        tmp$ret$0 = false;
+      }
+      tmp = tmp$ret$0;
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  }
+  function equationsFor($this, term1, term2) {
+    var tmp = Companion_instance_0;
+    return tmp.b1g(term1, term2, AbstractUnificator$checkTermsEquality$ref($this));
+  }
+  function equationsFor_0($this, substitution1, substitution2) {
+    var tmp = Companion_instance_0;
+    var tmp_0 = plus(asSequence(substitution1), asSequence(substitution2));
+    return tmp.fromSequence(map(tmp_0, AbstractUnificator$equationsFor$lambda));
+  }
+  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.s();
+    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.g4();
+      while (eqIterator.p()) {
+        var eq = eqIterator.q();
+        if (eq.g1g()) {
+          return Companion_getInstance().failed();
+        } else if (eq.h1g()) {
+          eqIterator.g3();
+          changed = true;
+        } else if (eq.o1g()) {
+          var assignment = eq.j1g();
+          if (occurCheckEnabled && occurrenceCheck($this, assignment.m1g_1, eq.f1g())) {
+            return Companion_getInstance().failed();
+          } else {
+            changed = changed || applySubstitutionToEquations($this, assignment.toSubstitution(), equations, eqIterator.u3());
+          }
+        } else if (eq.i1g()) {
+          eqIterator.g3();
+          var _iterator__ex2g4s = equationsFor($this, eq.e1g(), eq.f1g()).m();
+          insertion: while (_iterator__ex2g4s.p()) {
+            var it = _iterator__ex2g4s.q();
+            if (it.h1g())
+              continue insertion;
+            else if (it.g1g())
+              return Companion_getInstance().failed();
+            else {
+              eqIterator.x3(it);
+            }
+          }
+          changed = true;
+        }
+      }
+    }
+    // Inline function 'kotlin.collections.filter' call
+    // Inline function 'kotlin.collections.filterTo' call
+    var destination = ArrayList_init_$Create$();
+    var _iterator__ex2g4s_0 = equations.m();
+    while (_iterator__ex2g4s_0.p()) {
+      var element = _iterator__ex2g4s_0.q();
+      if (element.o1g()) {
+        destination.j(element);
+      }
+    }
+    return toSubstitution(destination);
+  }
+  function newDeque($this, items) {
+    // Inline function 'kotlin.collections.arrayListOf' call
+    var tmp$ret$0 = ArrayList_init_$Create$();
+    return toCollection(items, tmp$ret$0);
+  }
+  function AbstractUnificator$contextEquations$delegate$lambda(this$0) {
+    return function () {
+      return toEquations(this$0.m8());
+    };
+  }
+  function AbstractUnificator$_get_contextEquations_$ref_7ajcte() {
+    return constructCallableReference(function (p0) {
+      return _get_contextEquations__x0dd77(p0);
+    }, 1, 0, 25);
+  }
+  function AbstractUnificator$checkTermsEquality$ref(p0) {
+    return constructCallableReference(function (p0_0, p1) {
+      return p0.a1g(p0_0, p1);
+    }, 2, 0, 26, 'checkTermsEquality', [p0]);
+  }
+  function AbstractUnificator$equationsFor$lambda(it) {
+    // Inline function 'kotlin.collections.toPair' call
+    return new Pair(it.b2(), it.c2());
+  }
+  function applySubstitutionToEquations$handleIndex($equations, $substitution, this$0, changed, i) {
+    if ($equations.t(i).g1g() || $equations.t(i).h1g())
+      return Unit_instance;
+    var currentEq = $equations.t(i);
+    var _destruct__k2r9zo = currentEq.apply($substitution).toPair();
+    var newLhs = _destruct__k2r9zo.ac();
+    var newRhs = _destruct__k2r9zo.bc();
+    if (!currentEq.e1g().equals(newLhs) || !currentEq.f1g().equals(newRhs)) {
+      var tmp = Companion_instance_0;
+      $equations.d4(i, tmp.p1g(newLhs, newRhs, AbstractUnificator$checkTermsEquality$ref(this$0)));
+      changed._v = true;
+    }
+  }
+  function AbstractUnificator(context) {
+    context = context === VOID ? Companion_getInstance().empty() : context;
+    this.y1f_1 = context;
+    var tmp = this;
+    tmp.z1f_1 = lazy(AbstractUnificator$contextEquations$delegate$lambda(this));
+  }
+  protoOf(AbstractUnificator).m8 = function () {
+    return this.y1f_1;
+  };
+  protoOf(AbstractUnificator).q1g = function (term1, term2, occurCheckEnabled) {
+    if (this.m8().mz())
+      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);
+  };
+  protoOf(AbstractUnificator).mguWithOccurCheck = function (term1, term2, occurCheckEnabled, $super) {
+    return this.mguWithOccurCheck(term1, term2, occurCheckEnabled, ($super == null ? true : $super instanceof AbstractUnificator) ? $super : THROW_CCE());
+  };
+  protoOf(AbstractUnificator).r1g = function (substitution1, substitution2, occurCheckEnabled) {
+    if (this.m8().mz() || substitution1.mz() || substitution2.mz())
+      return Companion_getInstance().failed();
+    if (!occurCheckEnabled) {
+      var quickMerge = this.m8().plus(substitution1).plus(substitution2);
+      if (quickMerge.lz()) {
+        return quickMerge;
+      }
+    }
+    var equations = newDeque(this, plus(asSequence_0(_get_contextEquations__x0dd77(this)), equationsFor_0(this, substitution1, substitution2)));
+    return mgu_0(this, equations, occurCheckEnabled);
+  };
+  protoOf(AbstractUnificator).mergeWithOccurCheck = function (substitution1, substitution2, occurCheckEnabled) {
+    return this.r1g(substitution1, substitution2, occurCheckEnabled);
+  };
+  function CachedUnificator(decorated, cacheCapacity) {
+    this.s1g_1 = decorated;
+    this.t1g_1 = Companion_instance.eo(cacheCapacity);
+  }
+  protoOf(CachedUnificator).q1g = function (term1, term2, occurCheckEnabled) {
+    var mguRequest = new Triple(term1, term2, occurCheckEnabled);
+    var cached = this.t1g_1.f2(mguRequest);
+    var tmp;
+    if (cached instanceof Some) {
+      tmp = cached.ho_1;
+    } else {
+      var mguResult = this.s1g_1.q1g(term1, term2, occurCheckEnabled);
+      this.t1g_1.fo(mguRequest, mguResult);
+      tmp = mguResult;
+    }
+    return tmp;
+  };
+  protoOf(CachedUnificator).mguWithOccurCheck = function (term1, term2, occurCheckEnabled, $super) {
+    return this.mguWithOccurCheck(term1, term2, occurCheckEnabled, ($super == null ? true : $super instanceof CachedUnificator) ? $super : THROW_CCE());
+  };
+  protoOf(CachedUnificator).r1g = function (substitution1, substitution2, occurCheckEnabled) {
+    var mguRequest = new Triple(substitution1, substitution2, occurCheckEnabled);
+    var cached = this.t1g_1.f2(mguRequest);
+    var tmp;
+    if (cached instanceof Some) {
+      tmp = cached.ho_1;
+    } else {
+      var mguResult = this.s1g_1.mergeWithOccurCheck(substitution1, substitution2, occurCheckEnabled);
+      this.t1g_1.fo(mguRequest, mguResult);
+      tmp = mguResult;
+    }
+    return tmp;
+  };
+  protoOf(CachedUnificator).mergeWithOccurCheck = function (substitution1, substitution2, occurCheckEnabled) {
+    return this.r1g(substitution1, substitution2, occurCheckEnabled);
+  };
+  function allOfLists($this, lhs, rhs, equalityChecker) {
+    var tmp;
+    if (equalityChecker === VOID) {
+      tmp = Term$equals$ref();
+    } else {
+      tmp = equalityChecker;
+    }
+    equalityChecker = tmp;
+    var tmp_0 = zip(lhs.unfold(), rhs.unfold());
+    return flatMap(tmp_0, Equation$Companion$allOfLists$lambda(equalityChecker));
+  }
+  function allOfTuples($this, lhs, rhs, equalityChecker) {
+    var tmp;
+    if (equalityChecker === VOID) {
+      tmp = Term$equals$ref();
+    } else {
+      tmp = equalityChecker;
+    }
+    equalityChecker = tmp;
+    var tmp_0 = zip(lhs.unfold(), rhs.unfold());
+    return flatMap(tmp_0, Equation$Companion$allOfTuples$lambda(equalityChecker));
+  }
+  function Term$equals$ref() {
+    return constructCallableReference(function (p0, p1) {
+      return p0.equals(p1);
+    }, 2, 0, 27, 'equals');
+  }
+  function Equation$Companion$from$lambda($equalityChecker) {
+    return function (it) {
+      return Companion_instance_0.u1g(it, $equalityChecker);
+    };
+  }
+  function Equation$Companion$allOfLists$lambda($equalityChecker) {
+    return function (_destruct__k2r9zo) {
+      var l = _destruct__k2r9zo.ac();
+      var r = _destruct__k2r9zo.bc();
+      return l.ut() && r.ut() ? sequenceOf(Companion_instance_0.p1g(l.castToCons().nv(), r.castToCons().nv(), $equalityChecker)) : l.tt() && r.tt() ? sequenceOf(Companion_instance_0.p1g(l.castToList(), r.castToList(), $equalityChecker)) : Companion_instance_0.b1g(l, r, $equalityChecker);
+    };
+  }
+  function Equation$Companion$allOfTuples$lambda($equalityChecker) {
+    return function (_destruct__k2r9zo) {
+      var l = _destruct__k2r9zo.ac();
+      var r = _destruct__k2r9zo.bc();
+      return l.st() && r.st() ? sequenceOf(Companion_instance_0.p1g(l.castToTuple().bv(), r.castToTuple().bv(), $equalityChecker)) : Companion_instance_0.b1g(l, r, $equalityChecker);
+    };
+  }
+  function Equation$Companion$allOf$lambda($equalityChecker) {
+    return function (it) {
+      return Companion_instance_0.u1g(it, $equalityChecker);
+    };
+  }
+  function Identity(lhs, rhs) {
+    Equation.call(this, lhs, rhs);
+    this.x1g_1 = lhs;
+    this.y1g_1 = rhs;
+  }
+  protoOf(Identity).e1g = function () {
+    return this.x1g_1;
+  };
+  protoOf(Identity).f1g = function () {
+    return this.y1g_1;
+  };
+  protoOf(Identity).h1g = function () {
+    return true;
+  };
+  protoOf(Identity).toString = function () {
+    return 'Identity(lhs=' + this.x1g_1.toString() + ', rhs=' + this.y1g_1.toString() + ')';
+  };
+  protoOf(Identity).hashCode = function () {
+    var result = this.x1g_1.hashCode();
+    result = imul(result, 31) + this.y1g_1.hashCode() | 0;
+    return result;
+  };
+  protoOf(Identity).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Identity))
+      return false;
+    if (!this.x1g_1.equals(other.x1g_1))
+      return false;
+    if (!this.y1g_1.equals(other.y1g_1))
+      return false;
+    return true;
+  };
+  function Assignment(lhs, rhs) {
+    Equation.call(this, lhs, rhs);
+    this.m1g_1 = lhs;
+    this.n1g_1 = rhs;
+  }
+  protoOf(Assignment).e1g = function () {
+    return this.m1g_1;
+  };
+  protoOf(Assignment).f1g = function () {
+    return this.n1g_1;
+  };
+  protoOf(Assignment).toSubstitution = function () {
+    return Companion_getInstance().unifier(this.m1g_1, this.n1g_1);
+  };
+  protoOf(Assignment).b1h = function () {
+    return to(this.m1g_1, this.n1g_1);
+  };
+  protoOf(Assignment).toPair = function () {
+    return this.b1h();
+  };
+  protoOf(Assignment).o1g = function () {
+    return true;
+  };
+  protoOf(Assignment).z1g = function () {
+    return this;
+  };
+  protoOf(Assignment).toString = function () {
+    return 'Assignment(lhs=' + this.m1g_1.toString() + ', rhs=' + this.n1g_1.toString() + ')';
+  };
+  protoOf(Assignment).hashCode = function () {
+    var result = this.m1g_1.hashCode();
+    result = imul(result, 31) + this.n1g_1.hashCode() | 0;
+    return result;
+  };
+  protoOf(Assignment).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Assignment))
+      return false;
+    if (!this.m1g_1.equals(other.m1g_1))
+      return false;
+    if (!this.n1g_1.equals(other.n1g_1))
+      return false;
+    return true;
+  };
+  function Comparison(lhs, rhs) {
+    Equation.call(this, lhs, rhs);
+    this.e1h_1 = lhs;
+    this.f1h_1 = rhs;
+  }
+  protoOf(Comparison).e1g = function () {
+    return this.e1h_1;
+  };
+  protoOf(Comparison).f1g = function () {
+    return this.f1h_1;
+  };
+  protoOf(Comparison).i1g = function () {
+    return true;
+  };
+  protoOf(Comparison).toString = function () {
+    return 'Comparison(lhs=' + this.e1h_1.toString() + ', rhs=' + this.f1h_1.toString() + ')';
+  };
+  protoOf(Comparison).hashCode = function () {
+    var result = this.e1h_1.hashCode();
+    result = imul(result, 31) + this.f1h_1.hashCode() | 0;
+    return result;
+  };
+  protoOf(Comparison).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Comparison))
+      return false;
+    if (!this.e1h_1.equals(other.e1h_1))
+      return false;
+    if (!this.f1h_1.equals(other.f1h_1))
+      return false;
+    return true;
+  };
+  function Contradiction(lhs, rhs) {
+    Equation.call(this, lhs, rhs);
+    this.i1h_1 = lhs;
+    this.j1h_1 = rhs;
+  }
+  protoOf(Contradiction).e1g = function () {
+    return this.i1h_1;
+  };
+  protoOf(Contradiction).f1g = function () {
+    return this.j1h_1;
+  };
+  protoOf(Contradiction).g1g = function () {
+    return true;
+  };
+  protoOf(Contradiction).toString = function () {
+    return 'Contradiction(lhs=' + this.i1h_1.toString() + ', rhs=' + this.j1h_1.toString() + ')';
+  };
+  protoOf(Contradiction).hashCode = function () {
+    var result = this.i1h_1.hashCode();
+    result = imul(result, 31) + this.j1h_1.hashCode() | 0;
+    return result;
+  };
+  protoOf(Contradiction).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Contradiction))
+      return false;
+    if (!this.i1h_1.equals(other.i1h_1))
+      return false;
+    if (!this.j1h_1.equals(other.j1h_1))
+      return false;
+    return true;
+  };
+  function Companion() {
+  }
+  protoOf(Companion).p1g = function (lhs, rhs, equalityChecker) {
+    var tmp;
+    if (lhs.du() && rhs.du()) {
+      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.du()) {
+      tmp = new Assignment(lhs.castToVar(), rhs);
+    } else if (rhs.du()) {
+      tmp = new Assignment(rhs.castToVar(), lhs);
+    } else if (lhs.gu() && rhs.gu()) {
+      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.gu() || rhs.gu()) {
+      tmp = new Contradiction(lhs, rhs);
+    } else if (lhs.nt() && rhs.nt()) {
+      var lhsStruct = lhs.castToStruct();
+      var rhsStruct = rhs.castToStruct();
+      var tmp_2;
+      if (!(lhsStruct.bt() === rhsStruct.bt()) || !(lhsStruct.ht() === rhsStruct.ht())) {
+        tmp_2 = new Contradiction(lhsStruct, rhsStruct);
+      } else {
+        tmp_2 = new Comparison(lhsStruct, rhsStruct);
+      }
+      tmp = tmp_2;
+    } else {
+      tmp = new Comparison(lhs, rhs);
+    }
+    return tmp;
+  };
+  protoOf(Companion).of = function (lhs, rhs, equalityChecker, $super) {
+    var tmp;
+    if (equalityChecker === VOID) {
+      tmp = Term$equals$ref();
+    } else {
+      tmp = equalityChecker;
+    }
+    equalityChecker = tmp;
+    return $super === VOID ? this.p1g(lhs, rhs, equalityChecker) : $super.p1g.call(this, lhs, rhs, equalityChecker);
+  };
+  protoOf(Companion).k1h = function (pair, equalityChecker) {
+    return this.p1g(pair.first, pair.second, equalityChecker);
+  };
+  protoOf(Companion).ofPair = function (pair, equalityChecker, $super) {
+    var tmp;
+    if (equalityChecker === VOID) {
+      tmp = Term$equals$ref();
+    } else {
+      tmp = equalityChecker;
+    }
+    equalityChecker = tmp;
+    return $super === VOID ? this.k1h(pair, equalityChecker) : $super.k1h.call(this, pair, equalityChecker);
+  };
+  protoOf(Companion).l1h = function (pairs, equalityChecker) {
+    return flatMap(pairs, Equation$Companion$from$lambda(equalityChecker));
+  };
+  protoOf(Companion).fromSequence = function (pairs, equalityChecker, $super) {
+    var tmp;
+    if (equalityChecker === VOID) {
+      tmp = Term$equals$ref();
+    } else {
+      tmp = equalityChecker;
+    }
+    equalityChecker = tmp;
+    return $super === VOID ? this.l1h(pairs, equalityChecker) : $super.l1h.call(this, pairs, equalityChecker);
+  };
+  protoOf(Companion).m1h = function (pairs, equalityChecker) {
+    return this.l1h(asSequence_0(pairs), equalityChecker);
+  };
+  protoOf(Companion).fromIterable = function (pairs, equalityChecker, $super) {
+    var tmp;
+    if (equalityChecker === VOID) {
+      tmp = Term$equals$ref();
+    } else {
+      tmp = equalityChecker;
+    }
+    equalityChecker = tmp;
+    return $super === VOID ? this.m1h(pairs, equalityChecker) : $super.m1h.call(this, pairs, equalityChecker);
+  };
+  protoOf(Companion).n1h = function (pairs, equalityChecker) {
+    return this.l1h(sequenceOf_0(pairs.slice()), equalityChecker);
+  };
+  protoOf(Companion).from = function (pairs, equalityChecker, $super) {
+    var tmp;
+    if (equalityChecker === VOID) {
+      tmp = Term$equals$ref();
+    } else {
+      tmp = equalityChecker;
+    }
+    equalityChecker = tmp;
+    return $super === VOID ? this.n1h(pairs, equalityChecker) : $super.n1h.call(this, pairs, equalityChecker);
+  };
+  protoOf(Companion).u1g = function (pair, equalityChecker) {
+    return this.b1g(pair.first, pair.second, equalityChecker);
+  };
+  protoOf(Companion).allOfPair = function (pair, equalityChecker, $super) {
+    var tmp;
+    if (equalityChecker === VOID) {
+      tmp = Term$equals$ref();
+    } else {
+      tmp = equalityChecker;
+    }
+    equalityChecker = tmp;
+    return $super === VOID ? this.u1g(pair, equalityChecker) : $super.u1g.call(this, pair, equalityChecker);
+  };
+  protoOf(Companion).b1g = function (lhs, rhs, equalityChecker) {
+    var tmp;
+    if (lhs.ct() && rhs.ct()) {
+      tmp = sequenceOf(this.p1g(lhs, rhs, equalityChecker));
+    } else if (lhs.tt() && rhs.tt()) {
+      tmp = allOfLists(this, lhs.castToList(), rhs.castToList(), equalityChecker);
+    } else if (lhs.st() && rhs.st()) {
+      tmp = allOfTuples(this, lhs.castToTuple(), rhs.castToTuple(), equalityChecker);
+    } else if (lhs.nt() && rhs.nt()) {
+      var lhsStruct = lhs.castToStruct();
+      var rhsStruct = rhs.castToStruct();
+      var tmp_0;
+      if (lhsStruct.bt() === rhsStruct.bt() && lhsStruct.ht() === rhsStruct.ht()) {
+        var tmp_1 = zip(lhsStruct.au(), rhsStruct.au());
+        tmp_0 = flatMap(tmp_1, Equation$Companion$allOf$lambda(equalityChecker));
+      } else {
+        tmp_0 = sequenceOf(this.p1g(lhs, rhs, equalityChecker));
+      }
+      tmp = tmp_0;
+    } else {
+      tmp = sequenceOf(this.p1g(lhs, rhs, equalityChecker));
+    }
+    return tmp;
+  };
+  protoOf(Companion).allOf = function (lhs, rhs, equalityChecker, $super) {
+    var tmp;
+    if (equalityChecker === VOID) {
+      tmp = Term$equals$ref();
+    } else {
+      tmp = equalityChecker;
+    }
+    equalityChecker = tmp;
+    return $super === VOID ? this.b1g(lhs, rhs, equalityChecker) : $super.b1g.call(this, lhs, rhs, equalityChecker);
+  };
+  var Companion_instance_0;
+  function Companion_getInstance_1() {
+    return Companion_instance_0;
+  }
+  function Equation(lhs, rhs) {
+    this.c1g_1 = lhs;
+    this.d1g_1 = rhs;
+  }
+  protoOf(Equation).e1g = function () {
+    return this.c1g_1;
+  };
+  protoOf(Equation).f1g = function () {
+    return this.d1g_1;
+  };
+  protoOf(Equation).h1g = function () {
+    return false;
+  };
+  protoOf(Equation).o1g = function () {
+    return false;
+  };
+  protoOf(Equation).z1g = function () {
+    return null;
+  };
+  protoOf(Equation).j1g = function () {
+    var tmp0_elvis_lhs = this.z1g();
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      throw ClassCastException_init_$Create$('Cannot cast ' + toString(this) + ' to ' + getKClass(Assignment).g9());
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    return tmp;
+  };
+  protoOf(Equation).i1g = function () {
+    return false;
+  };
+  protoOf(Equation).g1g = function () {
+    return false;
+  };
+  protoOf(Equation).h1f = function () {
+    return Companion_getInstance_0().of('=', [this.e1g(), this.f1g()]);
+  };
+  protoOf(Equation).toTerm = function () {
+    return this.h1f();
+  };
+  protoOf(Equation).toPair = function () {
+    return new Pair(this.e1g(), this.f1g());
+  };
+  protoOf(Equation).swap = function () {
+    return Companion_instance_0.of(this.f1g(), this.e1g());
+  };
+  protoOf(Equation).a1h = function (substitution, equalityChecker) {
+    return Companion_instance_0.p1g(this.e1g().getSubstituted(substitution, []), this.f1g().getSubstituted(substitution, []), equalityChecker);
+  };
+  protoOf(Equation).apply = function (substitution, equalityChecker, $super) {
+    var tmp;
+    if (equalityChecker === VOID) {
+      tmp = Term$equals$ref();
+    } else {
+      tmp = equalityChecker;
+    }
+    equalityChecker = tmp;
+    return $super === VOID ? this.a1h(substitution, equalityChecker) : $super.a1h.call(this, substitution, equalityChecker);
+  };
+  function toEquations(_this__u8e3s4) {
+    // Inline function 'kotlin.collections.map' call
+    var this_0 = _this__u8e3s4.b1();
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$_0(collectionSizeOrDefault(this_0, 10));
+    var _iterator__ex2g4s = this_0.m();
+    while (_iterator__ex2g4s.p()) {
+      var item = _iterator__ex2g4s.q();
+      // Inline function 'kotlin.collections.component1' call
+      var variable = item.b2();
+      // Inline function 'kotlin.collections.component2' call
+      var term = item.c2();
+      var tmp$ret$2 = new Assignment(variable, term);
+      destination.j(tmp$ret$2);
+    }
+    return destination;
+  }
+  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.o1g()) {
+      tmp = _this__u8e3s4.j1g().b1h();
+    } else if (_this__u8e3s4.e1g().du()) {
+      tmp = to(_this__u8e3s4.e1g().castToVar(), _this__u8e3s4.f1g());
+    } else if (_this__u8e3s4.f1g().du()) {
+      tmp = to(_this__u8e3s4.f1g().castToVar(), _this__u8e3s4.e1g());
+    } else {
+      throw IllegalArgumentException_init_$Create$('Equation contains no variables: ' + toString(_this__u8e3s4));
+    }
+    return tmp;
+  }
+  function toSubstitution$lambda(it) {
+    return toAssignmentPair(it);
+  }
+  function Unificator$Companion$default$delegate$lambda() {
+    return Companion_getInstance_2().strict();
+  }
+  function Unificator$Companion$_get_default_$ref_8i2tx3() {
+    return constructCallableReference(function (p0) {
+      return p0.q1h();
+    }, 1, 0, 28);
+  }
+  function Unificator$Companion$naive$1($context) {
+    AbstractUnificator.call(this, $context);
+  }
+  protoOf(Unificator$Companion$naive$1).a1g = function (first, second) {
+    var tmp;
+    if (first.iu() && second.iu()) {
+      tmp = first.castToInteger().c2().li(second.castToInteger().c2()) === 0;
+    } else if (first.hu() && second.hu()) {
+      tmp = first.castToNumeric().xx().ci(second.castToNumeric().xx()) === 0;
+    } else {
+      tmp = first.equals(second);
+    }
+    return tmp;
+  };
+  protoOf(Unificator$Companion$naive$1).mguWithOccurCheck = function (term1, term2, occurCheckEnabled, $super) {
+    return this.mguWithOccurCheck(term1, term2, occurCheckEnabled, ($super == null ? true : $super instanceof Unificator$Companion$naive$1) ? $super : THROW_CCE());
+  };
+  function Unificator$Companion$strict$1($context) {
+    AbstractUnificator.call(this, $context);
+  }
+  protoOf(Unificator$Companion$strict$1).a1g = function (first, second) {
+    return first.equals(second);
+  };
+  protoOf(Unificator$Companion$strict$1).mguWithOccurCheck = function (term1, term2, occurCheckEnabled, $super) {
+    return this.mguWithOccurCheck(term1, term2, occurCheckEnabled, ($super == null ? true : $super instanceof Unificator$Companion$strict$1) ? $super : THROW_CCE());
+  };
+  function Companion_0() {
+    Companion_instance_1 = this;
+    var tmp = this;
+    tmp.o1h_1 = lazy(Unificator$Companion$default$delegate$lambda);
+    this.p1h_1 = 32;
+  }
+  protoOf(Companion_0).q1h = function () {
+    var tmp0 = this.o1h_1;
+    var tmp = KProperty1;
+    // Inline function 'kotlin.getValue' call
+    getPropertyCallableRef('default', 1, tmp, Unificator$Companion$_get_default_$ref_8i2tx3(), null);
+    return tmp0.c2();
+  };
+  protoOf(Companion_0).mguWith = function (_this__u8e3s4, other) {
+    return this.q1h().mgu(_this__u8e3s4, other);
+  };
+  protoOf(Companion_0).matches = function (_this__u8e3s4, other) {
+    return this.q1h().match(_this__u8e3s4, other);
+  };
+  protoOf(Companion_0).unifyWith = function (_this__u8e3s4, other) {
+    return this.q1h().unify(_this__u8e3s4, other);
+  };
+  protoOf(Companion_0).mergeWith = function (_this__u8e3s4, other) {
+    return this.q1h().merge(_this__u8e3s4, other);
+  };
+  protoOf(Companion_0).naiveWithContext = function (context) {
+    return new Unificator$Companion$naive$1(context);
+  };
+  protoOf(Companion_0).naive = function () {
+    return this.naiveWithContext(Companion_getInstance().empty());
+  };
+  protoOf(Companion_0).strictWithContext = function (context) {
+    return new Unificator$Companion$strict$1(context);
+  };
+  protoOf(Companion_0).strict = function () {
+    return this.strictWithContext(Companion_getInstance().empty());
+  };
+  protoOf(Companion_0).v1h = function (other, capacity) {
+    var tmp;
+    if (other instanceof CachedUnificator) {
+      tmp = new CachedUnificator(other.s1g_1, capacity);
+    } else {
+      tmp = new CachedUnificator(other, capacity);
+    }
+    return tmp;
+  };
+  protoOf(Companion_0).cached = function (other, capacity, $super) {
+    capacity = capacity === VOID ? 32 : capacity;
+    return $super === VOID ? this.v1h(other, capacity) : $super.v1h.call(this, other, capacity);
+  };
+  var Companion_instance_1;
+  function Companion_getInstance_2() {
+    if (Companion_instance_1 == null)
+      new Companion_0();
+    return Companion_instance_1;
+  }
+  function Unificator() {
+  }
+  //region block: post-declaration
+  protoOf(AbstractUnificator).mguWithOccurCheck = mguWithOccurCheck;
+  protoOf(AbstractUnificator).mgu = mgu;
+  protoOf(AbstractUnificator).matchWithOccurCheck = matchWithOccurCheck;
+  protoOf(AbstractUnificator).match = match;
+  protoOf(AbstractUnificator).unifyWithOccurCheck = unifyWithOccurCheck;
+  protoOf(AbstractUnificator).unify = unify;
+  protoOf(AbstractUnificator).merge = merge;
+  protoOf(CachedUnificator).mguWithOccurCheck = mguWithOccurCheck;
+  protoOf(CachedUnificator).mgu = mgu;
+  protoOf(CachedUnificator).matchWithOccurCheck = matchWithOccurCheck;
+  protoOf(CachedUnificator).match = match;
+  protoOf(CachedUnificator).unifyWithOccurCheck = unifyWithOccurCheck;
+  protoOf(CachedUnificator).unify = unify;
+  protoOf(CachedUnificator).merge = merge;
+  protoOf(Equation).oo = castTo;
+  defineProp(protoOf(Equation), 'lhs', function () {
+    return this.e1g();
+  });
+  defineProp(protoOf(Equation), 'rhs', function () {
+    return this.f1g();
+  });
+  defineProp(protoOf(Companion_0), 'default', protoOf(Companion_0).q1h);
+  //endregion
+  //region block: init
+  Companion_instance_0 = new Companion();
+  //endregion
+  //region block: exports
+  _.$_$ = _.$_$ || {};
+  _.$_$.a = Companion_getInstance_2;
+  //endregion
+  return _;
+}));
+
+//# sourceMappingURL=2p-unify.js.map