occam-verify-cli 0.0.479 → 0.0.481

package/lib/verify/statementAsEquality.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return verifyStatementAsEquality;
+    }
+});
+var _equality = /*#__PURE__*/ _interopRequireDefault(require("../equality"));
+var _variable = /*#__PURE__*/ _interopRequireDefault(require("../variable"));
+var _term = /*#__PURE__*/ _interopRequireWildcard(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
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interopRequireWildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+var specialNodeQuery = (0, _query.nodeQuery)("/statement/@special!"), leftTermNodeQuery = (0, _query.nodeQuery)("/statement/term[0]"), rightTermNodeQuery = (0, _query.nodeQuery)("/statement/term[1]");
+function verifyStatementAsEquality(statementNode, proofContext) {
+    var statementVerifiedAsEquality = false;
+    proofContext.begin(statementNode);
+    var statementString = (0, _string.nodeAsString)(statementNode);
+    proofContext.debug("Verifying the '".concat(statementString, "' statement as an equality..."));
+    var specialNode = specialNodeQuery(statementNode);
+    if (specialNode !== null) {
+        var terminalNode = specialNode, terminalNodeContent = terminalNode.getContent();
+        if (terminalNodeContent === _constants.EQUALS_CHARACTER) {
+            var types = [], context = proofContext, leftTermNode = leftTermNodeQuery(statementNode), rightTermNode = rightTermNodeQuery(statementNode), 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, leftTermString = (0, _string.nodeAsString)(leftTermNode), rightTermString = (0, _string.nodeAsString)(rightTermNode);
+                if (leftType === null && rightType === null) {
+                    proofContext.error("The types of the '".concat(leftTermString, "' and '").concat(rightTermString, "' terms are both undefined and therefore the terms cannot be equated."));
+                } else if (rightType === null) {
+                    var type = leftType, termNode = rightTermNode, variable = addVariable(type, termNode, proofContext);
+                    if (variable !== null) {
+                        var leftTypeName = leftType.getName();
+                        proofContext.info("The '".concat(rightTermString, "' variable has been given the '").concat(leftTypeName, "' type."));
+                        statementVerifiedAsEquality = true;
+                    }
+                } else if (leftType === null) {
+                    var type1 = rightType, termNode1 = leftType, variable1 = addVariable(type1, termNode1, proofContext);
+                    if (variable1 !== null) {
+                        var rightTypeName = rightType.getName();
+                        proofContext.info("The '".concat(rightTermString, "' variable has been given the '").concat(rightTypeName, "' type."));
+                        statementVerifiedAsEquality = true;
+                    }
+                } else {
+                    var leftTypeMatchesRightType = leftType.match(rightType);
+                    if (!leftTypeMatchesRightType) {
+                        proofContext.error("The types of the '".concat(leftTermString, "' and '").concat(rightTermString, "' terms do not match and therefore the terms cannot be equated."));
+                    } else {
+                        var derived = proofContext.isDerived();
+                        if (!derived) {
+                            statementVerifiedAsEquality = true;
+                        } else {
+                            var equality = _equality.default.fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode), proofSteps = proofContext.getProofSteps(), equalities = equalitiesFromProofSteps(proofSteps), equalityEquates = equality.equate(equalities, proofContext);
+                            statementVerifiedAsEquality = equalityEquates; ///
+                        }
+                    }
+                }
+            }
+        }
+    }
+    if (statementVerifiedAsEquality) {
+        proofContext.info("Verified the '".concat(statementString, "' equality."));
+    }
+    statementVerifiedAsEquality ? proofContext.complete(statementNode) : proofContext.halt(statementNode);
+    return statementVerifiedAsEquality;
+}
+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;
+}
+function addVariable(type, termNode, proofContext) {
+    var variable = null;
+    var variables = [], termVerifiedAsVariable = (0, _term.verifyTermAsVariable)(termNode, variables, proofContext);
+    if (termVerifiedAsVariable) {
+        var firstVariable = (0, _array.first)(variables);
+        variable = firstVariable; ///
+        var name = variable.getName();
+        variable = _variable.default.fromTypeAndName(type, name); ///
+        proofContext.addVariable(variable);
+    }
+    return variable;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/verify/statementAsEquality.js"],"sourcesContent":["\"use strict\";\n\nimport Equality from \"../equality\";\nimport Variable from \"../variable\";\nimport verifyTerm from \"../verify/term\";\n\nimport { nodeQuery } from \"../utilities/query\";\nimport { nodeAsString } from \"../utilities/string\";\nimport { first, second } from \"../utilities/array\";\nimport { verifyTermAsVariable } from \"../verify/term\";\nimport { EQUALS_CHARACTER, MAXIMUM_INDEXES_LENGTH } from \"../constants\";\n\nconst specialNodeQuery = nodeQuery(\"/statement/@special!\"),\n      leftTermNodeQuery = nodeQuery(\"/statement/term[0]\"),\n      rightTermNodeQuery = nodeQuery(\"/statement/term[1]\");\n\nexport default function verifyStatementAsEquality(statementNode, proofContext) {\n  let statementVerifiedAsEquality = false;\n\n  proofContext.begin(statementNode);\n\n  const statementString = nodeAsString(statementNode);\n\n  proofContext.debug(`Verifying the '${statementString}' statement as an equality...`);\n\n  const specialNode = specialNodeQuery(statementNode);\n\n  if (specialNode !== null) {\n    const terminalNode = specialNode, ///\n          terminalNodeContent = terminalNode.getContent();\n\n    if (terminalNodeContent === EQUALS_CHARACTER) {\n      const types = [],\n            context = proofContext,  ///\n            leftTermNode = leftTermNodeQuery(statementNode),\n            rightTermNode = rightTermNodeQuery(statementNode),\n            leftTermVerified = verifyTerm(leftTermNode, types, context),\n            rightTermVerified = verifyTerm(rightTermNode, types, context);\n\n      if (leftTermVerified && rightTermVerified) {\n        const firstType = first(types),\n              secondType = second(types),\n              leftType = firstType, ///\n              rightType = secondType, ///\n              leftTermString = nodeAsString(leftTermNode),\n              rightTermString = nodeAsString(rightTermNode);\n\n        if ((leftType === null) && (rightType === null)) {\n          proofContext.error(`The types of the '${leftTermString}' and '${rightTermString}' terms are both undefined and therefore the terms cannot be equated.`);\n        } else if (rightType === null) {\n          const type = leftType,  ///\n                termNode = rightTermNode, ///\n                variable = addVariable(type, termNode, proofContext);\n\n          if (variable !== null) {\n            const leftTypeName = leftType.getName();\n\n            proofContext.info(`The '${rightTermString}' variable has been given the '${leftTypeName}' type.`);\n\n            statementVerifiedAsEquality = true;\n          }\n        } else if (leftType === null) {\n          const type = rightType,  ///\n                termNode = leftType, ///\n                variable = addVariable(type, termNode, proofContext);\n\n          if (variable !== null) {\n            const rightTypeName = rightType.getName();\n\n            proofContext.info(`The '${rightTermString}' variable has been given the '${rightTypeName}' type.`);\n\n            statementVerifiedAsEquality = true;\n          }\n        } else {\n          const leftTypeMatchesRightType = leftType.match(rightType);\n\n          if (!leftTypeMatchesRightType) {\n            proofContext.error(`The types of the '${leftTermString}' and '${rightTermString}' terms do not match and therefore the terms cannot be equated.`);\n          } else {\n            const derived = proofContext.isDerived();\n\n            if (!derived) {\n              statementVerifiedAsEquality = true;\n            } else {\n              const equality = Equality.fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode),\n                    proofSteps = proofContext.getProofSteps(),\n                    equalities = equalitiesFromProofSteps(proofSteps),\n                    equalityEquates = equality.equate(equalities, proofContext);\n\n              statementVerifiedAsEquality = equalityEquates;  ///\n            }\n          }\n        }\n      }\n    }\n  }\n\n  if (statementVerifiedAsEquality) {\n    proofContext.info(`Verified the '${statementString}' equality.`);\n  }\n\n  statementVerifiedAsEquality ?\n    proofContext.complete(statementNode) :\n      proofContext.halt(statementNode);\n\n  return statementVerifiedAsEquality;\n}\n\nfunction equalitiesFromProofSteps(proofSteps) {\n  const start = -MAXIMUM_INDEXES_LENGTH;  ///\n\n  proofSteps = proofSteps.slice(start); ///\n\n  const equalities = proofSteps.reduce((equalities, proofStep, index) => {\n    const equality = Equality.fromProofStep(proofStep);\n\n    if (equality !== null) {\n      equalities.push(equality);\n    }\n\n    return equalities;\n  }, []);\n\n  return equalities;\n}\n\nfunction addVariable(type, termNode, proofContext) {\n  let variable = null;\n\n  const variables = [],\n        termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, proofContext);\n\n  if (termVerifiedAsVariable) {\n    const firstVariable = first(variables);\n\n    variable = firstVariable;  ///\n\n    const name = variable.getName();\n\n    variable = Variable.fromTypeAndName(type, name);  ///\n\n    proofContext.addVariable(variable);\n  }\n\n  return variable;\n}\n"],"names":["verifyStatementAsEquality","specialNodeQuery","nodeQuery","leftTermNodeQuery","rightTermNodeQuery","statementNode","proofContext","statementVerifiedAsEquality","begin","statementString","nodeAsString","debug","specialNode","terminalNode","terminalNodeContent","getContent","EQUALS_CHARACTER","types","context","leftTermNode","rightTermNode","leftTermVerified","verifyTerm","rightTermVerified","firstType","first","secondType","second","leftType","rightType","leftTermString","rightTermString","error","type","termNode","variable","addVariable","leftTypeName","getName","info","rightTypeName","leftTypeMatchesRightType","match","derived","isDerived","equality","Equality","fromLeftTermNodeAndRightTermNode","proofSteps","getProofSteps","equalities","equalitiesFromProofSteps","equalityEquates","equate","complete","halt","start","MAXIMUM_INDEXES_LENGTH","slice","reduce","proofStep","index","fromProofStep","push","variables","termVerifiedAsVariable","verifyTermAsVariable","firstVariable","name","Variable","fromTypeAndName"],"mappings":"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"}

package/lib/verify/statementTypeAssertion.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return verifyStatementTypeAssertion;
+    }
+});
+var _variable = /*#__PURE__*/ _interopRequireDefault(require("../variable"));
+var _array = require("../utilities/array");
+var _string = require("../utilities/string");
+var _query = require("../utilities/query");
+var _term = require("../verify/term");
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+var termNodeQuery = (0, _query.nodeQuery)("/typeAssertion/term"), typeNodeQuery = (0, _query.nodeQuery)("/typeAssertion/type"), typeAssertionNodeQuery = (0, _query.nodeQuery)("/statement/typeAssertion!");
+function verifyStatementTypeAssertion(statementNode, proofContext) {
+    var typeAssertionVerified = false;
+    proofContext.begin(statementNode);
+    var statementString = (0, _string.nodeAsString)(statementNode);
+    proofContext.debug("Verifying the '".concat(statementString, "' statement type assertion..."));
+    var typeAssertionNode = typeAssertionNodeQuery(statementNode);
+    if (typeAssertionNode !== null) {
+        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(statementString, "' statement type assertion."));
+    }
+    typeAssertionVerified ? proofContext.complete(statementNode) : proofContext.halt(statementNode);
+    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();
+    var assertedTypeEqualToOrSubTypeOfVariableType = variableType === null ? true : 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/statementTypeAssertion.js"],"sourcesContent":["\"use strict\";\n\nimport Variable from \"../variable\";\n\nimport { first } from \"../utilities/array\";\nimport { nodeAsString } from \"../utilities/string\";\nimport { nodeQuery, typeNameFromTypeNode } from \"../utilities/query\";\nimport { verifyTermAsVariable, verifyTermAgainstConstructors } from \"../verify/term\";\n\nconst termNodeQuery = nodeQuery(\"/typeAssertion/term\"),\n      typeNodeQuery = nodeQuery(\"/typeAssertion/type\"),\n      typeAssertionNodeQuery = nodeQuery(\"/statement/typeAssertion!\");\n\nexport default function verifyStatementTypeAssertion(statementNode, proofContext) {\n  let typeAssertionVerified = false;\n\n  proofContext.begin(statementNode);\n\n  const statementString = nodeAsString(statementNode);\n\n  proofContext.debug(`Verifying the '${statementString}' statement type assertion...`);\n\n  const typeAssertionNode = typeAssertionNodeQuery(statementNode);\n\n  if (typeAssertionNode !== null) {\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\n  if (typeAssertionVerified) {\n    proofContext.info(`Verified the '${statementString}' statement type assertion.`);\n  }\n\n  typeAssertionVerified ?\n    proofContext.complete(statementNode) :\n      proofContext.halt(statementNode);\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\n  const assertedTypeEqualToOrSubTypeOfVariableType = (variableType === null) ?\n                                                        true :  ///\n                                                          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":["verifyStatementTypeAssertion","termNodeQuery","nodeQuery","typeNodeQuery","typeAssertionNodeQuery","statementNode","proofContext","typeAssertionVerified","begin","statementString","nodeAsString","debug","typeAssertionNode","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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "0.0.479",
+  "version": "0.0.481",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",

package/src/conclusion.js

@@ -118,6 +118,8 @@ function matchConclusionNonTerminalNode(conclusionNonTerminalNode, nonTerminalNo
         childNodes = nonTerminalNode.getChildNodes(),
         conclusionNonTerminalNodeRuleName = conclusionNonTerminalNode.getRuleName(),
         conclusionNonTerminalNodeChildNodes = conclusionNonTerminalNode.getChildNodes(),
+        nodes = childNodes, ///
+        conclusionNodes = conclusionNonTerminalNodeChildNodes, ///
         ruleNameStatementRuleName = (ruleName === STATEMENT_RULE_NAME),
         conclusionNonTerminalNodeRuleNameMetastatementRuleName = (conclusionNonTerminalNodeRuleName === METASTATEMENT_RULE_NAME);
 
@@ -129,16 +131,12 @@ function matchConclusionNonTerminalNode(conclusionNonTerminalNode, nonTerminalNo
     if (conclusionMetastatementNodeMatches) {
       conclusionNonTerminalNodeMatches = true; ///
     } else {
-      const nodes = childNodes, ///
-            conclusionNodes = conclusionNonTerminalNodeChildNodes, ///
-            conclusionNonTerminalNodeChildNodesMatches = matchConclusionNodes(conclusionNodes, nodes, substitutions);
+      const conclusionNonTerminalNodeChildNodesMatches = matchConclusionNodes(conclusionNodes, nodes, substitutions);
 
       conclusionNonTerminalNodeMatches = conclusionNonTerminalNodeChildNodesMatches; ///
     }
   } else if (ruleName === conclusionNonTerminalNodeRuleName) {
-    const nodes = childNodes, ///
-          conclusionNodes = conclusionNonTerminalNodeChildNodes, ///
-          conclusionNonTerminalNodeChildNodesMatches = matchConclusionNodes(conclusionNodes, nodes, substitutions);
+    const conclusionNonTerminalNodeChildNodesMatches = matchConclusionNodes(conclusionNodes, nodes, substitutions);
 
     conclusionNonTerminalNodeMatches = conclusionNonTerminalNodeChildNodesMatches; ///
   }
@@ -146,7 +144,7 @@ function matchConclusionNonTerminalNode(conclusionNonTerminalNode, nonTerminalNo
   return conclusionNonTerminalNodeMatches;
 }
 
-function matchConclusionMetavariableNode(conclusionMetavariableNode, nodes, substitutions) {
+function matchConclusionMetavariableNode(conclusionMetavariableNode, statementNode, substitutions) {
   let conclusionMetavariableNodeMatches = true;
 
   const conclusionMetavariableName = metavariableNameFromMetavariableNode(conclusionMetavariableNode),
@@ -159,7 +157,7 @@ function matchConclusionMetavariableNode(conclusionMetavariableNode, nodes, subs
         }) || null;
 
   if (substitution !== null) {
-    const substitutionNodesMatch = substitution.matchNodes(nodes);
+    const substitutionNodesMatch = substitution.matchStatementNode(statementNode);
 
     conclusionMetavariableNodeMatches = substitutionNodesMatch;  ///
   }
@@ -186,10 +184,7 @@ function matchConclusionMetastatementNode(conclusionMetastatementNode, statement
 
       if (conclusionNonTerminalChildNodeRuleNameMetavariableRuleName) {
         const conclusionMetavariableNode = conclusionNonTerminalChildNode,  ///
-              nonTerminalNode = statementNode,  ///
-              childNodes = nonTerminalNode.getChildNodes(),
-              nodes = childNodes, ///
-              conclusionMetavariableNodeMatches = matchConclusionMetavariableNode(conclusionMetavariableNode, nodes, substitutions);
+              conclusionMetavariableNodeMatches = matchConclusionMetavariableNode(conclusionMetavariableNode, statementNode, substitutions);
 
         conclusionMetastatementNodeMatches = conclusionMetavariableNodeMatches; ///
       }
@@ -255,47 +250,49 @@ function metaMatchConclusionNonTerminalNode(conclusionNonTerminalNode, nonTermin
   let conclusionNonTerminalNodeMatches = false;
 
   const ruleName = nonTerminalNode.getRuleName(),
-        conclusionNonTerminalNodeRuleName = conclusionNonTerminalNode.getRuleName();
-
-  if (ruleName === conclusionNonTerminalNodeRuleName) {
-    const childNodes = nonTerminalNode.getChildNodes(),
-          conclusionNonTerminalNodeChildNodes = conclusionNonTerminalNode.getChildNodes(),
-          nodes = childNodes, ///
-          conclusionNodes = conclusionNonTerminalNodeChildNodes, ///
-          conclusionNonTerminalNodeChildNodesMatches = metaMatchConclusionNodes(conclusionNodes, nodes, metaSubstitutions);
-
-    conclusionNonTerminalNodeMatches = conclusionNonTerminalNodeChildNodesMatches; ///
+        childNodes = nonTerminalNode.getChildNodes(),
+        conclusionNonTerminalNodeRuleName = conclusionNonTerminalNode.getRuleName(),
+        conclusionNonTerminalNodeChildNodes = conclusionNonTerminalNode.getChildNodes(),
+        nodes = childNodes, ///
+        conclusionNodes = conclusionNonTerminalNodeChildNodes, ///
+        ruleNameMetastatementRuleName = (ruleName === METASTATEMENT_RULE_NAME),
+        conclusionNonTerminalNodeRuleNameMetastatementRuleName = (conclusionNonTerminalNodeRuleName === METASTATEMENT_RULE_NAME);
 
-    if (!conclusionNonTerminalNodeMatches) {
-      const ruleNameMetastatementRuleName = (ruleName === METASTATEMENT_RULE_NAME);
+  if (ruleNameMetastatementRuleName && conclusionNonTerminalNodeRuleNameMetastatementRuleName) {
+    const statementNode = nonTerminalNode,  ///
+          conclusionMetastatementNode = conclusionNonTerminalNode,  ///
+          conclusionMetastatementNodeMatches = metaMatchConclusionMetastatementNode(conclusionMetastatementNode, statementNode, metaSubstitutions);
 
-      if (ruleNameMetastatementRuleName) {
-        const metastatementNode = nonTerminalNode,  ///
-              conclusionMetastatementNode = conclusionNonTerminalNode,  ///
-              conclusionMetastatementNodeMatches = metaMatchConclusionMetastatementNode(conclusionMetastatementNode, metastatementNode, metaSubstitutions);
+    if (conclusionMetastatementNodeMatches) {
+      conclusionNonTerminalNodeMatches = true; ///
+    } else {
+      const conclusionNonTerminalNodeChildNodesMatches = metaMatchConclusionNodes(conclusionNodes, nodes, metaSubstitutions);
 
-        conclusionNonTerminalNodeMatches = conclusionMetastatementNodeMatches; ///
-      }
+      conclusionNonTerminalNodeMatches = conclusionNonTerminalNodeChildNodesMatches; ///
     }
+  } else if (ruleName === conclusionNonTerminalNodeRuleName) {
+    const conclusionNonTerminalNodeChildNodesMatches = metaMatchConclusionNodes(conclusionNodes, nodes, metaSubstitutions);
+
+    conclusionNonTerminalNodeMatches = conclusionNonTerminalNodeChildNodesMatches; ///
   }
 
   return conclusionNonTerminalNodeMatches;
 }
 
-function metaMatchConclusionMetavariableNode(conclusionMetavariableNode, nodes, metaSubstitutions) {
+function metaMatchConclusionMetavariableNode(conclusionMetavariableNode, metastatementNode, metaSubstitutions) {
   let conclusionMetavariableNodeMatches = true;
 
   const conclusionMetavariableName = metavariableNameFromMetavariableNode(conclusionMetavariableNode),
         metaSubstitution = metaSubstitutions.find((metaSubstitution) => {
-      const metavariableName = metaSubstitution.getMetavariableName();
+          const metavariableName = metaSubstitution.getMetavariableName();
 
-      if (metavariableName === conclusionMetavariableName) {
-        return true;
-      }
-    }) || null;
+          if (metavariableName === conclusionMetavariableName) {
+            return true;
+          }
+        }) || null;
 
   if (metaSubstitution !== null) {
-    const metaSubstitutionNodesMatch = metaSubstitution.matchNodes(nodes);
+    const metaSubstitutionNodesMatch = metaSubstitution.matchMetastatementNode(metastatementNode);
 
     conclusionMetavariableNodeMatches = metaSubstitutionNodesMatch;  ///
   }
@@ -322,10 +319,7 @@ function metaMatchConclusionMetastatementNode(conclusionMetastatementNode, metas
 
       if (conclusionNonTerminalChildNodeRuleNameMetavariableRuleName) {
         const conclusionMetavariableNode = conclusionNonTerminalChildNode,  ///
-              nonTerminalNode = metastatementNode,  ///
-              childNodes = nonTerminalNode.getChildNodes(),
-              nodes = childNodes, ///
-              conclusionMetavariableNodeMatches = metaMatchConclusionMetavariableNode(conclusionMetavariableNode, nodes, metaSubstitutions);
+              conclusionMetavariableNodeMatches = metaMatchConclusionMetavariableNode(conclusionMetavariableNode, metastatementNode, metaSubstitutions);
 
         conclusionMetastatementNodeMatches = conclusionMetavariableNodeMatches; ///
       }

package/src/constants.js

@@ -7,6 +7,7 @@ export const BOOLEAN = "boolean";
 export const EMPTY_STRING = "";
 export const LEFT_BRACKET = "(";
 export const RIGHT_BRACKET = ")";
+export const EQUALS_CHARACTER = "=";
 export const MAXIMUM_INDEXES_LENGTH = 10;
 export const MAXIMUM_PERMUTATION_LENGTH = 5;
 export const BRACKETED_CHILD_NODES_LENGTH = 3;

package/src/equality.js

@@ -2,10 +2,11 @@
 
 import { nodeQuery } from "./utilities/query";
 import { TERM_RULE_NAME } from "./ruleNames";
+import { EQUALS_CHARACTER } from "./constants";
 
-const equalityNodeQuery = nodeQuery("/statement/equality!"),
-      leftTermNodeQuery = nodeQuery("/equality/term[0]"),
-      rightTermNodeQuery = nodeQuery("/equality/term[1]");
+const specialNodeQuery = nodeQuery("/statement/@special!"),
+      leftTermNodeQuery = nodeQuery("/statement/term[0]"),
+      rightTermNodeQuery = nodeQuery("/statement/term[1]");
 
 export default class Equality {
   constructor(leftTermNode, rightTermNode) {
@@ -85,23 +86,20 @@ export default class Equality {
     const statementNode = proofStep.getStatementNode();
 
     if (statementNode !== null) {
-      const equalityNode = equalityNodeQuery(statementNode);
+      const specialNode = specialNodeQuery(statementNode);
 
-      if (equalityNode !== null) {
-        const leftTermNode = leftTermNodeQuery(equalityNode),
-              rightTermNode = rightTermNodeQuery(equalityNode);
+      if (specialNode !== null) {
+        const terminalNode = specialNode, ///
+              terminalNodeContent = terminalNode.getContent();
 
-        equality = new Equality(leftTermNode, rightTermNode);
-      }
-    }
+        if (terminalNodeContent === EQUALS_CHARACTER) {
+          const leftTermNode = leftTermNodeQuery(statementNode),
+                rightTermNode = rightTermNodeQuery(statementNode);
 
-    return equality;
-  }
-
-  static fromEqualityNode(equalityNode) {
-    const leftTermNode = leftTermNodeQuery(equalityNode),
-          rightTermNode = rightTermNodeQuery(equalityNode),
           equality = new Equality(leftTermNode, rightTermNode);
+        }
+      }
+    }
 
     return equality;
   }

package/src/metaSubstitution.js

@@ -1,58 +1,62 @@
 "use strict";
 
-import { matchNodes, bracketedChildNodeFromChildNodes } from "./utilities/node";
+import { METASTATEMENT_RULE_NAME } from "./ruleNames";
+import { matchNode, bracketedNonTerminalChildNodeFromChildNodes } from "./utilities/node";
 
 export default class MetaSubstitution {
-  constructor(metavariableName, nodes) {
+  constructor(metavariableName, metastatementNode) {
     this.metavariableName = metavariableName;
-    this.nodes = nodes;
+    this.metastatementNode = metastatementNode;
   }
 
   getMetavariableName() {
     return this.metavariableName;
   }
 
-  getNodes() {
-    return this.nodes;
+  getMetastatementNode() {
+    return this.metastatementNode;
   }
 
-  matchNodes(nodes) {
-    let matches;
+  matchMetastatementNode(metastatementNode) {
+    let matchesMetastatementNode;
 
-    const nodesA = this.nodes,  ///
-          nodesB = nodes,
-          nodesMatch = matchNodes(nodesA, nodesB);
+    const nodeA = this.metastatementNode,  ///
+          nodeB = metastatementNode,
+          nodeMatches = matchNode(nodeA, nodeB);
 
-    matches = nodesMatch;  ///
+    matchesMetastatementNode = nodeMatches;  ///
 
-    if (!matches) {
-      const childNodes = nodes, ///
-            bracketedChildNode = bracketedChildNodeFromChildNodes(childNodes);
+    if (!matchesMetastatementNode) {
+      const nonTerminalNode = metastatementNode,  ///
+            childNodes = nonTerminalNode.getChildNodes(), ///
+            ruleName = METASTATEMENT_RULE_NAME;
 
-      if (bracketedChildNode !== null) {
-        const nonTerminalNode = bracketedChildNode,  ///
-              childNodes = nonTerminalNode.getChildNodes(),
-              nodesB = childNodes, ///
-              nodesMatch = matchNodes(nodesA, nodesB);
+      metastatementNode = bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName);  ///
 
-        matches = nodesMatch; ///
+      if (metastatementNode !== null) {
+        const nodeA = this.metastatementNode,  ///
+              nodeB = metastatementNode,
+              nodeMatches = matchNode(nodeA, nodeB);
+
+        matchesMetastatementNode = nodeMatches;  ///
       }
     }
 
-    return matches;
+    return matchesMetastatementNode;
   }
 
-  static fromMetavariableNameAndNodes(metavariableName, nodes) {
-    const bracketedChildNode = bracketedChildNodeFromChildNodes(nodes);
+  static fromMetavariableNameAndMetastatementNode(metavariableName, metastatementNode) {
+    let metaSubstitution = new MetaSubstitution(metavariableName, metastatementNode);
 
-    if (bracketedChildNode !== null) {
-      const nonTerminalNode = bracketedChildNode,  ///
-            childNodes = nonTerminalNode.getChildNodes();
+    const nonTerminalNode = metastatementNode,  ///
+          childNodes = nonTerminalNode.getChildNodes(),
+          ruleName = METASTATEMENT_RULE_NAME;
 
-      nodes = childNodes; ///
-    }
+    metastatementNode = bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName);  ///
 
-    const metaSubstitution = new MetaSubstitution(metavariableName, nodes);
+    if (metastatementNode !== null) {
+      metaSubstitution = new MetaSubstitution(metavariableName, metastatementNode);
+    }
 
     return metaSubstitution;
   }