occam-verify-cli 1.0.448 → 1.0.472

package/src/utilities/validation.js

@@ -2,9 +2,9 @@
 
 import elements from "../elements";
 
+import { bracketedConstructorFromNothing, bracketedCombinatorFromNothing } from "../utilities/instance";
 import { equalityFromStatement,
          judgementFromStatement,
-         metavariableFromStatement,
          typeAssertionFromStatement,
          definedAssertionFromStatement,
          propertyAssertionFromStatement,
@@ -12,15 +12,38 @@ import { equalityFromStatement,
          containedAssertionFromStatement,
          satisfiesAssertionFromStatement } from "../utilities/statement";
 
-function unifyTermWithBracketedConstructor(term, context, validateAhead) {
-  let termUnifiesWithBracketedConstructor;
+function validateTermAsVariable(term, context, validateAhead) {
+  let termValidatesAsVariable = false;
 
-  const { BracketedConstructor } = elements,
-    bracketedConstructor = BracketedConstructor.fromNothing();
+  const termNode = term.getNode(),
+        variableNode = termNode.getVariableNode();
 
-  termUnifiesWithBracketedConstructor = bracketedConstructor.unifyTerm(term, context, validateAhead);
+  if (variableNode !== null) {
+    const termString = term.getString();
 
-  return termUnifiesWithBracketedConstructor;
+    context.trace(`Validating the '${termString}' term as a variable...`);
+
+    const variableIdentifier = variableNode.getVariableIdentifier(),
+          variable = context.findVariableByVariableIdentifier(variableIdentifier);
+
+    if (variable !== null) {
+      const type = variable.getType();
+
+      term.setType(type);
+
+      const verifiesAhead = validateAhead();
+
+      if (verifiesAhead) {
+        termValidatesAsVariable = true;
+      }
+    }
+
+    if (termValidatesAsVariable) {
+      context.debug(`...validated the '${termString}' term as a variable.`);
+    }
+  }
+
+  return termValidatesAsVariable;
 }
 
 function unifyTermWithConstructors(term, context, validateAhead) {
@@ -39,62 +62,33 @@ function unifyTermWithConstructors(term, context, validateAhead) {
   return termUnifiesWithConstructors;
 }
 
-function validateTermAsVariable(term, context, validateAhead) {
-  let termValidatesAsVariable = false;
-
-  const { Variable } = elements,
-    termNode = term.getNode(),
-    singularVariableNode = termNode.getSingularVariableNode();
-
-  if (singularVariableNode !== null) {
-    let variable;
-
-    const termString = term.getString(),
-      variableNode = singularVariableNode;  ///
-
-    variable = Variable.fromVariableNode(variableNode, context);
-
-    context.trace(`Verifying the '${termString}' term as a variable...`);
-
-    const variableValidates = variable.validate(context);
-
-    if (variableValidates) {
-      let verifiesAhead;
-
-      const variableIdentifier = variable.getIdentifier();
-
-      variable = context.findVariableByVariableIdentifier(variableIdentifier);
-
-      const type = variable.getType();
-
-      term.setType(type);
-
-      verifiesAhead = validateAhead();
+function unifyTermWithBracketedConstructor(term, context, validateAhead) {
+  let termUnifiesWithBracketedConstructor;
 
-      termValidatesAsVariable = verifiesAhead; ///
-    }
+  const bracketedConstructor = bracketedConstructorFromNothing();
 
-    if (termValidatesAsVariable) {
-      context.debug(`...verified the '${termString}' term as a variable.`);
-    }
-  }
+  termUnifiesWithBracketedConstructor = bracketedConstructor.unifyTerm(term, context, validateAhead);
 
-  return termValidatesAsVariable;
+  return termUnifiesWithBracketedConstructor;
 }
 
-function validateStatementAsMetavariableAndSubstitution(statement, assignments, stated, context) {
+function validateStatementAsMetavariable(statement, assignments, stated, context) {
   let statementValidatesAsMetavariableAndSubstitution = false;
 
-  const metavariable = metavariableFromStatement(statement, context);
+  const statementNode = statement.getNode(),
+        metavariableNode = statementNode.getMetavariableNode();
 
-  if (metavariable !== null) {
+  if (metavariableNode !== null) {
     const statementString = statement.getString();
 
-    context.trace(`Validating the '${statementString}' statement as a metavariable and substitution...`);
+    context.trace(`Validating the '${statementString}' statement as a metavariable...`);
 
-    const metavariableValidates = metavariable.validate(context);
+    const metavariableName = metavariableNode.getMetavariableName(),
+          metavariable = context.findMetavariableByMetavariableName(metavariableName);
+
+    if (metavariable !== null) {
+      statementValidatesAsMetavariableAndSubstitution = true;
 
-    if (metavariableValidates) {
       const { TermSubstitution, FrameSubstitution } = elements,
             frameSubstitution = FrameSubstitution.fromStatement(statement, context),
             termSubstitution = TermSubstitution.fromStatement(statement, context),
@@ -103,49 +97,46 @@ function validateStatementAsMetavariableAndSubstitution(statement, assignments,
       if (substitution !== null) {
         const substitutionValidates = substitution.validate(context);
 
-        if (substitutionValidates) {
-          statementValidatesAsMetavariableAndSubstitution = true;
+        if (!substitutionValidates) {
+          statementValidatesAsMetavariableAndSubstitution = false;
         }
-      } else {
-        statementValidatesAsMetavariableAndSubstitution = true;
       }
     }
 
     if (statementValidatesAsMetavariableAndSubstitution) {
-      context.debug(`...validated the '${statementString}' statement as a metavariable and substitution.`);
+      context.debug(`...validated the '${statementString}' statement as a metavariable.`);
     }
   }
 
   return statementValidatesAsMetavariableAndSubstitution;
 }
 
-function unifyStatementWithBracketedCombinator(statement, assignments, stated, context) {
+function unifyStatementWithCombinators(statement, assignments, stated, context) {
   stated = true;  ///
 
   assignments = null; ///
 
-  const { BracketedCombinator } = elements,
-        bracketedCombinator = BracketedCombinator.fromNothing(),
-        statementUnifiesWithBracketedCombinator = bracketedCombinator.unifyStatement(statement, assignments, stated, context);
+  const combinators = context.getCombinators(),
+    statementUnifiesWithCombinators = combinators.some((combinator) => {
+      const unifiesWithCombinator = combinator.unifyStatement(statement, assignments, stated, context);
 
-  return statementUnifiesWithBracketedCombinator;
+      if (unifiesWithCombinator) {
+        return true;
+      }
+    });
+
+  return statementUnifiesWithCombinators;
 }
 
-function unifyStatementWithCombinators(statement, assignments, stated, context) {
+function unifyStatementWithBracketedCombinator(statement, assignments, stated, context) {
   stated = true;  ///
 
   assignments = null; ///
 
-  const combinators = context.getCombinators(),
-        statementUnifiesWithCombinators = combinators.some((combinator) => {
-          const unifiesWithCombinator = combinator.unifyStatement(statement, assignments, stated, context);
-
-          if (unifiesWithCombinator) {
-            return true;
-          }
-        });
+  const bracketedCombinator = bracketedCombinatorFromNothing(),
+        statementUnifiesWithBracketedCombinator = bracketedCombinator.unifyStatement(statement, assignments, stated, context);
 
-  return statementUnifiesWithCombinators;
+  return statementUnifiesWithBracketedCombinator;
 }
 
 function validateStatementAsEquality(statement, assignments, stated, context) {
@@ -349,15 +340,15 @@ function validateStatementAsSatisfiesAssertion(statement, assignments, stated, c
 }
 
 export const validateTerms = [
-  unifyTermWithBracketedConstructor,
+  validateTermAsVariable,
   unifyTermWithConstructors,
-  validateTermAsVariable
+  unifyTermWithBracketedConstructor
 ];
 
 export const validateStatements = [
-  validateStatementAsMetavariableAndSubstitution,
-  unifyStatementWithBracketedCombinator,
+  validateStatementAsMetavariable,
   unifyStatementWithCombinators,
+  unifyStatementWithBracketedCombinator,
   validateStatementAsEquality,
   validateStatementAsJudgement,
   validateStatementAsTypeAssertion,