occam-verify-cli 0.0.960 → 0.0.962

package/src/verify/term.js

@@ -2,34 +2,43 @@
 
 import shim from "../shim";
 import Term from "../term";
-import bracketedConstructor from "../constructor/bracketed";
-import termWithConstructorUnifier from "../unifier/termWithConstructor";
+import unifyTermWithConstructors from "../unify/termWithConstructors";
+import unifyTermWithBracketedConstructor from "../unify/termWithBracketedConstructor";
 
+import { first } from "../utilities/array";
 import { nodeQuery } from "../utilities/query";
 
-const termNodeQuery = nodeQuery("/term/argument/term"),
-      variableNodeQuery = nodeQuery("/term/variable!");
+const variableNodeQuery = nodeQuery("/term/variable!");
+
+const unifyTermFunctions = [
+        unifyTermWithBracketedConstructor,
+        unifyTermWithConstructors,
+      ];
 
 function verifyTerm(termNode, terms, localContext, verifyAhead) {
-  let termVerified;
+  let termVerified = false;
 
   const termString = localContext.nodeAsString(termNode);
 
   localContext.trace(`Verifying the '${termString}' term...`, termNode);
 
-  const verifyTermFunctions = [
-    verifyTermAsVariable,
-    unifyTermWithConstructors,
-    unifyTermWithBracketedConstructor
-  ];
+  if (!termVerified) {
+    const termVerifiedAsVariable = verifyTermAsVariable(termNode, terms, localContext, verifyAhead);
 
-  termVerified = verifyTermFunctions.some((verifyTermFunction) => {
-    const termVerified = verifyTermFunction(termNode, terms, localContext, verifyAhead);
+    termVerified = termVerifiedAsVariable; ///
+  }
 
-    if (termVerified) {
-      return true;
-    }
-  });
+  if (!termVerified) {
+    const termUnified = unifyTermFunctions.some((unifyTermFunction) => {
+      const termUnified = unifyTermFunction(termNode, terms, localContext, verifyAhead);
+
+      if (termUnified) {
+        return true;
+      }
+    });
+
+    termVerified = termUnified; ///
+  }
 
   if (termVerified) {
     localContext.debug(`...verified the '${termString}' term.`, termNode);
@@ -54,12 +63,15 @@ function verifyTermAsVariable(termNode, terms, localContext, verifyAhead) {
 
     localContext.trace(`Verifying the '${termString}' term as a variable...`, termNode);
 
-    const variable = localContext.findVariableByVariableNode(variableNode);
+    const variables = [],
+          variableVerified = verifyVariable(variableNode, variables, localContext);
 
-    if (variable !== null) {
+    if (variableVerified) {
       let verifiedAhead;
 
-      const type = variable.getType(),
+      const firstVariable = first(variables),
+            variable = firstVariable, ///
+            type = variable.getType(),
             term = Term.fromTermNodeAndType(termNode, type);
 
       terms.push(term);
@@ -79,87 +91,26 @@ function verifyTermAsVariable(termNode, terms, localContext, verifyAhead) {
   return termVerifiedAsVariable;
 }
 
-function unifyTermWithConstructors(termNode, terms, localContext, verifyAhead) {
-  let termUnifiedWithConstructors = false;
-
-  const variableNode = variableNodeQuery(termNode);
-
-  if (variableNode === null) {
-    const constructors = localContext.getConstructors();
-
-    termUnifiedWithConstructors = constructors.some((constructor) => {
-      const termUnifiedWithConstructor = unifyTermWithConstructor(termNode, terms, constructor, localContext, verifyAhead);
-
-      if (termUnifiedWithConstructor) {
-        return true;
-      }
-    });
-  }
-
-  return termUnifiedWithConstructors;
-}
+function verifyVariable(variableNode, variables, localContext) {
+  let variableVerified = false;
 
-function unifyTermWithBracketedConstructor(termNode, terms, localContext, verifyAhead) {
-  let termUnifiedWithBracketedConstructor;
+  const variableString = localContext.nodeAsString(variableNode);
 
-  const termString = localContext.nodeAsString(termNode),
-        bracketedTerms = [];
+  localContext.trace(`Verifying the '${variableString}' variable...`, variableNode);
 
-  localContext.trace(`Unifying the '${termString}' term with the bracketed constructor...`, termNode);
+  const variable = localContext.findVariableByVariableNode(variableNode);
 
-  termUnifiedWithBracketedConstructor = unifyTermWithConstructor(termNode, bracketedTerms, bracketedConstructor, localContext, () => {
-    let verifiedAhead;
+  if (variable === null) {
+    localContext.trace(`The '${variableString}' variable is not present.`, variableNode);
+  } else {
+    variables.push(variable);
 
-    const bracketedTermNode = termNode; ///
-
-    termNode = termNodeQuery(bracketedTermNode); ///
-
-    const termVVerified = verifyTerm(termNode, terms, localContext, verifyAhead);
-
-    verifiedAhead = termVVerified;  ///
-
-    return verifiedAhead;
-  });
-
-  if (termUnifiedWithBracketedConstructor) {
-    localContext.debug(`...unified the '${termString}' term with the bracketed constructor.`, termNode);
+    variableVerified = true;
   }
 
-  return termUnifiedWithBracketedConstructor;
-}
-
-function unifyTermWithConstructor(termNode, terms, constructor, localContext, verifyAhead) {
-  let termUnifiedWithConstructor = false;
-
-  const termString = localContext.nodeAsString(termNode),
-        constructorString = constructor.getString(),
-        constructorTermNode = constructor.getTermNode();
-
-  localContext.trace(`Unifying the '${termString}' term with the '${constructorString}' constructor...`, termNode);
-
-  const termNodeA = termNode,  ///
-        constructorTermNodeB = constructorTermNode,  ///
-        unified = termWithConstructorUnifier.unify(termNodeA, constructorTermNodeB, localContext);
-
-  if (unified) {
-    let verifiedAhead;
-
-    const type = constructor.getType(),
-          term = Term.fromTermNodeAndType(termNode, type);
-
-    terms.push(term);
-
-    verifiedAhead = verifyAhead();
-
-    terms.pop();
-
-    termUnifiedWithConstructor = verifiedAhead;  ///
-  }
-
-  if (termUnifiedWithConstructor) {
-    localContext.debug(`...unified the '${termString}' term with the '${constructorString}' constructor.`, termNode);
+  if (variableVerified) {
+    localContext.debug(`...verified the '${variableString}' variable.`, variableNode);
   }
 
-  return termUnifiedWithConstructor;
+  return variableVerified;
 }
-

package/src/verify/termAsConstructor.js

@@ -22,7 +22,7 @@ export default function verifyTermAsConstructor(termNode, typeNode, fileContext)
 
     type = firstType; ///
 
-    termVerifiedAsConstructor = termAsConstructorVerifier.verify(termNode, fileContext);
+    termVerifiedAsConstructor = termAsConstructorVerifier.verifyTerm(termNode, fileContext);
   }
 
   if (termVerifiedAsConstructor) {

package/src/verify/termGivenType.js

@@ -0,0 +1,32 @@
+"use strict";
+
+import shim from "../shim";
+
+import { first } from "../utilities/array";
+
+export default function verifyTermGivenType(termNode, type, localContext) {
+  let termVerifiedGivenType = false;
+
+  if (type !== null) {
+    const { verifyTerm } = shim,
+          terms = [],
+          termVerified = verifyTerm(termNode, terms, localContext, () => {
+            let verifiedAhead = false;
+
+            const firstTerm = first(terms),
+                  term = firstTerm, ///
+                  termType = term.getType(),
+                  termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);
+
+            if (termTypeEqualToOrSubTypeOfType) {
+              verifiedAhead = true;
+            }
+
+            return verifiedAhead;
+          });
+
+    termVerifiedGivenType = termVerified; ///
+  }
+
+  return termVerifiedGivenType;
+}