occam-verify-cli 1.0.438 → 1.0.448

package/src/node/substitution/frame.js

@@ -5,13 +5,6 @@ import SubstitutionNode from "../../node/substitution";
 import { FRAME_RULE_NAME } from "../../ruleNames";
 
 export default class FrameSubstitutionNode extends SubstitutionNode {
-  getMetavariableNode() {
-    const lastMetavariableNode = this.getLastMetavariableNode(),
-          metavariableNode = lastMetavariableNode;  ///
-
-    return metavariableNode;
-  }
-
   getFrameNode() {
     const firstFrameNode = this.getFirstFrameNode(),
           frameNode = firstFrameNode; ///
@@ -19,18 +12,11 @@ export default class FrameSubstitutionNode extends SubstitutionNode {
     return frameNode;
   }
 
-  getLastFrameNode() {
-    const ruleName = FRAME_RULE_NAME,
-          lastFrameNode = this.getLastNodeByRuleName(ruleName);
-
-    return lastFrameNode;
-  }
-
-  getFirstFrameNode() {
-    const ruleName = FRAME_RULE_NAME,
-          firstFrameNode = this.getFirstNodeByRuleName(ruleName);
+  getMetavariableNode() {
+    const lastMetavariableNode = this.getLastMetavariableNode(),
+          metavariableNode = lastMetavariableNode;  ///
 
-    return firstFrameNode;
+    return metavariableNode;
   }
 
   getLastMetavariableNode() {
@@ -59,5 +45,19 @@ export default class FrameSubstitutionNode extends SubstitutionNode {
     return firstMetavariableNode;
   }
 
+  getLastFrameNode() {
+    const ruleName = FRAME_RULE_NAME,
+          lastFrameNode = this.getLastNodeByRuleName(ruleName);
+
+    return lastFrameNode;
+  }
+
+  getFirstFrameNode() {
+    const ruleName = FRAME_RULE_NAME,
+          firstFrameNode = this.getFirstNodeByRuleName(ruleName);
+
+    return firstFrameNode;
+  }
+
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return SubstitutionNode.fromRuleNameChildNodesOpacityAndPrecedence(FrameSubstitutionNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/substitution/statement.js

@@ -5,13 +5,6 @@ import SubstitutionNode from "../../node/substitution";
 import { STATEMENT_RULE_NAME } from "../../ruleNames";
 
 export default class StatementSubstitutionNode extends SubstitutionNode {
-  getMetavariableNode() {
-    const lastMetavariableNode = this.getLastVariableNode(),
-          metavariableNode = lastMetavariableNode;  ///
-
-    return metavariableNode;
-  }
-
   getStatementNode() {
     const firstStatementNode = this.getFirstStatementNode(),
           statementNode = firstStatementNode; ///
@@ -19,18 +12,11 @@ export default class StatementSubstitutionNode extends SubstitutionNode {
     return statementNode;
   }
 
-  getLastStatementNode() {
-    const ruleName = STATEMENT_RULE_NAME,
-          lastStatementNode = this.getLastNodeByRuleName(ruleName);
-
-    return lastStatementNode;
-  }
-
-  getFirstStatementNode() {
-    const ruleName = STATEMENT_RULE_NAME,
-          firstStatementNode = this.getFirstNodeByRuleName(ruleName);
+  getMetavariableNode() {
+    const lastMetavariableNode = this.getLastVariableNode(),
+          metavariableNode = lastMetavariableNode;  ///
 
-    return firstStatementNode;
+    return metavariableNode;
   }
 
   getLastMetavariableNode() {
@@ -59,5 +45,19 @@ export default class StatementSubstitutionNode extends SubstitutionNode {
     return firstMetavariableNode;
   }
 
+  getLastStatementNode() {
+    const ruleName = STATEMENT_RULE_NAME,
+          lastStatementNode = this.getLastNodeByRuleName(ruleName);
+
+    return lastStatementNode;
+  }
+
+  getFirstStatementNode() {
+    const ruleName = STATEMENT_RULE_NAME,
+          firstStatementNode = this.getFirstNodeByRuleName(ruleName);
+
+    return firstStatementNode;
+  }
+
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return SubstitutionNode.fromRuleNameChildNodesOpacityAndPrecedence(StatementSubstitutionNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/substitution/term.js

@@ -5,13 +5,6 @@ import SubstitutionNode from "../../node/substitution";
 import { TERM_RULE_NAME } from "../../ruleNames";
 
 export default class TermSubstitutionNode extends SubstitutionNode {
-  getVariableNode() {
-    const lastVariableNode = this.getLastVariableNode(),
-          variableNode = lastVariableNode;  ///
-
-    return variableNode;
-  }
-
   getTermNode() {
     const firstTermNode = this.getFirstTermNode(),
           termNode = firstTermNode; ///
@@ -19,18 +12,11 @@ export default class TermSubstitutionNode extends SubstitutionNode {
     return termNode;
   }
 
-  getLastTermNode() {
-    const ruleName = TERM_RULE_NAME,
-          lastTermNode = this.getLastNodeByRuleName(ruleName);
-
-    return lastTermNode;
-  }
-
-  getFirstTermNode() {
-    const ruleName = TERM_RULE_NAME,
-          firstTermNode = this.getFirstNodeByRuleName(ruleName);
+  getVariableNode() {
+    const lastVariableNode = this.getLastVariableNode(),
+          variableNode = lastVariableNode;  ///
 
-    return firstTermNode;
+    return variableNode;
   }
 
   getLastVariableNode() {
@@ -49,6 +35,20 @@ export default class TermSubstitutionNode extends SubstitutionNode {
     return firstVariableNode;
   }
 
+  getLastTermNode() {
+    const ruleName = TERM_RULE_NAME,
+          lastTermNode = this.getLastNodeByRuleName(ruleName);
+
+    return lastTermNode;
+  }
+
+  getFirstTermNode() {
+    const ruleName = TERM_RULE_NAME,
+          firstTermNode = this.getFirstNodeByRuleName(ruleName);
+
+    return firstTermNode;
+  }
+
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return SubstitutionNode.fromRuleNameChildNodesOpacityAndPrecedence(TermSubstitutionNode, ruleName, childNodes, opacity, precedence); }
 }
 

package/src/node/term.js

@@ -5,27 +5,6 @@ import NonTerminalNode from "../nonTerminalNode";
 import { ARGUMENT_RULE_NAME, VARIABLE_RULE_NAME } from "../ruleNames";
 
 export default class TermNode extends NonTerminalNode {
-  getVariableIdentifier() {
-    let variableIdentifier = null;
-
-    const singular = this.isSingular();
-
-    if (singular) {
-      const singularVariableNode = this.getSingularVariableNode();
-
-      variableIdentifier = singularVariableNode.getVariableIdentifier();
-    }
-
-    return variableIdentifier;
-  }
-
-  getVariableNode() {
-    const singularVariableNode = this.getSingularVariableNode(),
-          variableNode = singularVariableNode;  //
-
-    return variableNode;
-  }
-
   isSingular() {
     let singular = false;
 
@@ -38,11 +17,11 @@ export default class TermNode extends NonTerminalNode {
     return singular;
   }
 
-  getVariableNodes() {
-    const ruleName = VARIABLE_RULE_NAME,
-          variableNodes = this.getNodesByRuleName(ruleName);
+  getVariableNode() {
+    const singularVariableNode = this.getSingularVariableNode(),
+          variableNode = singularVariableNode;  //
 
-    return variableNodes;
+    return variableNode;
   }
 
   getSingularTermNode() {
@@ -57,18 +36,18 @@ export default class TermNode extends NonTerminalNode {
     return singularTermNode;
   }
 
-  getSingularArgumentNode() {
-    const ruleName = ARGUMENT_RULE_NAME,
-          singularArgumentNode = this.getSingularNodeByRuleName(ruleName);
+  getVariableIdentifier() {
+    let variableIdentifier = null;
 
-    return singularArgumentNode;
-  }
+    const singular = this.isSingular();
 
-  getSingularVariableNode() {
-    const ruleName = VARIABLE_RULE_NAME,
-          singularVariableNode = this.getSingularNodeByRuleName(ruleName);
+    if (singular) {
+      const singularVariableNode = this.getSingularVariableNode();
 
-    return singularVariableNode;
+      variableIdentifier = singularVariableNode.getVariableIdentifier();
+    }
+
+    return variableIdentifier;
   }
 
   getSingularVariableIdentifier() {
@@ -85,5 +64,26 @@ export default class TermNode extends NonTerminalNode {
     return singularVariableIdentifier;
   }
 
+  getVariableNodes() {
+    const ruleName = VARIABLE_RULE_NAME,
+          variableNodes = this.getNodesByRuleName(ruleName);
+
+    return variableNodes;
+  }
+
+  getSingularArgumentNode() {
+    const ruleName = ARGUMENT_RULE_NAME,
+          singularArgumentNode = this.getSingularNodeByRuleName(ruleName);
+
+    return singularArgumentNode;
+  }
+
+  getSingularVariableNode() {
+    const ruleName = VARIABLE_RULE_NAME,
+          singularVariableNode = this.getSingularNodeByRuleName(ruleName);
+
+    return singularVariableNode;
+  }
+
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(TermNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/preamble.js

@@ -31,6 +31,8 @@ import Conclusion from "./element/conclusion";
 import Derivation from "./element/derivation";
 import Hypothesis from "./element/hypothesis";
 import Assumption from "./element/assumption";
+import Combinator from "./element/combinator";
+import Constructor from "./element/constructor";
 import Supposition from "./element/supposition";
 import Metatheorem from "./element/metatheorem";
 import Equivalence from "./element/equivalence";
@@ -40,7 +42,6 @@ import Substitutions from "./element/substitutions";
 import ProcedureCall from "./element/procedureCall";
 import SubDerivation from "./element/subDerivation";
 import TypeAssertion from "./element/assertion/type";
-import ConstructorTerm from "./element/term/constructor";
 import PropertyRelation from "./element/propertyRelation";
 import DefinedAssertion from "./element/assertion/defined";
 import TermSubstitution from "./element/substitution/term";
@@ -51,7 +52,8 @@ import ProcedureReference from "./element/procedureReference";
 import ContainedAssertion from "./element/assertion/contained";
 import SatisfiesAssertion from "./element/assertion/satisfies";
 import VariableDeclaration from "./element/declaration/variable";
-import CombinatorStatement from "./element/statement/combinator";
+import BracketedCombinator from "./element/combinator/bracketed";
+import BracketedConstructor from "./element/constructor/bracketed";
 import SimpleTypeDeclaration from "./element/declaration/simpleType";
 import StatementSubstitution from "./element/substitution/statement";
 import ReferenceSubstitution from "./element/substitution/reference";
@@ -60,5 +62,3 @@ import TypePrefixDeclaration from "./element/declaration/typePrefix";
 import ConstructorDeclaration from "./element/declaration/constructor";
 import ComplexTypeDeclaration from "./element/declaration/complexType";
 import MetavariableDeclaration from "./element/declaration/metavariable";
-import BracketedConstructorTerm from "./element/term/constructor/bracketed";
-import BracketedCombinatorStatement from "./element/statement/combinator/bracketed";

package/src/process/instantiate.js

@@ -3,9 +3,12 @@
 import { ruleFromBNF } from "../utilities/bnf";
 
 const termPlaceholderBNF = ` _ ::= term... <END_OF_LINE> ; `,
+      stepPlaceholderBNF = ` _ ::= step... <END_OF_LINE> ; `,
       variablePlaceholderBNF = ` _ ::= variable... <END_OF_LINE> ; `,
       referencePlaceholderBNF = ` _ ::= reference... <END_OF_LINE> ; `,
       statementPlaceholderBNF = ` _ ::= statement... <END_OF_LINE> ; `,
+      combinatorPlaceholderBNF = ` _ ::= combinator... <END_OF_LINE> ; `,
+      constructorPlaceholderBNF = ` _ ::= constructor... <END_OF_LINE> ; `,
       equivalencePlaceholderBNF = ` _ ::= equivalence... <END_OF_LINE> ; `,
       metavariablePlaceholderBNF = ` _ ::= metavariable... <END_OF_LINE> ; `,
       termSubstitutionPlaceholderBNF = ` _ ::= termSubstitution... <END_OF_LINE> ; `,
@@ -13,9 +16,12 @@ const termPlaceholderBNF = ` _ ::= term... <END_OF_LINE> ; `,
       statementSubstitutionPlaceholderBNF = ` _ ::= statementSubstitution... <END_OF_LINE> ; `,
       referenceSubstitutionPlaceholderBNF = ` _ ::= referenceSubstitution... <END_OF_LINE> ; `,
       termPlaceholderRule = ruleFromBNF(termPlaceholderBNF),
+      stepPlaceholderRule = ruleFromBNF(stepPlaceholderBNF),
       variablePlaceholderRule = ruleFromBNF(variablePlaceholderBNF),
       referencePlaceholderRule = ruleFromBNF(referencePlaceholderBNF),
       statementPlaceholderRule = ruleFromBNF(statementPlaceholderBNF),
+      combinatorPlaceholderRule = ruleFromBNF(combinatorPlaceholderBNF),
+      constructorPlaceholderRule = ruleFromBNF(constructorPlaceholderBNF),
       equivalencePlaceholderRule = ruleFromBNF(equivalencePlaceholderBNF),
       metavariablePlaceholderRule = ruleFromBNF(metavariablePlaceholderBNF),
       termSubstitutionPlaceholderRule = ruleFromBNF(termSubstitutionPlaceholderBNF),
@@ -25,12 +31,18 @@ const termPlaceholderBNF = ` _ ::= term... <END_OF_LINE> ; `,
 
 export function instantiateTerm(string, context) { return instantiate(termPlaceholderRule, string, context); }
 
+export function instantiateStep(string, context) { return instantiate(stepPlaceholderRule, string, context); }
+
 export function instantiateVariable(string, context) { return instantiate(variablePlaceholderRule, string, context); }
 
 export function instantiateReference(string, context) { return instantiate(referencePlaceholderRule, string, context); }
 
 export function instantiateStatement(string, context) { return instantiate(statementPlaceholderRule, string, context); }
 
+export function instantiateCombinator(string, context) { return instantiate(combinatorPlaceholderRule, string, context); }
+
+export function instantiateConstructor(string, context) { return instantiate(constructorPlaceholderRule, string, context); }
+
 export function instantiateEquivalence(string, context) { return instantiate(equivalencePlaceholderRule, string, context); }
 
 export function instantiateMetavariable(string, context) { return instantiate(metavariablePlaceholderRule, string, context); }

package/src/process/unify.js

@@ -1,8 +1,7 @@
 "use strict";
 
-import elements from "../elements";
-
 import { nodeQuery } from "../utilities/query";
+import { termFromTermNode, frameFromFrameNode, statementFromStatementNode } from "../utilities/element";
 import { terminalNodeMapFromNodes, areTerminalNodeMapsEqual, isLastRemainingArgumentFunction } from "../utilities/pass";
 
 const nonTerminalNodeQuery = nodeQuery("/*");
@@ -29,7 +28,7 @@ class Pass {
   }
 
   descend(generalChildNodes, specificChildNodes, ...remainingArguments) {
-    let descendedAhead = false;
+    let descended = false;
 
     const generalChildNodesLength = generalChildNodes.length,
           specificChildNodesLength = specificChildNodes.length;
@@ -43,9 +42,12 @@ class Pass {
         const lastRemainingArgumentFunction = isLastRemainingArgumentFunction(remainingArguments);
 
         if (lastRemainingArgumentFunction) {
-          const index = 0;
+          const index = 0,
+                descendedAhead = this.descendAhead(index, generalChildNodes, specificChildNodes,...remainingArguments);
 
-          descendedAhead = this.descendAhead(index, generalChildNodes, specificChildNodes,...remainingArguments);
+          if (descendedAhead) {
+            descended = true;
+          }
         } else {
           const visited = generalChildNodes.every((generalChildNode, index) => {
             const specificChildNode = specificChildNodes[index],
@@ -59,13 +61,13 @@ class Pass {
           });
 
           if (visited) {
-            descendedAhead = true;
+            descended = true;
           }
         }
       }
     }
 
-    return descendedAhead;
+    return descended;
   }
 
   descendAhead(index, generalChildNodes, specificChildNodes, ...remainingArguments) {
@@ -346,11 +348,10 @@ class CombinatorPass extends Pass {
 
         context = specificContext;  ///
 
-        const { Statement } = elements,
-              statement = Statement.fromStatementNode(statementNode, context),
-              statementVerifiesGivenType = statement.verifyGivenMetaType(metaType, assignments, stated, context);
+        const statement = statementFromStatementNode(statementNode, context),
+              statementValidatesGivenType = statement.validateGivenMetaType(metaType, assignments, stated, context);
 
-        if (statementVerifiesGivenType) {
+        if (statementValidatesGivenType) {
           success = true;
         }
 
@@ -375,11 +376,10 @@ class CombinatorPass extends Pass {
 
         context = specificContext;  ///
 
-        const { Frame } = elements,
-              frame = Frame.fromFrameNode(frameNode, context),
-              frameVerifiesGivenType = frame.verifyGivenMetaType(metaType, assignments, stated, context);
+        const frame = frameFromFrameNode(frameNode, context),
+              frameValidatesGivenMetaType = frame.validateGivenMetaType(metaType, assignments, stated, context);
 
-        if (frameVerifiesGivenType) {
+        if (frameValidatesGivenMetaType) {
           success = true;
         }
 
@@ -405,11 +405,10 @@ class CombinatorPass extends Pass {
         if (type !== null) {
           context = specificContext;  ///
 
-          const { Term } = elements,
-                term = Term.fromTermNode(termNode, context),
-                termVerifiesGivenType = term.verifyGivenType(type, generalContext, specificContext);
+          const term = termFromTermNode(termNode, context),
+                termValidatesGivenType = term.validateGivenType(type, generalContext, specificContext);
 
-          if (termVerifiesGivenType) {
+          if (termValidatesGivenType) {
             success = true;
           }
         }
@@ -441,11 +440,10 @@ class ConstructorPass extends Pass {
         if (type !== null) {
           context = specificContext;  ///
 
-          const { Term } = elements,
-                term = Term.fromTermNode(termNode, context),
-                termVerifiesGivenType = term.verifyGivenType(type, generalContext, specificContext);
+          const term = termFromTermNode(termNode, context),
+                termValidatesGivenType = term.validateGivenType(type, generalContext, specificContext);
 
-          if (termVerifiesGivenType) {
+          if (termValidatesGivenType) {
             success = true;
           }
         }
@@ -470,9 +468,9 @@ class MetavariablePass extends Pass {
               type = generalContext.findTypeByNominalTypeName(nominalTypeName),
               context = specificContext, ///
               term = context.findTermByTermNode(termNode),
-              termVerifiesGivenType = term.verifyGivenType(type, generalContext, specificContext);
+              termValidatesGivenType = term.validateGivenType(type, generalContext, specificContext);
 
-        if (termVerifiesGivenType) {
+        if (termValidatesGivenType) {
           success = true;
         }
 
@@ -567,6 +565,21 @@ export function unifyMetavariable(generalMetavariable, specificMetavariable, gen
   return metavariableUnifies;
 }
 
+export function unifyTermWithConstructor(term, constructor, generalContext, specificContext) {
+  let termUnifiesWithConstructor = false;
+
+  const termNode = term.getNode(),
+        constructorTerm = constructor.getTerm(),
+        constructorTermNode = constructorTerm.getNode(),
+        success = constructorPass.run(constructorTermNode, termNode, generalContext, specificContext);
+
+  if (success) {
+    termUnifiesWithConstructor = true;
+  }
+
+  return termUnifiesWithConstructor;
+}
+
 export function unifyStatementIntrinsically(generalStatement, specificStatement, substitutions, generalContext, specificContext) {
   let statementUnifiesIntrinsically = false;
 
@@ -583,6 +596,21 @@ export function unifyStatementIntrinsically(generalStatement, specificStatement,
   return statementUnifiesIntrinsically;
 }
 
+export function unifyStatementWithCombinator(statement, combinator, assignments, stated, generalContext, specificContext) {
+  let statementUnifiesWithCombinator = false;
+
+  const statementNode = statement.getNode(),
+        combinatorStatement = combinator.getStatement(),
+        combinatorStatementNode = combinatorStatement.getNode(),
+        success = combinatorPass.run(combinatorStatementNode, statementNode, assignments, stated, generalContext, specificContext);
+
+  if (success) {
+    statementUnifiesWithCombinator = true;
+  }
+
+  return statementUnifiesWithCombinator;
+}
+
 export function unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, substitutions, generalContext, specificContext) {
   let metavariableUnifiesIntrinsically = false;
 
@@ -598,35 +626,3 @@ export function unifyMetavariableIntrinsically(generalMetavariable, specificMeta
 
   return metavariableUnifiesIntrinsically;
 }
-
-export function unifyTermWithConstructorTerm(term, constructorTerm, context) {
-  let termUnifiesWithConstructor = false;
-
-  const termNode = term.getNode(),
-        generalContext = context, ///
-        specificContext = context,  ///
-        constructorTermNode = constructorTerm.getNode(),
-        success = constructorPass.run(constructorTermNode, termNode, generalContext, specificContext);
-
-  if (success) {
-    termUnifiesWithConstructor = true;
-  }
-
-  return termUnifiesWithConstructor;
-}
-
-export function unifyStatementWithCombinatorStatement(statement, combinatorStatement, assignments, stated, context) {
-  let statementUnifiesWithCombinator = false;
-
-  const statementNode = statement.getNode(),
-        generalContext = context, ///
-        specificContext = context,  ///
-        combinatorStatementNode = combinatorStatement.getNode(),
-        success = combinatorPass.run(combinatorStatementNode, statementNode, assignments, stated, generalContext, specificContext);
-
-  if (success) {
-    statementUnifiesWithCombinator = true;
-  }
-
-  return statementUnifiesWithCombinator;
-}