occam-verify-cli 0.0.835 → 0.0.837

package/src/mixins/nodesVerifier/intrinsiclevel.js

@@ -0,0 +1,73 @@
+"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, ///
+          termNodeMatches = substitution.matchTermNode(termNode);
+
+    if (termNodeMatches) {
+      const verifiedAhead = verifyAhead();
+
+      variableNodeVerified = verifiedAhead;  ///
+    }
+  } else {
+    const variableNode = variableNodeA, ///
+          localContext = localContextA, ///
+          variable = localContext.findVariableByVariableNode(variableNode);
+
+    if (variable !== null) {
+      const terms = [],
+            context = localContextB, ///
+            termNode = termNodeB, ///
+            termVerified = verifyTerm(termNode, terms, context, () => {
+              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

@@ -0,0 +1,39 @@
+"use strict";
+
+import MetastatementForMetavariableSubstitution from "../../substitution/metastatementForMetavariable";
+
+function verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead) {
+  let metavariableNodeVerified;
+
+  const substitution = substitutions.find((substitution) => {
+    const substitutionMatchesMetavariableNodeA = substitution.matchMetavariableNode(metavariableNodeA);
+
+    if (substitutionMatchesMetavariableNodeA) {
+      return true;
+    }
+  }) || null;
+
+  if (substitution !== null) {
+    const metastatementNode = metastatementNodeB, ///
+          metastatementNodeMatches = substitution.matchMetastatementNode(metastatementNode);
+
+    metavariableNodeVerified = metastatementNodeMatches;  ///
+  } else {
+    const metavariableNode = metavariableNodeA, ///
+          metastatementNode = metastatementNodeB, ///
+          metastatementForMetavariableSubstitution = MetastatementForMetavariableSubstitution.fromMetavariableNodeAndMetastatementNode(metavariableNode, metastatementNode),
+          substitution = metastatementForMetavariableSubstitution;  ///
+
+    substitutions.push(substitution);
+
+    metavariableNodeVerified = true;
+  }
+
+  return metavariableNodeVerified;
+}
+
+const metaLevelNodesVerifierMixins = {
+  verifyMetavariableNode
+};
+
+export default metaLevelNodesVerifierMixins;

package/src/substitution/metastatementForMetavariable.js

@@ -1,9 +1,13 @@
 "use strict";
 
+import Substitution from "../substitution";
+
 import { bracketedMetastatementChildNodeFromMetastatementNode } from "../utilities/metaproof";
 
-export default class MetastatementForMetavariableSubstitution {
+export default class MetastatementForMetavariableSubstitution extends Substitution {
   constructor(metavariableNode, metastatementNode) {
+    super();
+
     this.metavariableNode = metavariableNode;
     this.metastatementNode = metastatementNode;
   }

package/src/substitution/statementForMetavariable.js

@@ -1,9 +1,13 @@
 "use strict";
 
+import Substitution from "../substitution";
+
 import { bracketedStatementChildNodeFromStatementNode } from "../utilities/proof";
 
-export default class StatementForMetavariableSubstitution {
+export default class StatementForMetavariableSubstitution extends Substitution {
   constructor(metavariableNode, statementNode) {
+    super();
+
     this.metavariableNode = metavariableNode;
     this.statementNode = statementNode;
   }

package/src/substitution/termForVariable.js

@@ -1,7 +1,11 @@
 "use strict";
 
-export default class TermForVariableSubstitution {
+import Substitution from "../substitution";
+
+export default class TermForVariableSubstitution extends Substitution {
   constructor(variableNode, termNode) {
+    super();
+
     this.variableNode = variableNode;
     this.termNode = termNode;
   }

package/src/substitution.js

@@ -0,0 +1,33 @@
+"use strict";
+
+export default class Substitution {
+  matchTermNode(termNode) {
+    const termNodeMatches = false;
+
+    return termNodeMatches;
+  }
+
+  matchVariableNode(variableNode) {
+    const variableNodeMatches = false;
+
+    return variableNodeMatches;
+  }
+
+  matchStatementNode(statementNode) {
+    const statementNodeMatches = false;
+
+    return statementNodeMatches;
+  }
+
+  matchMetavariableNode(metavariableNode) {
+    const metavariableNodeMatches = false;
+
+    return metavariableNodeMatches;
+  }
+
+  matchMetastatementNode(metastatementNode) {
+    const metastatementNodeMatches = false;
+
+    return metastatementNodeMatches;
+  }
+}

package/src/utilities/metaproof.js

@@ -5,7 +5,7 @@ import bracketedMetastatementNode from "../node/metastatement/bracketed";
 import { nodeQuery } from "../utilities/query";
 import { BRACKETED_METASTATEMENT_DEPTH } from "../constants";
 
-const bracketedMetastatementChildNodeQuery = nodeQuery('/metastatement/metastatement!');
+const bracketedMetastatementChildNodeQuery = nodeQuery("/metastatement/metastatement!");
 
 export function matchMetastatementModuloBrackets(metastatementNodeA, metastatementNodeB) {
   let metastatementMatchesModuloBrackets = false;

package/src/utilities/proof.js

@@ -5,7 +5,7 @@ import bracketedStatementNode from "../node/statement/bracketed";
 import { nodeQuery } from "../utilities/query";
 import { BRACKETED_STATEMENT_DEPTH } from "../constants";
 
-const bracketedStatementChildNodeQuery = nodeQuery('/statement/metaArgument!/statement!');
+const bracketedStatementChildNodeQuery = nodeQuery("/statement/metaArgument!/statement!");
 
 export function matchStatementModuloBrackets(statementNodeA, statementNodeB) {
   let statementMatchesModuloBrackets = false;

package/src/verifier/node/statementAsCombinator.js

@@ -14,12 +14,12 @@ class StatementAsCombinatorNodeVerifier extends NodeVerifier {
     const ruleName = nonTerminalNode.getRuleName();
 
     switch (ruleName) {
-      case TYPE_RULE_NAME: {
-        const typeNode = nonTerminalNode, ///
-              standaloneTypeVerified = verifyStandaloneType(typeNode, fileContext, verifyAhead),
-              typeNodeVerified = standaloneTypeVerified;  ///
+      case STATEMENT_RULE_NAME: {
+        const statementNode = nonTerminalNode, ///
+              standaloneStatementVerified = verifyStandaloneStatement(statementNode, fileContext, verifyAhead),
+              statementNodeVerified = standaloneStatementVerified; ///
 
-        nonTerminalNodeVerified = typeNodeVerified; ///
+        nonTerminalNodeVerified = statementNodeVerified; ///
 
         break;
       }
@@ -34,12 +34,12 @@ class StatementAsCombinatorNodeVerifier extends NodeVerifier {
         break;
       }
 
-      case STATEMENT_RULE_NAME: {
-        const statementNode = nonTerminalNode, ///
-              standaloneStatementVerified = verifyStandaloneStatement(statementNode, fileContext, verifyAhead),
-              statementNodeVerified = standaloneStatementVerified; ///
+      case TYPE_RULE_NAME: {
+        const typeNode = nonTerminalNode, ///
+              standaloneTypeVerified = verifyStandaloneType(typeNode, fileContext, verifyAhead),
+              typeNodeVerified = standaloneTypeVerified;  ///
 
-        nonTerminalNodeVerified = statementNodeVerified; ///
+        nonTerminalNodeVerified = typeNodeVerified; ///
 
         break;
       }
@@ -58,4 +58,3 @@ class StatementAsCombinatorNodeVerifier extends NodeVerifier {
 const statementAsCombinatorNodeVerifier = new StatementAsCombinatorNodeVerifier();
 
 export default statementAsCombinatorNodeVerifier;
-

package/src/verifier/node/termAsConstructor.js

@@ -17,16 +17,6 @@ class TermAsConstructorNodeVerifier extends NodeVerifier {
     const ruleName = nonTerminalNode.getRuleName();
 
     switch (ruleName) {
-      case TERM_RULE_NAME: {
-        const termNode = nonTerminalNode, ///
-              standaloneTermVerified = verifyStandaloneTerm(termNode, fileContext, verifyAhead),
-              termNodeVerified = standaloneTermVerified;  ///
-
-        nonTerminalNodeVerified = termNodeVerified; ///
-
-        break;
-      }
-
       case ARGUMENT_RULE_NAME: {
         const argumentNode = nonTerminalNode, ///
               argumentVerified = verifyArgument(argumentNode, fileContext, verifyAhead),
@@ -37,6 +27,16 @@ class TermAsConstructorNodeVerifier extends NodeVerifier {
         break;
       }
 
+      case TERM_RULE_NAME: {
+        const termNode = nonTerminalNode, ///
+              standaloneTermVerified = verifyStandaloneTerm(termNode, fileContext, verifyAhead),
+              termNodeVerified = standaloneTermVerified;  ///
+
+        nonTerminalNodeVerified = termNodeVerified; ///
+
+        break;
+      }
+
       default: {
         nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNode, fileContext, verifyAhead);
 
@@ -52,7 +52,7 @@ const termAsConstructorNodeVerifier = new TermAsConstructorNodeVerifier();
 
 export default termAsConstructorNodeVerifier;
 
-export function verifyArgument(argumentNode, fileContext, verifyAhead) {
+function verifyArgument(argumentNode, fileContext, verifyAhead) {
   let argumentVerified;
 
   const argumentString = fileContext.nodeAsString(argumentNode);

package/src/verifier/nodes/equality.js

@@ -15,17 +15,11 @@ class EqualityNodesVerifier extends NodesVerifier {
     if (ruleNameA === ruleNameB) {
       switch (ruleNameA) {
         case TERM_RULE_NAME: {
-          const leftTermNode = nonTerminalNodeA, ///
-                rightTermNode = nonTerminalNodeB, ///
-                termNodesEqual = areTermNodesEqual(leftTermNode, rightTermNode, collections);
+          const termNodeA = nonTerminalNodeA, ///
+                termNodeB = nonTerminalNodeB, ///
+                termNodeVerified = this.verifyTermNode(termNodeA, termNodeB, collections, localContext, verifyAhead);
 
-          if (termNodesEqual) {
-            const verifiedAhead = verifyAhead();
-
-            nonTerminalNodeVerified = verifiedAhead;  ///
-          } else {
-            nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, collections, localContext, verifyAhead);
-          }
+          nonTerminalNodeVerified = termNodeVerified;  ///
 
           break;
         }
@@ -40,6 +34,27 @@ class EqualityNodesVerifier extends NodesVerifier {
 
     return nonTerminalNodeVerified;
   }
+
+  verifyTermNode(termNodeA, termNodeB, collections, localContext, verifyAhead) {
+    let termNodeVerified;
+
+    const leftTermNode = termNodeA, ///
+          rightTermNode = termNodeB, ///
+          termNodesEqual = areTermNodesEqual(leftTermNode, rightTermNode, collections);
+
+    if (termNodesEqual) {
+      const verifiedAhead = verifyAhead();
+
+      termNodeVerified = verifiedAhead;  ///
+    } else {
+      const nonTerminalNodeA = termNodeA, ///
+            nonTerminalNodeB = termNodeB; ///
+
+      termNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, collections, localContext, verifyAhead);
+    }
+
+    return termNodeVerified;
+  }
 }
 
 const equalityNodesVerifier = new EqualityNodesVerifier();

package/src/verifier/nodes/intrinsicLevel.js

@@ -1,14 +1,12 @@
 "use strict";
 
-import verifyTerm from "../../verify/term";
 import NodesVerifier from "../../verifier/nodes";
-import TermForVariableSubstitution from "../../substitution/termForVariable";
+import intrinsicLevelNodesVerifierMixins from "../../mixins/nodesVerifier/intrinsiclevel";
 
-import { first } from "../../utilities/array";
 import { nodeQuery } from "../../utilities/query";
 import { TERM_RULE_NAME } from "../../ruleNames";
 
-const variableNodeQuery = nodeQuery('/term/variable!');
+const variableNodeQuery = nodeQuery("/term/variable!");
 
 class IntrinsicLevelNodesVerifier extends NodesVerifier {
   verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead) {
@@ -26,11 +24,7 @@ class IntrinsicLevelNodesVerifier extends NodesVerifier {
                 termNodeB = nonTerminalNodeB,  ///
                 termNodeVerified = this.verifyTermNode(termNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
-          if (termNodeVerified) {
-            nonTerminalNodeVerified = true;  ///
-          } else {
-            nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
-          }
+          nonTerminalNodeVerified = termNodeVerified;  ///
 
           break;
         }
@@ -47,81 +41,28 @@ class IntrinsicLevelNodesVerifier extends NodesVerifier {
   }
 
   verifyTermNode(termNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {
-    let termNodeVerified = false;
+    let termNodeVerified;
 
     const variableNodeA = variableNodeQuery(termNodeA);
 
     if (variableNodeA !== null) {
-      const variableVerified = this.verifyVariableNode(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead);
-
-      termNodeVerified = variableVerified; ///
-    }
-
-    return termNodeVerified;
-  }
+      const variableNodeVerified = this.verifyVariableNode(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
-  verifyVariableNode(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {
-    let variableVerified = false;
-
-    const substitution = substitutions.find((substitution) => {
-            const substitutionMatchesVariableNodeA = substitution.matchVariableNode(variableNodeA);
-
-            if (substitutionMatchesVariableNodeA) {
-              return true;
-            }
-          }) || null;
-
-    if (substitution !== null) {
-      const termNode = termNodeB, ///
-            substitutionNodesVerified = substitution.matchTermNode(termNode);
-
-      if (substitutionNodesVerified) {
-        const verifiedAhead = verifyAhead();
-
-        variableVerified = verifiedAhead;  ///
-      }
+      termNodeVerified = variableNodeVerified; ///
     } else {
-      const variableNode = variableNodeA, ///
-            localContext = localContextA, ///
-            variable = localContext.findVariableByVariableNode(variableNode);
-
-      if (variable !== null) {
-        const terms = [],
-              context = localContextB, ///
-              termNode = termNodeB, ///
-              termVerified = verifyTerm(termNode, terms, context, () => {
-                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;
-              });
+      const nonTerminalNodeA = termNodeA, ///
+            nonTerminalNodeB = termNodeB, ///
+            nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
-        variableVerified = termVerified;  ///
-      }
+      termNodeVerified = nonTerminalNodeVerified; ///
     }
 
-    return variableVerified;
+    return termNodeVerified;
   }
 }
 
+Object.assign(IntrinsicLevelNodesVerifier.prototype, intrinsicLevelNodesVerifierMixins);
+
 const intrinsicLevelNodesVerifier = new IntrinsicLevelNodesVerifier();
 
 export default intrinsicLevelNodesVerifier;

package/src/verifier/nodes/metaLevel.js

@@ -1,12 +1,12 @@
 "use strict";
 
 import NodesVerifier from "../../verifier/nodes";
-import MetastatementForMetavariableSubstitution from "../../substitution/metastatementForMetavariable";
+import metaLevelNodesVerifierMixins from "../../mixins/nodesVerifier/metaLevel";
 
 import { nodeQuery } from "../../utilities/query";
 import { METASTATEMENT_RULE_NAME } from "../../ruleNames";
 
-const metavariableNodeQuery = nodeQuery('/metastatement/metavariable!');
+const metavariableNodeQuery = nodeQuery("/metastatement/metavariable!");
 
 class MetaLevelNodesVerifier extends NodesVerifier {
   verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead) {
@@ -24,11 +24,7 @@ class MetaLevelNodesVerifier extends NodesVerifier {
                 metastatementNodeB = nonTerminalNodeB,  ///
                 metastatementNodeVerified = this.verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead);
 
-          if (metastatementNodeVerified) {
-            nonTerminalNodeVerified = true;  ///
-          } else {
-            nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead);
-          }
+          nonTerminalNodeVerified = metastatementNodeVerified;  ///
 
           break;
         }
@@ -45,7 +41,7 @@ class MetaLevelNodesVerifier extends NodesVerifier {
   }
 
   verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead) {
-    let metastatementNodeVerified = false;
+    let metastatementNodeVerified;
 
     const metavariableNodeA = metavariableNodeQuery(metastatementNodeA);
 
@@ -53,42 +49,20 @@ class MetaLevelNodesVerifier extends NodesVerifier {
       const metaVariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead);
 
       metastatementNodeVerified = metaVariableNodeVerified; ///
-    }
-
-    return metastatementNodeVerified;
-  }
-
-  verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead) {
-    let metavariableNodeVerified;
-
-    const substitution = substitutions.find((substitution) => {
-            const substitutionMatchesMetavariableNodeA = substitution.matchMetavariableNode(metavariableNodeA);
-
-            if (substitutionMatchesMetavariableNodeA) {
-              return true;
-            }
-          }) || null;
-
-    if (substitution !== null) {
-      const metastatementNode = metastatementNodeB, ///
-            metastatementNodeMatches = substitution.matchMetastatementNode(metastatementNode);
-
-      metavariableNodeVerified = metastatementNodeMatches;  ///
     } else {
-      const metavariableNode = metavariableNodeA, ///
-            metastatementNode = metastatementNodeB, ///
-            metastatementForMetavariableSubstitution = MetastatementForMetavariableSubstitution.fromMetavariableNodeAndMetastatementNode(metavariableNode, metastatementNode),
-            substitution = metastatementForMetavariableSubstitution;  ///
-
-      substitutions.push(substitution);
+      const nonTerminalNodeA = metastatementNodeA,  ///
+            nonTerminalNodeB = metastatementNodeB, ///
+            nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead);
 
-      metavariableNodeVerified = true;
+      metastatementNodeVerified = nonTerminalNodeVerified;  ///
     }
 
-    return metavariableNodeVerified;
+    return metastatementNodeVerified;
   }
 }
 
+Object.assign(MetaLevelNodesVerifier.prototype, metaLevelNodesVerifierMixins);
+
 const metaLevelNodesVerifier = new MetaLevelNodesVerifier();
 
 export default metaLevelNodesVerifier;