occam-verify-cli 0.0.932 → 0.0.933

package/lib/verify/variableAgainstTerm.js

@@ -1,70 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return verifyVariableAgainstTerm;
-    }
-});
-var _term = /*#__PURE__*/ _interop_require_default(require("../verify/term"));
-var _termForVariable = /*#__PURE__*/ _interop_require_default(require("../substitution/termForVariable"));
-var _array = require("../utilities/array");
-var _query = require("../utilities/query");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-var variableNodeQuery = (0, _query.nodeQuery)("/term/variable");
-function verifyVariableAgainstTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {
-    var variableVerifiedAgainstTerm = false;
-    var substitution = substitutions.find(function(substitution) {
-        var substitutionMatchesVariableNodeA = substitution.matchVariableNode(variableNodeA);
-        if (substitutionMatchesVariableNodeA) {
-            return true;
-        }
-    }) || null;
-    if (substitution !== null) {
-        var substitutionMatchesTermNodeB = substitution.matchTermNode(termNodeB);
-        if (substitutionMatchesTermNodeB) {
-            var verifiedAhead = verifyAhead();
-            variableVerifiedAgainstTerm = verifiedAhead; ///
-        }
-    } else {
-        var variableA = localContextA.findVariableByVariableNode(variableNodeA);
-        if (variableA !== null) {
-            var terms = [], termVerified = (0, _term.default)(termNodeB, terms, localContextB, function() {
-                var verifiedAhead = false;
-                var firstTerm = (0, _array.first)(terms), termB = firstTerm, variableB = variableFromTerm(termB, localContextB);
-                if (variableA === variableB) {
-                    verifiedAhead = verifyAhead();
-                } else {
-                    var term = termB, variable = variableA, termType = term.getType(), variableType = variable.getType(), variableTypeEqualToOrSuperTypeOfTermType = variableType.isEqualToOrSuperTypeOf(termType);
-                    if (variableTypeEqualToOrSuperTypeOfTermType) {
-                        var termNode = termNodeB, variableNode = variableNodeA, termForVariableSubstitution = _termForVariable.default.fromVariableNodeAndTermNode(variableNode, termNode), substitution = termForVariableSubstitution; ///
-                        substitutions.push(substitution);
-                        verifiedAhead = verifyAhead();
-                        if (!verifiedAhead) {
-                            substitutions.pop();
-                        }
-                    }
-                }
-                return verifiedAhead;
-            });
-            variableVerifiedAgainstTerm = termVerified; ///
-        }
-    }
-    return variableVerifiedAgainstTerm;
-}
-function variableFromTerm(term, localContext) {
-    var variable = null;
-    var termNode = term.getNode(), variableNode = variableNodeQuery(termNode);
-    if (variableNode !== null) {
-        variable = localContext.findVariableByVariableNode(variableNode);
-    }
-    return variable;
-}
-
-//# sourceMappingURL=data:application/json;base64,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

package/src/mixins/context.js

@@ -1,96 +0,0 @@
-"use strict";
-
-function trace(node, message) { this.context.trace(node, message); }
-
-function debug(node, message) { this.context.debug(node, message); }
-
-function info(node, message) { this.context.info(node, message); }
-
-function warning(node, message) { this.context.warning(node, message); }
-
-function error(node, message) { this.context.error(node, message); }
-
-function fatal(node, message) { this.context.fatal(node, message); }
-
-function getAxioms() { return this.context.getAxioms(); }
-
-function getLemmas() { return this.context.getLemmas(); }
-
-function getTheorems() { return this.context.getTheorems(); }
-
-function getConjectures() { return this.context.getConjectures(); }
-
-function getCombinators() { return this.context.getCombinators(); }
-
-function getConstructors() { return this.context.getConstructors(); }
-
-function isTypePresentByTypeName(typeName) { return this.context.isTypePresentByTypeName(typeName); }
-
-function isTypePresentByTypeNode(typeNode) { return this.context.isTypePresentByTypeNode(typeNode); }
-
-function isMetavariablePresentByName(name) { return this.context.isMetavariablePresentByName(name); }
-
-function isLabelPresentByMetavariableNode(metavariableNode) { return this.context.isLabelPresentByMetavariableNode(metavariableNode); }
-
-function findTypeByTypeName(typeName) { return this.context.findTypeByTypeName(typeName); }
-
-function findTypeByTypeNode(typeNode) { return this.context.findTypeByTypeNode(typeNode); }
-
-function findMetavariableByName(name) { return this.context.findMetavariableByName(name); }
-
-function findLabelByMetavariableNode(metavariableNode) { return this.context.findLabelByMetavariableNode(metavariableNode); }
-
-function findMetaTypeByMetaTypeNode(metaTypeNode) { return this.context.findMetaTypeByMetaTypeNode(metaTypeNode); }
-
-function findRuleByMetavariableNode(metavariableNode) { return this.context.findRuleByMetavariableNode(metavariableNode); }
-
-function findAxiomByMetavariableNode(metavariableNode) { return this.context.findAxiomByMetavariableNode(metavariableNode); }
-
-function findLemmaByMetavariableNode(metavariableNode) { return this.context.findLemmaByMetavariableNode(metavariableNode); }
-
-function findTheoremByMetavariableNode(metavariableNode) { return this.context.findTheoremByMetavariableNode(metavariableNode); }
-
-function findMetaLemmaByMetavariableNode(metavariableNode) { return this.context.findMetaLemmaByMetavariableNode(metavariableNode); }
-
-function findConjectureByMetavariableNode(metavariableNode) { return this.context.findConjectureByMetavariableNode(metavariableNode); }
-
-function findMetatheoremByMetavariableNode(metavariableNode) { return this.context.findMetatheoremByMetavariableNode(metavariableNode); }
-
-function nodeAsString(node) { return this.context.nodeAsString(node); }
-
-function nodesAsString(node) { return this.context.nodesAsString(node); }
-
-const contextMixins = {
-  trace,
-  debug,
-  info,
-  warning,
-  error,
-  fatal,
-  getAxioms,
-  getLemmas,
-  getTheorems,
-  getConjectures,
-  getCombinators,
-  getConstructors,
-  isTypePresentByTypeName,
-  isTypePresentByTypeNode,
-  isMetavariablePresentByName,
-  isLabelPresentByMetavariableNode,
-  findTypeByTypeName,
-  findTypeByTypeNode,
-  findMetavariableByName,
-  findLabelByMetavariableNode,
-  findMetaTypeByMetaTypeNode,
-  findRuleByMetavariableNode,
-  findAxiomByMetavariableNode,
-  findLemmaByMetavariableNode,
-  findTheoremByMetavariableNode,
-  findMetaLemmaByMetavariableNode,
-  findConjectureByMetavariableNode,
-  findMetatheoremByMetavariableNode,
-  nodeAsString,
-  nodesAsString
-};
-
-export default contextMixins;

package/src/mixins/nodesVerifier/intrinsiclevel.js

@@ -1,73 +0,0 @@
-"use strict";
-
-import verifyTerm from "../../verify/term";
-import TermForVariableSubstitution from "../../substitution/termForVariable";
-
-import { first } from "../../utilities/array";
-
-function verifyVariableNode(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {
-  let variableNodeVerified = false;
-
-  const substitution = substitutions.find((substitution) => {
-    const substitutionMatchesVariableNodeA = substitution.matchVariableNode(variableNodeA);
-
-    if (substitutionMatchesVariableNodeA) {
-      return true;
-    }
-  }) || null;
-
-  if (substitution !== null) {
-    const termNode = termNodeB, ///
-          substitutionMatchesTermNode = substitution.matchTermNode(termNode);
-
-    if (substitutionMatchesTermNode) {
-      const verifiedAhead = verifyAhead();
-
-      variableNodeVerified = verifiedAhead;  ///
-    }
-  } else {
-    const variableNode = variableNodeA, ///
-          localContext = localContextA, ///
-          variable = localContext.findVariableByVariableNode(variableNode);
-
-    if (variable !== null) {
-      const terms = [],
-            termNode = termNodeB, ///
-            localContext = localContextB, ///
-            termVerified = verifyTerm(termNode, terms, localContext, () => {
-              let verifiedAhead = false;
-
-              const firstTerm = first(terms),
-                    term = firstTerm, ///
-                    termType = term.getType(),
-                    variableType = variable.getType(),
-                    variableTypeEqualToOrSuperTypeOfTermType = variableType.isEqualToOrSuperTypeOf(termType);
-
-              if (variableTypeEqualToOrSuperTypeOfTermType) {
-                const termForVariableSubstitution = TermForVariableSubstitution.fromVariableNodeAndTermNode(variableNode, termNode),
-                      substitution = termForVariableSubstitution;  ///
-
-                substitutions.push(substitution);
-
-                verifiedAhead = verifyAhead();
-
-                if (!verifiedAhead) {
-                  substitutions.pop();
-                }
-              }
-
-              return verifiedAhead;
-            });
-
-      variableNodeVerified = termVerified;  ///
-    }
-  }
-
-  return variableNodeVerified;
-}
-
-const intrinsicLevelNodesVerifierMixins = {
-  verifyVariableNode
-};
-
-export default intrinsicLevelNodesVerifierMixins;

package/src/mixins/nodesVerifier/metaLevel.js

@@ -1,39 +0,0 @@
-"use strict";
-
-import StatementForMetavariableSubstitution from "../../substitution/statementForMetavariable";
-
-function verifyMetavariableNode(metavariableNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead) {
-  let metavariableNodeVerified;
-
-  const substitution = substitutions.find((substitution) => {
-    const substitutionMatchesMetavariableNodeA = substitution.matchMetavariableNode(metavariableNodeA);
-
-    if (substitutionMatchesMetavariableNodeA) {
-      return true;
-    }
-  }) || null;
-
-  if (substitution !== null) {
-    const statementNode = statementNodeB, ///
-          substitutionStatementNode = substitution.matchStatementNode(statementNode);
-
-    metavariableNodeVerified = substitutionStatementNode;  ///
-  } else {
-    const metavariableNode = metavariableNodeA, ///
-          statementNode = statementNodeB, ///
-          statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromMetavariableNodeAndStatementNode(metavariableNode, statementNode),
-          substitution = statementForMetavariableSubstitution;  ///
-
-    substitutions.push(substitution);
-
-    metavariableNodeVerified = true;
-  }
-
-  return metavariableNodeVerified;
-}
-
-const metaLevelNodesVerifierMixins = {
-  verifyMetavariableNode
-};
-
-export default metaLevelNodesVerifierMixins;

package/src/utilities/verifier.js

@@ -1,38 +0,0 @@
-"use strict";
-
-export function verifyNode(nodeQueryMaps, nonTerminalNode, ...remainingArguments) {
-  let nodeVerified = false;
-
-  nodeVerified = nodeQueryMaps.some((nodeQueryMap) => {
-    const { nodeQuery, verifyNode } = nodeQueryMap;
-
-    const node = nodeQuery(nonTerminalNode);
-
-    if (node !== null) {
-      nodeVerified = verifyNode(node, ...remainingArguments);
-
-      return true;
-    }
-  });
-
-  return nodeVerified;
-}
-
-export function verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, ...remainingArguments) {
-  let nodesVerified = false;
-
-  nodeQueryMaps.some((nodeQueryMap) => {
-    const { nodeQueryA, nodeQueryB, verifyNodes } = nodeQueryMap;
-
-    const nodeA = nodeQueryA(nonTerminalNodeA),  ///
-          nodeB = nodeQueryB(nonTerminalNodeB);  ///
-
-    if ((nodeA !== null) && (nodeB !== null)) {
-      nodesVerified = verifyNodes(nodeA, nodeB, ...remainingArguments);
-
-      return true;
-    }
-  });
-
-  return nodesVerified;
-}

package/src/verifier/nodes/equality.js

@@ -1,84 +0,0 @@
-"use strict";
-
-import NodesVerifier from "../../verifier/nodes";
-import verifyTermAgainstTerm from "../../verify/termAgainstTerm";
-
-import { nodeQuery } from "../../utilities/query";
-import { verifyNodes } from "../../utilities/verifier";
-
-const termNodeQuery = nodeQuery("/term!"),
-      nonTerminalNodeQuery = nodeQuery("/*");
-
-class EqualityNodesVerifier extends NodesVerifier {
-  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead) {
-    let nonTerminalNodeVerified;
-
-    const nodeQueryMaps = [
-      {
-        nodeQueryA: termNodeQuery,
-        nodeQueryB: termNodeQuery,
-        verifyNodes: (nodeA, nodeB, localContext, verifyAhead) => {
-          let nonTerminalNodeVerified;
-
-          const termNodeA = nodeA,  ///
-                termNodeB = nodeB,  ///
-                termNodeVerifiedAgainstTermNode =
-
-                  this.verifyTermNodeAgainstTermNode(termNodeA, termNodeB, localContext, verifyAhead);
-
-          nonTerminalNodeVerified = termNodeVerifiedAgainstTermNode; ///
-
-          return nonTerminalNodeVerified;
-        }
-      },
-      {
-        nodeQueryA: nonTerminalNodeQuery,
-        nodeQueryB: nonTerminalNodeQuery,
-        verifyNodes: (nodeA, nodeB, localContext, verifyAhead) => {
-          let nonTerminalNodeVerified;
-
-          const nonTerminalNodeA = nodeA, ///
-                nonTerminalNodeB = nodeB; ///
-
-          nonTerminalNodeVerified =
-
-            super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
-
-          return nonTerminalNodeVerified;
-        }
-      }
-    ];
-
-    const nodesVerified = verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
-
-    nonTerminalNodeVerified = nodesVerified;  ///
-
-    return nonTerminalNodeVerified;
-  }
-
-  verifyTermNodeAgainstTermNode(termNodeA, termNodeB, localContext, verifyAhead) {
-    let termNodeVerifiedAgainstTermNode;
-
-    const termVerifiedAgainstTerm = verifyTermAgainstTerm(termNodeA, termNodeB, localContext, verifyAhead);
-
-    if (termVerifiedAgainstTerm) {
-      termNodeVerifiedAgainstTermNode = true;
-    } else {
-      const nonTerminalNodeA = termNodeA, ///
-            nonTerminalNodeB = termNodeB, ///
-            nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
-            nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
-            childNodesA = nonTerminalNodeAChildNodes, ///
-            childNodesB = nonTerminalNodeBChildNodes, ///
-            childNodesVerified = this.verifyChildNodes(childNodesA, childNodesB, localContext, verifyAhead);
-
-      termNodeVerifiedAgainstTermNode = childNodesVerified; ///
-    }
-
-    return termNodeVerifiedAgainstTermNode;
-  }
-}
-
-const equalityNodesVerifier = new EqualityNodesVerifier();
-
-export default equalityNodesVerifier;

package/src/verifier/nodes/metaLevel.js

@@ -1,109 +0,0 @@
-"use strict";
-
-import NodesVerifier from "../../verifier/nodes";
-import verifyVariableAgainstTerm from "../../verify/variableAgainstTerm";
-import verifyMetavariableAgainstStatement from "../../verify/metavariableAgainstStatement";
-
-import { nodeQuery } from "../../utilities/query";
-import { verifyNodes } from "../../utilities/verifier";
-
-const termNodeQuery = nodeQuery("/term!"),
-      statementNodeQuery = nodeQuery("/statement!"),
-      nonTerminalNodeQuery = nodeQuery("/*"),
-      termVariableNodeQuery = nodeQuery("/term/variable!"),
-      statementSubstitutionNodeQuery = nodeQuery("/statement/substitution!"),
-      statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!");
-
-class MetaLevelNodesVerifier extends NodesVerifier {
-  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead) {
-    let nonTerminalNodeVerified;
-
-    const nodeQueryMaps = [
-      {
-        nodeQueryA: statementMetavariableNodeQuery,
-        nodeQueryB: statementNodeQuery,
-        verifyNodes: (nodeA, nodeB, substitutions, localContextA, localContextB, verifyAhead) => {
-          let nonTerminalNodeVerified;
-
-          const statementNodeA = nonTerminalNodeA,  ///
-                statementNodeB = nodeB, ///
-                statementMetavariableNodeA = nodeA, ///
-                statementSubstitutionNodeA = statementSubstitutionNodeQuery(statementNodeA),
-                metavariableNodeVerifiedAgainstStatementNode =
-
-                  this.verifyStatementMetavariableNodeAgainstStatementNode(statementMetavariableNodeA, statementSubstitutionNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead);
-
-          nonTerminalNodeVerified = metavariableNodeVerifiedAgainstStatementNode;  ///
-
-          return nonTerminalNodeVerified;
-        }
-      },
-      {
-        nodeQueryA: termVariableNodeQuery,
-        nodeQueryB: termNodeQuery,
-        verifyNodes: (nodeA, nodeB, substitutions, localContextA, localContextB, verifyAhead) => {
-          let nonTerminalNodeVerified;
-
-          const termNodeB = nodeB,  ///
-                termVariableNodeA = nodeA,  ///
-                termVariableNodeVerifiedAgainstTermNode =
-
-                  this.verifyTermVariableNodeAgainstTermNode(termVariableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead);
-
-          nonTerminalNodeVerified = termVariableNodeVerifiedAgainstTermNode;  ///
-
-          return nonTerminalNodeVerified;
-        }
-      },
-      {
-        nodeQueryA: nonTerminalNodeQuery,
-        nodeQueryB: nonTerminalNodeQuery,
-        verifyNodes: (nodeA, nodeB, substitutions, localContextA, localContextB, verifyAhead) => {
-          let nonTerminalNodeVerified;
-
-          const nonTerminalNodeA = nodeA, ///
-                nonTerminalNodeB = nodeB; ///
-
-          nonTerminalNodeVerified =
-
-            super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
-
-          return nonTerminalNodeVerified;
-        }
-      }
-    ];
-
-    const nodesVerified = verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
-
-    nonTerminalNodeVerified = nodesVerified;  ///
-
-    return nonTerminalNodeVerified;
-  }
-
-  verifyStatementMetavariableNodeAgainstStatementNode(statementMetavariableNodeA, statementSubstitutionNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead) {
-    let metavariableNodeVerifiedAgainstStatementNode;
-
-    const substitutionNode = statementSubstitutionNodeA,  ///
-          metavariableNodeA = statementMetavariableNodeA, ///
-          metavariableVerifiedAgainstStatement = verifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNode, substitutions, localContextA, localContextB, verifyAhead);
-
-    metavariableNodeVerifiedAgainstStatementNode = metavariableVerifiedAgainstStatement;  ///
-
-    return metavariableNodeVerifiedAgainstStatementNode;
-  }
-
-  verifyTermVariableNodeAgainstTermNode(termVariableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {
-    let termVariableNodeVerifiedAgainstTermNode;
-
-    const variableNodeA = termVariableNodeA, ///
-          termVerifiedAgainstVariable = verifyVariableAgainstTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead);
-
-    termVariableNodeVerifiedAgainstTermNode = termVerifiedAgainstVariable;  ///
-
-    return termVariableNodeVerifiedAgainstTermNode;
-  }
-}
-
-const metaLevelNodesVerifier = new MetaLevelNodesVerifier();
-
-export default metaLevelNodesVerifier;

package/src/verifier/nodes/statementAgainstCombinator.js

@@ -1,105 +0,0 @@
-"use strict";
-
-import NodesVerifier from "../../verifier/nodes";
-import verifyArgumentAgainstArgument from "../../verify/argumentAgainstArgument";
-import verifyStatementAgainstMetaType from "../../verify/statementAgainstMetaType";
-
-import { nodeQuery } from "../../utilities/query";
-import { verifyNodes } from "../../utilities/verifier";
-
-const argumentNodeQuery = nodeQuery("/argument!"),
-      nonTerminalNodeQuery = nodeQuery("/*"),
-      metaArgumentMetaTypeNodeQuery = nodeQuery("/metaArgument/metaType!"),
-      metaArgumentStatementNodeQuery = nodeQuery("/metaArgument/statement!");
-
-class StatementAgainstCombinatorNodesVerifier extends NodesVerifier {
-  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead) {
-    let nonTerminalNodeVerified;
-
-    const nodeQueryMaps = [
-      {
-        nodeQueryA: metaArgumentStatementNodeQuery,
-        nodeQueryB: metaArgumentMetaTypeNodeQuery,
-        verifyNodes: (nodeA, nodeB, localContext, verifyAhead) => {
-          let nonTerminalNodeVerified;
-
-          const metaArgumentMetaTypeNodeB = nodeB,  ///
-                metaArgumentStatementNodeA = nodeA, ///
-                metaArgumentStatementVerifiedAgainstMetaArgumentMetaType =
-
-                  this.verifyMetaArgumentStatementAgainstMetaArgumentMetaType(metaArgumentStatementNodeA, metaArgumentMetaTypeNodeB, localContext, verifyAhead);
-
-          nonTerminalNodeVerified = metaArgumentStatementVerifiedAgainstMetaArgumentMetaType; ///
-
-          return nonTerminalNodeVerified;
-        }
-      },
-      {
-        nodeQueryA: argumentNodeQuery,
-        nodeQueryB: argumentNodeQuery,
-        verifyNodes: (nodeA, nodeB, localContext, verifyAhead) => {
-          let nonTerminalNodeVerified;
-
-          const argumentNodeA = nodeA,  ///
-                argumentNodeB = nodeB,  ///
-                argumentNodeVerifiedAgainstArgumentNode =
-
-                  this.verifyArgumentNodeAgainstArgumentNode(argumentNodeA, argumentNodeB, localContext, verifyAhead);
-
-          nonTerminalNodeVerified = argumentNodeVerifiedAgainstArgumentNode; ///
-
-          return nonTerminalNodeVerified;
-        }
-      },
-      {
-        nodeQueryA: nonTerminalNodeQuery,
-        nodeQueryB: nonTerminalNodeQuery,
-        verifyNodes: (nodeA, nodeB, localContext, verifyAhead) => {
-          let nonTerminalNodeVerified;
-
-          const nonTerminalNodeA = nodeA, ///
-                nonTerminalNodeB = nodeB; ///
-
-          nonTerminalNodeVerified =
-
-            super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
-
-          return nonTerminalNodeVerified;
-        }
-      }
-    ];
-
-    const nodesVerified = verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
-
-    nonTerminalNodeVerified = nodesVerified;  ///
-
-    return nonTerminalNodeVerified;
-  }
-
-  verifyMetaArgumentStatementAgainstMetaArgumentMetaType(metaArgumentStatementNodeA, metaArgumentMetaTypeNodeB, localContext, verifyAhead) {
-    let metaArgumentStatementVerifiedAgainstMetaArgumentMetaType;
-
-    const { verifyStatement } = this,
-          metaTypeNode = metaArgumentMetaTypeNodeB, ///
-          statementNode = metaArgumentStatementNodeA,  ///
-          statementVerifiedAgainstMetaType = verifyStatementAgainstMetaType(statementNode, metaTypeNode, localContext, verifyAhead, verifyStatement);
-
-    metaArgumentStatementVerifiedAgainstMetaArgumentMetaType = statementVerifiedAgainstMetaType; ///
-
-    return metaArgumentStatementVerifiedAgainstMetaArgumentMetaType;
-  }
-
-  verifyArgumentNodeAgainstArgumentNode(argumentNodeA, argumentNodeB, localContext, verifyAhead) {
-    let argumentNodeVerifiedAgainstArgumentNode;
-
-    const argumentVerifiedAgainstArgument = verifyArgumentAgainstArgument(argumentNodeA, argumentNodeB, localContext, verifyAhead);
-
-    argumentNodeVerifiedAgainstArgumentNode = argumentVerifiedAgainstArgument; ///
-
-    return argumentNodeVerifiedAgainstArgumentNode;
-  }
-}
-
-const statementAgainstCombinatorNodesVerifier = new StatementAgainstCombinatorNodesVerifier();
-
-export default statementAgainstCombinatorNodesVerifier;