occam-verify-cli 0.0.478 → 0.0.480

package/src/verify/statementAsEquality.js

@@ -0,0 +1,146 @@
+"use strict";
+
+import Equality from "../equality";
+import Variable from "../variable";
+import verifyTerm from "../verify/term";
+
+import { nodeQuery } from "../utilities/query";
+import { nodeAsString } from "../utilities/string";
+import { first, second } from "../utilities/array";
+import { verifyTermAsVariable } from "../verify/term";
+import { EQUALS_CHARACTER, MAXIMUM_INDEXES_LENGTH } from "../constants";
+
+const specialNodeQuery = nodeQuery("/statement/@special!"),
+      leftTermNodeQuery = nodeQuery("/statement/term[0]"),
+      rightTermNodeQuery = nodeQuery("/statement/term[1]");
+
+export default function verifyStatementAsEquality(statementNode, proofContext) {
+  let statementVerifiedAsEquality = false;
+
+  proofContext.begin(statementNode);
+
+  const statementString = nodeAsString(statementNode);
+
+  proofContext.debug(`Verifying the '${statementString}' statement as an equality...`);
+
+  const specialNode = specialNodeQuery(statementNode);
+
+  if (specialNode !== null) {
+    const terminalNode = specialNode, ///
+          terminalNodeContent = terminalNode.getContent();
+
+    if (terminalNodeContent === EQUALS_CHARACTER) {
+      const types = [],
+            context = proofContext,  ///
+            leftTermNode = leftTermNodeQuery(statementNode),
+            rightTermNode = rightTermNodeQuery(statementNode),
+            leftTermVerified = verifyTerm(leftTermNode, types, context),
+            rightTermVerified = verifyTerm(rightTermNode, types, context);
+
+      if (leftTermVerified && rightTermVerified) {
+        const firstType = first(types),
+              secondType = second(types),
+              leftType = firstType, ///
+              rightType = secondType, ///
+              leftTermString = nodeAsString(leftTermNode),
+              rightTermString = nodeAsString(rightTermNode);
+
+        if ((leftType === null) && (rightType === null)) {
+          proofContext.error(`The types of the '${leftTermString}' and '${rightTermString}' terms are both undefined and therefore the terms cannot be equated.`);
+        } else if (rightType === null) {
+          const type = leftType,  ///
+                termNode = rightTermNode, ///
+                variable = addVariable(type, termNode, proofContext);
+
+          if (variable !== null) {
+            const leftTypeName = leftType.getName();
+
+            proofContext.info(`The '${rightTermString}' variable has been given the '${leftTypeName}' type.`);
+
+            statementVerifiedAsEquality = true;
+          }
+        } else if (leftType === null) {
+          const type = rightType,  ///
+                termNode = leftType, ///
+                variable = addVariable(type, termNode, proofContext);
+
+          if (variable !== null) {
+            const rightTypeName = rightType.getName();
+
+            proofContext.info(`The '${rightTermString}' variable has been given the '${rightTypeName}' type.`);
+
+            statementVerifiedAsEquality = true;
+          }
+        } else {
+          const leftTypeMatchesRightType = leftType.match(rightType);
+
+          if (!leftTypeMatchesRightType) {
+            proofContext.error(`The types of the '${leftTermString}' and '${rightTermString}' terms do not match and therefore the terms cannot be equated.`);
+          } else {
+            const derived = proofContext.isDerived();
+
+            if (!derived) {
+              statementVerifiedAsEquality = true;
+            } else {
+              const equality = Equality.fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode),
+                    proofSteps = proofContext.getProofSteps(),
+                    equalities = equalitiesFromProofSteps(proofSteps),
+                    equalityEquates = equality.equate(equalities, proofContext);
+
+              statementVerifiedAsEquality = equalityEquates;  ///
+            }
+          }
+        }
+      }
+    }
+  }
+
+  if (statementVerifiedAsEquality) {
+    proofContext.info(`Verified the '${statementString}' equality.`);
+  }
+
+  statementVerifiedAsEquality ?
+    proofContext.complete(statementNode) :
+      proofContext.halt(statementNode);
+
+  return statementVerifiedAsEquality;
+}
+
+function equalitiesFromProofSteps(proofSteps) {
+  const start = -MAXIMUM_INDEXES_LENGTH;  ///
+
+  proofSteps = proofSteps.slice(start); ///
+
+  const equalities = proofSteps.reduce((equalities, proofStep, index) => {
+    const equality = Equality.fromProofStep(proofStep);
+
+    if (equality !== null) {
+      equalities.push(equality);
+    }
+
+    return equalities;
+  }, []);
+
+  return equalities;
+}
+
+function addVariable(type, termNode, proofContext) {
+  let variable = null;
+
+  const variables = [],
+        termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, proofContext);
+
+  if (termVerifiedAsVariable) {
+    const firstVariable = first(variables);
+
+    variable = firstVariable;  ///
+
+    const name = variable.getName();
+
+    variable = Variable.fromTypeAndName(type, name);  ///
+
+    proofContext.addVariable(variable);
+  }
+
+  return variable;
+}

package/src/verify/{assertion/type.js → statementTypeAssertion.js}

@@ -1,53 +1,59 @@
 "use strict";
 
-import { first } from "../../utilities/array";
-import { nodeAsString } from "../../utilities/string";
-import { nodeQuery, typeNameFromTypeNode } from "../../utilities/query";
-import { verifyTermAsVariable, verifyTermAgainstConstructors } from "../../verify/term";
-import Variable from "../../variable";
+import Variable from "../variable";
+
+import { first } from "../utilities/array";
+import { nodeAsString } from "../utilities/string";
+import { nodeQuery, typeNameFromTypeNode } from "../utilities/query";
+import { verifyTermAsVariable, verifyTermAgainstConstructors } from "../verify/term";
 
 const termNodeQuery = nodeQuery("/typeAssertion/term"),
-      typeNodeQuery = nodeQuery("/typeAssertion/type");
+      typeNodeQuery = nodeQuery("/typeAssertion/type"),
+      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
 
-export default function verifyTypeAssertion(typeAssertionNode, proofContext) {
+export default function verifyStatementTypeAssertion(statementNode, proofContext) {
   let typeAssertionVerified = false;
 
-  proofContext.begin(typeAssertionNode);
+  proofContext.begin(statementNode);
 
-  const typeAssertionString = nodeAsString(typeAssertionNode);
+  const statementString = nodeAsString(statementNode);
 
-  proofContext.debug(`Verifying the '${typeAssertionString}' type assertion...`);
+  proofContext.debug(`Verifying the '${statementString}' statement type assertion...`);
 
-  const typeNode = typeNodeQuery(typeAssertionNode),
-        typeName = typeNameFromTypeNode(typeNode),
-        typePresent = proofContext.isTypePresentByTypeName(typeName);
-
-  if (!typePresent) {
-    proofContext.error(`The ${typeName} type is not present.`);
-  } else {
-    const context = proofContext, ///
-          termNode = termNodeQuery(typeAssertionNode),
-          variables = [],
-          termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context);
+  const typeAssertionNode = typeAssertionNodeQuery(statementNode);
 
-    if (termVerifiedAsVariable) {
-      const variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, proofContext);
+  if (typeAssertionNode !== null) {
+    const typeNode = typeNodeQuery(typeAssertionNode),
+          typeName = typeNameFromTypeNode(typeNode),
+          typePresent = proofContext.isTypePresentByTypeName(typeName);
 
-      typeAssertionVerified = variableTypeAssertionVerified;  ///
+    if (!typePresent) {
+      proofContext.error(`The ${typeName} type is not present.`);
     } else {
-      const termTypeAssertionVerified = verifyTermTypeAssertion(typeAssertionNode, proofContext);
+      const context = proofContext, ///
+            termNode = termNodeQuery(typeAssertionNode),
+            variables = [],
+            termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context);
+
+      if (termVerifiedAsVariable) {
+        const variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, proofContext);
 
-      typeAssertionVerified = termTypeAssertionVerified;  ///
+        typeAssertionVerified = variableTypeAssertionVerified;  ///
+      } else {
+        const termTypeAssertionVerified = verifyTermTypeAssertion(typeAssertionNode, proofContext);
+
+        typeAssertionVerified = termTypeAssertionVerified;  ///
+      }
     }
   }
 
   if (typeAssertionVerified) {
-    proofContext.info(`Verified the '${typeAssertionString}' type assertion.`);
+    proofContext.info(`Verified the '${statementString}' statement type assertion.`);
   }
 
   typeAssertionVerified ?
-    proofContext.complete(typeAssertionNode) :
-      proofContext.halt(typeAssertionNode);
+    proofContext.complete(statementNode) :
+      proofContext.halt(statementNode);
 
   return typeAssertionVerified;
 }
@@ -97,8 +103,11 @@ function verifyVariableTypeAssertion(typeAssertionNode, proofContext) {
         firstVariable = first(variables),
         variable = firstVariable, ///
         variableName = variable.getName(),
-        variableType = variable.getType(),
-        assertedTypeEqualToOrSubTypeOfVariableType = assertedType.isEqualToOrSubTypeOf(variableType);
+        variableType = variable.getType();
+
+  const assertedTypeEqualToOrSubTypeOfVariableType = (variableType === null) ?
+                                                        true :  ///
+                                                          assertedType.isEqualToOrSubTypeOf(variableType);
 
   if (!assertedTypeEqualToOrSubTypeOfVariableType) {
     proofContext.error(`The asserted type is not equal to or a sub-type of the '${variableName}' variable type.`);

package/lib/verify/assertion/type.js

@@ -1,78 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return verifyTypeAssertion;
-    }
-});
-var _array = require("../../utilities/array");
-var _string = require("../../utilities/string");
-var _query = require("../../utilities/query");
-var _term = require("../../verify/term");
-var _variable = /*#__PURE__*/ _interopRequireDefault(require("../../variable"));
-function _interopRequireDefault(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-var termNodeQuery = (0, _query.nodeQuery)("/typeAssertion/term"), typeNodeQuery = (0, _query.nodeQuery)("/typeAssertion/type");
-function verifyTypeAssertion(typeAssertionNode, proofContext) {
-    var typeAssertionVerified = false;
-    proofContext.begin(typeAssertionNode);
-    var typeAssertionString = (0, _string.nodeAsString)(typeAssertionNode);
-    proofContext.debug("Verifying the '".concat(typeAssertionString, "' type assertion..."));
-    var typeNode = typeNodeQuery(typeAssertionNode), typeName = (0, _query.typeNameFromTypeNode)(typeNode), typePresent = proofContext.isTypePresentByTypeName(typeName);
-    if (!typePresent) {
-        proofContext.error("The ".concat(typeName, " type is not present."));
-    } else {
-        var context = proofContext, termNode = termNodeQuery(typeAssertionNode), variables = [], termVerifiedAsVariable = (0, _term.verifyTermAsVariable)(termNode, variables, context);
-        if (termVerifiedAsVariable) {
-            var variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, proofContext);
-            typeAssertionVerified = variableTypeAssertionVerified; ///
-        } else {
-            var termTypeAssertionVerified = verifyTermTypeAssertion(typeAssertionNode, proofContext);
-            typeAssertionVerified = termTypeAssertionVerified; ///
-        }
-    }
-    if (typeAssertionVerified) {
-        proofContext.info("Verified the '".concat(typeAssertionString, "' type assertion."));
-    }
-    typeAssertionVerified ? proofContext.complete(typeAssertionNode) : proofContext.halt(typeAssertionNode);
-    return typeAssertionVerified;
-}
-function verifyTermTypeAssertion(typeAssertionNode, proofContext) {
-    var termTypeAssertionVerified = false;
-    var types = [], context = proofContext, termNode = termNodeQuery(typeAssertionNode), termVerifiedAgainstConstructors = (0, _term.verifyTermAgainstConstructors)(termNode, types, context);
-    if (termVerifiedAgainstConstructors) {
-        var typeNode = typeNodeQuery(typeAssertionNode), typeName = (0, _query.typeNameFromTypeNode)(typeNode), assertedTypeName = typeName, assertedType = proofContext.findTypeByTypeName(assertedTypeName), firstType = (0, _array.first)(types), termType = firstType, assertedTypeEqualToOrSubTypeOfTermType = assertedType.isEqualToOrSubTypeOf(termType);
-        if (!assertedTypeEqualToOrSubTypeOfTermType) {
-            var termString = (0, _string.nodeAsString)(termNode);
-            proofContext.error("The asserted type is not equal to or a sub-type of the '".concat(termString, "' term type."));
-        } else {
-            termTypeAssertionVerified = true;
-        }
-    }
-    return termTypeAssertionVerified;
-}
-function verifyVariableTypeAssertion(typeAssertionNode, proofContext) {
-    var variableTypeAssertionVerified = false;
-    var context = proofContext, variables = [], termNode = termNodeQuery(typeAssertionNode);
-    (0, _term.verifyTermAsVariable)(termNode, variables, context);
-    var typeNode = typeNodeQuery(typeAssertionNode), typeName = (0, _query.typeNameFromTypeNode)(typeNode), assertedTypeName = typeName, assertedType = proofContext.findTypeByTypeName(assertedTypeName), firstVariable = (0, _array.first)(variables), variable = firstVariable, variableName = variable.getName(), variableType = variable.getType(), assertedTypeEqualToOrSubTypeOfVariableType = assertedType.isEqualToOrSubTypeOf(variableType);
-    if (!assertedTypeEqualToOrSubTypeOfVariableType) {
-        proofContext.error("The asserted type is not equal to or a sub-type of the '".concat(variableName, "' variable type."));
-    } else {
-        var derived = proofContext.isDerived();
-        if (!derived) {
-            var type = assertedType, name = variableName, variable1 = _variable.default.fromTypeAndName(type, name);
-            proofContext.addVariable(variable1);
-        }
-        variableTypeAssertionVerified = true;
-    }
-    return variableTypeAssertionVerified;
-}
-
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/verify/assertion/type.js"],"sourcesContent":["\"use strict\";\n\nimport { first } from \"../../utilities/array\";\nimport { nodeAsString } from \"../../utilities/string\";\nimport { nodeQuery, typeNameFromTypeNode } from \"../../utilities/query\";\nimport { verifyTermAsVariable, verifyTermAgainstConstructors } from \"../../verify/term\";\nimport Variable from \"../../variable\";\n\nconst termNodeQuery = nodeQuery(\"/typeAssertion/term\"),\n      typeNodeQuery = nodeQuery(\"/typeAssertion/type\");\n\nexport default function verifyTypeAssertion(typeAssertionNode, proofContext) {\n  let typeAssertionVerified = false;\n\n  proofContext.begin(typeAssertionNode);\n\n  const typeAssertionString = nodeAsString(typeAssertionNode);\n\n  proofContext.debug(`Verifying the '${typeAssertionString}' type assertion...`);\n\n  const typeNode = typeNodeQuery(typeAssertionNode),\n        typeName = typeNameFromTypeNode(typeNode),\n        typePresent = proofContext.isTypePresentByTypeName(typeName);\n\n  if (!typePresent) {\n    proofContext.error(`The ${typeName} type is not present.`);\n  } else {\n    const context = proofContext, ///\n          termNode = termNodeQuery(typeAssertionNode),\n          variables = [],\n          termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context);\n\n    if (termVerifiedAsVariable) {\n      const variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, proofContext);\n\n      typeAssertionVerified = variableTypeAssertionVerified;  ///\n    } else {\n      const termTypeAssertionVerified = verifyTermTypeAssertion(typeAssertionNode, proofContext);\n\n      typeAssertionVerified = termTypeAssertionVerified;  ///\n    }\n  }\n\n  if (typeAssertionVerified) {\n    proofContext.info(`Verified the '${typeAssertionString}' type assertion.`);\n  }\n\n  typeAssertionVerified ?\n    proofContext.complete(typeAssertionNode) :\n      proofContext.halt(typeAssertionNode);\n\n  return typeAssertionVerified;\n}\n\nfunction verifyTermTypeAssertion(typeAssertionNode, proofContext) {\n  let termTypeAssertionVerified = false;\n\n  const types = [],\n        context = proofContext, ///\n        termNode = termNodeQuery(typeAssertionNode),\n        termVerifiedAgainstConstructors = verifyTermAgainstConstructors(termNode, types, context);\n\n  if (termVerifiedAgainstConstructors) {\n    const typeNode = typeNodeQuery(typeAssertionNode),\n          typeName = typeNameFromTypeNode(typeNode),\n          assertedTypeName = typeName,  ///\n          assertedType = proofContext.findTypeByTypeName(assertedTypeName),\n          firstType = first(types),\n          termType = firstType,\n          assertedTypeEqualToOrSubTypeOfTermType = assertedType.isEqualToOrSubTypeOf(termType);\n\n    if (!assertedTypeEqualToOrSubTypeOfTermType) {\n      const termString = nodeAsString(termNode);\n\n      proofContext.error(`The asserted type is not equal to or a sub-type of the '${termString}' term type.`);\n    } else {\n      termTypeAssertionVerified = true;\n    }\n  }\n\n  return termTypeAssertionVerified;\n}\n\nfunction verifyVariableTypeAssertion(typeAssertionNode, proofContext) {\n  let variableTypeAssertionVerified = false;\n\n  const context = proofContext, ///\n        variables = [],\n        termNode = termNodeQuery(typeAssertionNode);\n\n  verifyTermAsVariable(termNode, variables, context);\n\n  const typeNode = typeNodeQuery(typeAssertionNode),\n        typeName = typeNameFromTypeNode(typeNode),\n        assertedTypeName = typeName,  ///\n        assertedType = proofContext.findTypeByTypeName(assertedTypeName),\n        firstVariable = first(variables),\n        variable = firstVariable, ///\n        variableName = variable.getName(),\n        variableType = variable.getType(),\n        assertedTypeEqualToOrSubTypeOfVariableType = assertedType.isEqualToOrSubTypeOf(variableType);\n\n  if (!assertedTypeEqualToOrSubTypeOfVariableType) {\n    proofContext.error(`The asserted type is not equal to or a sub-type of the '${variableName}' variable type.`);\n  } else {\n    const derived = proofContext.isDerived();\n\n    if (!derived) {\n      const type = assertedType,  ///\n            name = variableName,  ///\n            variable = Variable.fromTypeAndName(type, name);\n\n      proofContext.addVariable(variable);\n    }\n\n    variableTypeAssertionVerified = true;\n  }\n\n  return variableTypeAssertionVerified;\n}\n"],"names":["verifyTypeAssertion","termNodeQuery","nodeQuery","typeNodeQuery","typeAssertionNode","proofContext","typeAssertionVerified","begin","typeAssertionString","nodeAsString","debug","typeNode","typeName","typeNameFromTypeNode","typePresent","isTypePresentByTypeName","error","context","termNode","variables","termVerifiedAsVariable","verifyTermAsVariable","variableTypeAssertionVerified","verifyVariableTypeAssertion","termTypeAssertionVerified","verifyTermTypeAssertion","info","complete","halt","types","termVerifiedAgainstConstructors","verifyTermAgainstConstructors","assertedTypeName","assertedType","findTypeByTypeName","firstType","first","termType","assertedTypeEqualToOrSubTypeOfTermType","isEqualToOrSubTypeOf","termString","firstVariable","variable","variableName","getName","variableType","getType","assertedTypeEqualToOrSubTypeOfVariableType","derived","isDerived","type","name","Variable","fromTypeAndName","addVariable"],"mappings":"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"}

package/lib/verify/equality.js

@@ -1,68 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return verifyEquality;
-    }
-});
-var _equality = /*#__PURE__*/ _interopRequireDefault(require("../equality"));
-var _term = /*#__PURE__*/ _interopRequireDefault(require("../verify/term"));
-var _query = require("../utilities/query");
-var _string = require("../utilities/string");
-var _array = require("../utilities/array");
-var _constants = require("../constants");
-function _interopRequireDefault(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-var leftTermNodeQuery = (0, _query.nodeQuery)("/equality/term[0]"), rightTermNodeQuery = (0, _query.nodeQuery)("/equality/term[1]");
-function verifyEquality(equalityNode, proofContext) {
-    var equalityVerified = false;
-    proofContext.begin(equalityNode);
-    var equalityString = (0, _string.nodeAsString)(equalityNode);
-    proofContext.debug("Verifying the '".concat(equalityString, "' equality..."));
-    var equalityTypesVerified = verifyEqualityTypes(equalityNode, proofContext);
-    if (equalityTypesVerified) {
-        var derived = proofContext.isDerived();
-        if (derived) {
-            var equality = _equality.default.fromEqualityNode(equalityNode), proofSteps = proofContext.getProofSteps(), equalities = equalitiesFromProofSteps(proofSteps), equalityEquates = equality.equate(equalities, proofContext);
-            equalityVerified = equalityEquates; ///
-        } else {
-            equalityVerified = true;
-        }
-    }
-    if (equalityVerified) {
-        proofContext.info("Verified the '".concat(equalityString, "' equality."));
-    }
-    equalityVerified ? proofContext.complete(equalityNode) : proofContext.halt(equalityNode);
-    return equalityVerified;
-}
-function verifyEqualityTypes(equalityNode, proofContext) {
-    var equalityTypesVerified = false;
-    var types = [], context = proofContext, leftTermNode = leftTermNodeQuery(equalityNode), rightTermNode = rightTermNodeQuery(equalityNode), leftTermVerified = (0, _term.default)(leftTermNode, types, context), rightTermVerified = (0, _term.default)(rightTermNode, types, context);
-    if (leftTermVerified && rightTermVerified) {
-        var firstType = (0, _array.first)(types), secondType = (0, _array.second)(types), leftType = firstType, rightType = secondType, leftTypeEqualToSubTypeOfOrSuperTypeOfRightType = leftType.isEqualToSubTypeOfOrSuperTypeOf(rightType);
-        if (leftTypeEqualToSubTypeOfOrSuperTypeOfRightType) {
-            equalityTypesVerified = true;
-        }
-    }
-    return equalityTypesVerified;
-}
-function equalitiesFromProofSteps(proofSteps) {
-    var start = -_constants.MAXIMUM_INDEXES_LENGTH; ///
-    proofSteps = proofSteps.slice(start); ///
-    var equalities = proofSteps.reduce(function(equalities, proofStep, index) {
-        var equality = _equality.default.fromProofStep(proofStep);
-        if (equality !== null) {
-            equalities.push(equality);
-        }
-        return equalities;
-    }, []);
-    return equalities;
-}
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy92ZXJpZnkvZXF1YWxpdHkuanMiXSwic291cmNlc0NvbnRlbnQiOlsiXCJ1c2Ugc3RyaWN0XCI7XG5cbmltcG9ydCBFcXVhbGl0eSBmcm9tIFwiLi4vZXF1YWxpdHlcIjtcbmltcG9ydCB2ZXJpZnlUZXJtIGZyb20gXCIuLi92ZXJpZnkvdGVybVwiO1xuXG5pbXBvcnQgeyBub2RlUXVlcnkgfSBmcm9tIFwiLi4vdXRpbGl0aWVzL3F1ZXJ5XCI7XG5pbXBvcnQgeyBub2RlQXNTdHJpbmcgfSBmcm9tIFwiLi4vdXRpbGl0aWVzL3N0cmluZ1wiO1xuaW1wb3J0IHsgZmlyc3QsIHNlY29uZCB9IGZyb20gXCIuLi91dGlsaXRpZXMvYXJyYXlcIjtcbmltcG9ydCB7IE1BWElNVU1fSU5ERVhFU19MRU5HVEggfSBmcm9tIFwiLi4vY29uc3RhbnRzXCI7XG5cbmNvbnN0IGxlZnRUZXJtTm9kZVF1ZXJ5ID0gbm9kZVF1ZXJ5KFwiL2VxdWFsaXR5L3Rlcm1bMF1cIiksXG4gICAgICByaWdodFRlcm1Ob2RlUXVlcnkgPSBub2RlUXVlcnkoXCIvZXF1YWxpdHkvdGVybVsxXVwiKTtcblxuZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24gdmVyaWZ5RXF1YWxpdHkoZXF1YWxpdHlOb2RlLCBwcm9vZkNvbnRleHQpIHtcbiAgbGV0IGVxdWFsaXR5VmVyaWZpZWQgPSBmYWxzZTtcblxuICBwcm9vZkNvbnRleHQuYmVnaW4oZXF1YWxpdHlOb2RlKTtcblxuICBjb25zdCBlcXVhbGl0eVN0cmluZyA9IG5vZGVBc1N0cmluZyhlcXVhbGl0eU5vZGUpO1xuXG4gIHByb29mQ29udGV4dC5kZWJ1ZyhgVmVyaWZ5aW5nIHRoZSAnJHtlcXVhbGl0eVN0cmluZ30nIGVxdWFsaXR5Li4uYCk7XG5cbiAgY29uc3QgZXF1YWxpdHlUeXBlc1ZlcmlmaWVkID0gdmVyaWZ5RXF1YWxpdHlUeXBlcyhlcXVhbGl0eU5vZGUsIHByb29mQ29udGV4dCk7XG5cbiAgaWYgKGVxdWFsaXR5VHlwZXNWZXJpZmllZCkge1xuICAgIGNvbnN0IGRlcml2ZWQgPSBwcm9vZkNvbnRleHQuaXNEZXJpdmVkKCk7XG5cbiAgICBpZiAoZGVyaXZlZCkge1xuICAgICAgY29uc3QgZXF1YWxpdHkgPSBFcXVhbGl0eS5mcm9tRXF1YWxpdHlOb2RlKGVxdWFsaXR5Tm9kZSksXG4gICAgICAgICAgICBwcm9vZlN0ZXBzID0gcHJvb2ZDb250ZXh0LmdldFByb29mU3RlcHMoKSxcbiAgICAgICAgICAgIGVxdWFsaXRpZXMgPSBlcXVhbGl0aWVzRnJvbVByb29mU3RlcHMocHJvb2ZTdGVwcyksXG4gICAgICAgICAgICBlcXVhbGl0eUVxdWF0ZXMgPSBlcXVhbGl0eS5lcXVhdGUoZXF1YWxpdGllcywgcHJvb2ZDb250ZXh0KTtcblxuICAgICAgZXF1YWxpdHlWZXJpZmllZCA9IGVxdWFsaXR5RXF1YXRlczsgIC8vL1xuICAgIH0gZWxzZSB7XG4gICAgICBlcXVhbGl0eVZlcmlmaWVkID0gdHJ1ZTtcbiAgICB9XG4gIH1cblxuICBpZiAoZXF1YWxpdHlWZXJpZmllZCkge1xuICAgIHByb29mQ29udGV4dC5pbmZvKGBWZXJpZmllZCB0aGUgJyR7ZXF1YWxpdHlTdHJpbmd9JyBlcXVhbGl0eS5gKTtcbiAgfVxuXG4gIGVxdWFsaXR5VmVyaWZpZWQgP1xuICAgIHByb29mQ29udGV4dC5jb21wbGV0ZShlcXVhbGl0eU5vZGUpIDpcbiAgICAgIHByb29mQ29udGV4dC5oYWx0KGVxdWFsaXR5Tm9kZSk7XG5cbiAgcmV0dXJuIGVxdWFsaXR5VmVyaWZpZWQ7XG59XG5cbmZ1bmN0aW9uIHZlcmlmeUVxdWFsaXR5VHlwZXMoZXF1YWxpdHlOb2RlLCBwcm9vZkNvbnRleHQpIHtcbiAgbGV0IGVxdWFsaXR5VHlwZXNWZXJpZmllZCA9IGZhbHNlO1xuXG4gIGNvbnN0IHR5cGVzID0gW10sXG4gICAgICAgIGNvbnRleHQgPSBwcm9vZkNvbnRleHQsICAvLy9cbiAgICAgICAgbGVmdFRlcm1Ob2RlID0gbGVmdFRlcm1Ob2RlUXVlcnkoZXF1YWxpdHlOb2RlKSxcbiAgICAgICAgcmlnaHRUZXJtTm9kZSA9IHJpZ2h0VGVybU5vZGVRdWVyeShlcXVhbGl0eU5vZGUpLFxuICAgICAgICBsZWZ0VGVybVZlcmlmaWVkID0gdmVyaWZ5VGVybShsZWZ0VGVybU5vZGUsIHR5cGVzLCBjb250ZXh0KSxcbiAgICAgICAgcmlnaHRUZXJtVmVyaWZpZWQgPSB2ZXJpZnlUZXJtKHJpZ2h0VGVybU5vZGUsIHR5cGVzLCBjb250ZXh0KTtcblxuICBpZiAobGVmdFRlcm1WZXJpZmllZCAmJiByaWdodFRlcm1WZXJpZmllZCkge1xuICAgIGNvbnN0IGZpcnN0VHlwZSA9IGZpcnN0KHR5cGVzKSxcbiAgICAgICAgICBzZWNvbmRUeXBlID0gc2Vjb25kKHR5cGVzKSxcbiAgICAgICAgICBsZWZ0VHlwZSA9IGZpcnN0VHlwZSwgLy8vXG4gICAgICAgICAgcmlnaHRUeXBlID0gc2Vjb25kVHlwZSwgLy8vXG4gICAgICAgICAgbGVmdFR5cGVFcXVhbFRvU3ViVHlwZU9mT3JTdXBlclR5cGVPZlJpZ2h0VHlwZSA9IGxlZnRUeXBlLmlzRXF1YWxUb1N1YlR5cGVPZk9yU3VwZXJUeXBlT2YocmlnaHRUeXBlKTtcblxuICAgIGlmIChsZWZ0VHlwZUVxdWFsVG9TdWJUeXBlT2ZPclN1cGVyVHlwZU9mUmlnaHRUeXBlKSB7XG4gICAgICBlcXVhbGl0eVR5cGVzVmVyaWZpZWQgPSB0cnVlO1xuICAgIH1cbiAgfVxuXG4gIHJldHVybiBlcXVhbGl0eVR5cGVzVmVyaWZpZWQ7XG59XG5cbmZ1bmN0aW9uIGVxdWFsaXRpZXNGcm9tUHJvb2ZTdGVwcyhwcm9vZlN0ZXBzKSB7XG4gIGNvbnN0IHN0YXJ0ID0gLU1BWElNVU1fSU5ERVhFU19MRU5HVEg7ICAvLy9cblxuICBwcm9vZlN0ZXBzID0gcHJvb2ZTdGVwcy5zbGljZShzdGFydCk7IC8vL1xuXG4gIGNvbnN0IGVxdWFsaXRpZXMgPSBwcm9vZlN0ZXBzLnJlZHVjZSgoZXF1YWxpdGllcywgcHJvb2ZTdGVwLCBpbmRleCkgPT4ge1xuICAgIGNvbnN0IGVxdWFsaXR5ID0gRXF1YWxpdHkuZnJvbVByb29mU3RlcChwcm9vZlN0ZXApO1xuXG4gICAgaWYgKGVxdWFsaXR5ICE9PSBudWxsKSB7XG4gICAgICBlcXVhbGl0aWVzLnB1c2goZXF1YWxpdHkpO1xuICAgIH1cblxuICAgIHJldHVybiBlcXVhbGl0aWVzO1xuICB9LCBbXSk7XG5cbiAgcmV0dXJuIGVxdWFsaXRpZXM7XG59XG4iXSwibmFtZXMiOlsidmVyaWZ5RXF1YWxpdHkiLCJsZWZ0VGVybU5vZGVRdWVyeSIsIm5vZGVRdWVyeSIsInJpZ2h0VGVybU5vZGVRdWVyeSIsImVxdWFsaXR5Tm9kZSIsInByb29mQ29udGV4dCIsImVxdWFsaXR5VmVyaWZpZWQiLCJiZWdpbiIsImVxdWFsaXR5U3RyaW5nIiwibm9kZUFzU3RyaW5nIiwiZGVidWciLCJlcXVhbGl0eVR5cGVzVmVyaWZpZWQiLCJ2ZXJpZnlFcXVhbGl0eVR5cGVzIiwiZGVyaXZlZCIsImlzRGVyaXZlZCIsImVxdWFsaXR5IiwiRXF1YWxpdHkiLCJmcm9tRXF1YWxpdHlOb2RlIiwicHJvb2ZTdGVwcyIsImdldFByb29mU3RlcHMiLCJlcXVhbGl0aWVzIiwiZXF1YWxpdGllc0Zyb21Qcm9vZlN0ZXBzIiwiZXF1YWxpdHlFcXVhdGVzIiwiZXF1YXRlIiwiaW5mbyIsImNvbXBsZXRlIiwiaGFsdCIsInR5cGVzIiwiY29udGV4dCIsImxlZnRUZXJtTm9kZSIsInJpZ2h0VGVybU5vZGUiLCJsZWZ0VGVybVZlcmlmaWVkIiwidmVyaWZ5VGVybSIsInJpZ2h0VGVybVZlcmlmaWVkIiwiZmlyc3RUeXBlIiwiZmlyc3QiLCJzZWNvbmRUeXBlIiwic2Vjb25kIiwibGVmdFR5cGUiLCJyaWdodFR5cGUiLCJsZWZ0VHlwZUVxdWFsVG9TdWJUeXBlT2ZPclN1cGVyVHlwZU9mUmlnaHRUeXBlIiwiaXNFcXVhbFRvU3ViVHlwZU9mT3JTdXBlclR5cGVPZiIsInN0YXJ0IiwiTUFYSU1VTV9JTkRFWEVTX0xFTkdUSCIsInNsaWNlIiwicmVkdWNlIiwicHJvb2ZTdGVwIiwiaW5kZXgiLCJmcm9tUHJvb2ZTdGVwIiwicHVzaCJdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7K0JBYUE7OztlQUF3QkE7Ozs2REFYSDt5REFDRTtxQkFFRztzQkFDRztxQkFDQzt5QkFDUzs7Ozs7O0FBRXZDLElBQU1DLG9CQUFvQkMsSUFBQUEsZ0JBQVMsRUFBQyxzQkFDOUJDLHFCQUFxQkQsSUFBQUEsZ0JBQVMsRUFBQztBQUV0QixTQUFTRixlQUFlSSxZQUFZLEVBQUVDLFlBQVksRUFBRTtJQUNqRSxJQUFJQyxtQkFBbUIsS0FBSztJQUU1QkQsYUFBYUUsS0FBSyxDQUFDSDtJQUVuQixJQUFNSSxpQkFBaUJDLElBQUFBLG9CQUFZLEVBQUNMO0lBRXBDQyxhQUFhSyxLQUFLLENBQUMsQUFBQyxrQkFBZ0MsT0FBZkYsZ0JBQWU7SUFFcEQsSUFBTUcsd0JBQXdCQyxvQkFBb0JSLGNBQWNDO0lBRWhFLElBQUlNLHVCQUF1QjtRQUN6QixJQUFNRSxVQUFVUixhQUFhUyxTQUFTO1FBRXRDLElBQUlELFNBQVM7WUFDWCxJQUFNRSxXQUFXQyxpQkFBUSxDQUFDQyxnQkFBZ0IsQ0FBQ2IsZUFDckNjLGFBQWFiLGFBQWFjLGFBQWEsSUFDdkNDLGFBQWFDLHlCQUF5QkgsYUFDdENJLGtCQUFrQlAsU0FBU1EsTUFBTSxDQUFDSCxZQUFZZjtZQUVwREMsbUJBQW1CZ0IsaUJBQWtCLEdBQUc7UUFDMUMsT0FBTztZQUNMaEIsbUJBQW1CLElBQUk7UUFDekIsQ0FBQztJQUNILENBQUM7SUFFRCxJQUFJQSxrQkFBa0I7UUFDcEJELGFBQWFtQixJQUFJLENBQUMsQUFBQyxpQkFBK0IsT0FBZmhCLGdCQUFlO0lBQ3BELENBQUM7SUFFREYsbUJBQ0VELGFBQWFvQixRQUFRLENBQUNyQixnQkFDcEJDLGFBQWFxQixJQUFJLENBQUN0QixhQUFhO0lBRW5DLE9BQU9FO0FBQ1Q7QUFFQSxTQUFTTSxvQkFBb0JSLFlBQVksRUFBRUMsWUFBWSxFQUFFO0lBQ3ZELElBQUlNLHdCQUF3QixLQUFLO0lBRWpDLElBQU1nQixRQUFRLEVBQUUsRUFDVkMsVUFBVXZCLGNBQ1Z3QixlQUFlNUIsa0JBQWtCRyxlQUNqQzBCLGdCQUFnQjNCLG1CQUFtQkMsZUFDbkMyQixtQkFBbUJDLElBQUFBLGFBQVUsRUFBQ0gsY0FBY0YsT0FBT0MsVUFDbkRLLG9CQUFvQkQsSUFBQUEsYUFBVSxFQUFDRixlQUFlSCxPQUFPQztJQUUzRCxJQUFJRyxvQkFBb0JFLG1CQUFtQjtRQUN6QyxJQUFNQyxZQUFZQyxJQUFBQSxZQUFLLEVBQUNSLFFBQ2xCUyxhQUFhQyxJQUFBQSxhQUFNLEVBQUNWLFFBQ3BCVyxXQUFXSixXQUNYSyxZQUFZSCxZQUNaSSxpREFBaURGLFNBQVNHLCtCQUErQixDQUFDRjtRQUVoRyxJQUFJQyxnREFBZ0Q7WUFDbEQ3Qix3QkFBd0IsSUFBSTtRQUM5QixDQUFDO0lBQ0gsQ0FBQztJQUVELE9BQU9BO0FBQ1Q7QUFFQSxTQUFTVSx5QkFBeUJILFVBQVUsRUFBRTtJQUM1QyxJQUFNd0IsUUFBUSxDQUFDQyxpQ0FBc0IsRUFBRyxHQUFHO0lBRTNDekIsYUFBYUEsV0FBVzBCLEtBQUssQ0FBQ0YsUUFBUSxHQUFHO0lBRXpDLElBQU10QixhQUFhRixXQUFXMkIsTUFBTSxDQUFDLFNBQUN6QixZQUFZMEIsV0FBV0MsT0FBVTtRQUNyRSxJQUFNaEMsV0FBV0MsaUJBQVEsQ0FBQ2dDLGFBQWEsQ0FBQ0Y7UUFFeEMsSUFBSS9CLGFBQWEsSUFBSSxFQUFFO1lBQ3JCSyxXQUFXNkIsSUFBSSxDQUFDbEM7UUFDbEIsQ0FBQztRQUVELE9BQU9LO0lBQ1QsR0FBRyxFQUFFO0lBRUwsT0FBT0E7QUFDVCJ9

package/src/verify/equality.js

@@ -1,92 +0,0 @@
-"use strict";
-
-import Equality from "../equality";
-import verifyTerm from "../verify/term";
-
-import { nodeQuery } from "../utilities/query";
-import { nodeAsString } from "../utilities/string";
-import { first, second } from "../utilities/array";
-import { MAXIMUM_INDEXES_LENGTH } from "../constants";
-
-const leftTermNodeQuery = nodeQuery("/equality/term[0]"),
-      rightTermNodeQuery = nodeQuery("/equality/term[1]");
-
-export default function verifyEquality(equalityNode, proofContext) {
-  let equalityVerified = false;
-
-  proofContext.begin(equalityNode);
-
-  const equalityString = nodeAsString(equalityNode);
-
-  proofContext.debug(`Verifying the '${equalityString}' equality...`);
-
-  const equalityTypesVerified = verifyEqualityTypes(equalityNode, proofContext);
-
-  if (equalityTypesVerified) {
-    const derived = proofContext.isDerived();
-
-    if (derived) {
-      const equality = Equality.fromEqualityNode(equalityNode),
-            proofSteps = proofContext.getProofSteps(),
-            equalities = equalitiesFromProofSteps(proofSteps),
-            equalityEquates = equality.equate(equalities, proofContext);
-
-      equalityVerified = equalityEquates;  ///
-    } else {
-      equalityVerified = true;
-    }
-  }
-
-  if (equalityVerified) {
-    proofContext.info(`Verified the '${equalityString}' equality.`);
-  }
-
-  equalityVerified ?
-    proofContext.complete(equalityNode) :
-      proofContext.halt(equalityNode);
-
-  return equalityVerified;
-}
-
-function verifyEqualityTypes(equalityNode, proofContext) {
-  let equalityTypesVerified = false;
-
-  const types = [],
-        context = proofContext,  ///
-        leftTermNode = leftTermNodeQuery(equalityNode),
-        rightTermNode = rightTermNodeQuery(equalityNode),
-        leftTermVerified = verifyTerm(leftTermNode, types, context),
-        rightTermVerified = verifyTerm(rightTermNode, types, context);
-
-  if (leftTermVerified && rightTermVerified) {
-    const firstType = first(types),
-          secondType = second(types),
-          leftType = firstType, ///
-          rightType = secondType, ///
-          leftTypeEqualToSubTypeOfOrSuperTypeOfRightType = leftType.isEqualToSubTypeOfOrSuperTypeOf(rightType);
-
-    if (leftTypeEqualToSubTypeOfOrSuperTypeOfRightType) {
-      equalityTypesVerified = true;
-    }
-  }
-
-  return equalityTypesVerified;
-}
-
-function equalitiesFromProofSteps(proofSteps) {
-  const start = -MAXIMUM_INDEXES_LENGTH;  ///
-
-  proofSteps = proofSteps.slice(start); ///
-
-  const equalities = proofSteps.reduce((equalities, proofStep, index) => {
-    const equality = Equality.fromProofStep(proofStep);
-
-    if (equality !== null) {
-      equalities.push(equality);
-    }
-
-    return equalities;
-  }, []);
-
-  return equalities;
-}