occam-verify-cli 0.0.932 → 0.0.933

package/src/{verify → unify}/variableAgainstTerm.js

@@ -8,8 +8,8 @@ import { nodeQuery } from "../utilities/query";
 
 const variableNodeQuery = nodeQuery("/term/variable");
 
-export default function verifyVariableAgainstTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {
-  let variableVerifiedAgainstTerm = false;
+export default function unifyVariableAgainstTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {
+  let variableUnifiedAgainstTerm = false;
 
   const substitution = substitutions.find((substitution) => {
     const substitutionMatchesVariableNodeA = substitution.matchVariableNode(variableNodeA);
@@ -25,14 +25,14 @@ export default function verifyVariableAgainstTerm(variableNodeA, termNodeB, subs
     if (substitutionMatchesTermNodeB) {
       const verifiedAhead = verifyAhead();
 
-      variableVerifiedAgainstTerm = verifiedAhead;  ///
+      variableUnifiedAgainstTerm = verifiedAhead;  ///
     }
   } else {
     const variableA = localContextA.findVariableByVariableNode(variableNodeA);
 
     if (variableA !== null) {
       const terms = [],
-            termVerified = verifyTerm(termNodeB, terms, localContextB, () => {
+            termUnified = verifyTerm(termNodeB, terms, localContextB, () => {
               let verifiedAhead = false;
 
               const firstTerm = first(terms),
@@ -67,11 +67,11 @@ export default function verifyVariableAgainstTerm(variableNodeA, termNodeB, subs
               return verifiedAhead;
             });
 
-      variableVerifiedAgainstTerm = termVerified;  ///
+      variableUnifiedAgainstTerm = termUnified;  ///
     }
   }
 
-  return variableVerifiedAgainstTerm;
+  return variableUnifiedAgainstTerm;
 }
 
 function variableFromTerm(term, localContext) {

package/src/verifier/{node/metaLevel.js → metaLevel.js}

@@ -1,26 +1,26 @@
 "use strict";
 
-import NodeVerifier from "../../verifier/node";
+import Verifier from "../verifier";
 
-import { nodeQuery } from "../../utilities/query";
-import { verifyNode } from "../../utilities/verifier";
-import { verifyStandaloneTerm } from "../../verify/term";
-import { verifyStandaloneVariable } from "../../verify/variable";
-import { verifyStandaloneMetavariable } from "../../verify/metavariable";
+import { verify } from "../verifier";
+import { nodeQuery } from "../utilities/query";
+import { verifyStandaloneTerm } from "../verify/term";
+import { verifyStandaloneVariable } from "../verify/variable";
+import { verifyStandaloneMetavariable } from "../verify/metavariable";
 
 const termNodeQuery = nodeQuery("/term!"),
       variableNodeQuery = nodeQuery("/variable!"),
       nonTerminalNodeQuery = nodeQuery("/*"),
       metavariableNodeQuery = nodeQuery("/metavariable!");
 
-class MetaLevelNodeVerifier extends NodeVerifier {
+class MetaLevelVerifier extends Verifier {
   verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead) {
     let nonTerminalNodeVerified;
 
     const nodeQueryMaps = [
       {
         nodeQuery: termNodeQuery,
-        verifyNode: (node, localContext, verifyAhead) => {
+        verify: (node, localContext, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const termNode = node, ///
@@ -33,7 +33,7 @@ class MetaLevelNodeVerifier extends NodeVerifier {
       },
       {
         nodeQuery: variableNodeQuery,
-        verifyNode: (node, localContext, verifyAhead) => {
+        verify: (node, localContext, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const variableNode = node, ///
@@ -46,7 +46,7 @@ class MetaLevelNodeVerifier extends NodeVerifier {
       },
       {
         nodeQuery: metavariableNodeQuery,
-        verifyNode: (node, localContext, verifyAhead) => {
+        verify: (node, localContext, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const metavariableNode = node, ///
@@ -59,7 +59,7 @@ class MetaLevelNodeVerifier extends NodeVerifier {
       },
       {
         nodeQuery: nonTerminalNodeQuery,
-        verifyNode: (node, localContext, verifyAhead) => {
+        verify: (node, localContext, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const nonTerminalNode = node; ///
@@ -73,7 +73,7 @@ class MetaLevelNodeVerifier extends NodeVerifier {
       }
     ];
 
-    const nodeVerified = verifyNode(nodeQueryMaps, nonTerminalNode, localContext, verifyAhead);
+    const nodeVerified = verify(nodeQueryMaps, nonTerminalNode, localContext, verifyAhead);
 
     nonTerminalNodeVerified = nodeVerified; ///
 
@@ -102,6 +102,6 @@ class MetaLevelNodeVerifier extends NodeVerifier {
   }
 }
 
-const metaLevelNodeVerifier = new MetaLevelNodeVerifier();
+const metaLevelVerifier = new MetaLevelVerifier();
 
-export default metaLevelNodeVerifier;
+export default metaLevelVerifier;

package/src/verifier/{node/statementAsCombinator.js → statementAsCombinator.js}

@@ -1,26 +1,26 @@
 "use strict";
 
-import NodeVerifier from "../../verifier/node";
+import Verifier from "../verifier";
 
-import { nodeQuery } from "../../utilities/query";
-import { verifyNode } from "../../utilities/verifier";
-import { verifyStandaloneType } from "./../../verify/type";
-import { verifyStandaloneTerm } from "./../../verify/term";
-import { verifyStandaloneStatement } from "../../verify/statement";
+import { verify } from "../verifier";
+import { nodeQuery } from "../utilities/query";
+import { verifyStandaloneType } from "../verify/type";
+import { verifyStandaloneTerm } from "../verify/term";
+import { verifyStandaloneStatement } from "../verify/statement";
 
 const termNodeQuery = nodeQuery("/term!"),
       typeNodeQuery = nodeQuery("/type!"),
       statementNodeQuery = nodeQuery("/statement!"),
       nonTerminalNodeQuery = nodeQuery("/*");
 
-class StatementAsCombinatorNodeVerifier extends NodeVerifier {
+class StatementAsCombinatorVerifier extends Verifier {
   verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead) {
     let nonTerminalNodeVerified;
 
     const nodeQueryMaps = [
       {
         nodeQuery: termNodeQuery,
-        verifyNode: (node, localContext, verifyAhead) => {
+        verify: (node, localContext, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const termNode = node, ///
@@ -33,7 +33,7 @@ class StatementAsCombinatorNodeVerifier extends NodeVerifier {
       },
       {
         nodeQuery: typeNodeQuery,
-        verifyNode: (node, localContext, verifyAhead) => {
+        verify: (node, localContext, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const typeNode = node, ///
@@ -46,7 +46,7 @@ class StatementAsCombinatorNodeVerifier extends NodeVerifier {
       },
       {
         nodeQuery: statementNodeQuery,
-        verifyNode: (node, localContext, verifyAhead) => {
+        verify: (node, localContext, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const statementNode = node, ///
@@ -59,7 +59,7 @@ class StatementAsCombinatorNodeVerifier extends NodeVerifier {
       },
       {
         nodeQuery: nonTerminalNodeQuery,
-        verifyNode: (node, localContext, verifyAhead) => {
+        verify: (node, localContext, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const nonTerminalNode = node; ///
@@ -73,7 +73,7 @@ class StatementAsCombinatorNodeVerifier extends NodeVerifier {
       }
     ];
 
-    const nodeVerified = verifyNode(nodeQueryMaps, nonTerminalNode, localContext, verifyAhead);
+    const nodeVerified = verify(nodeQueryMaps, nonTerminalNode, localContext, verifyAhead);
 
     nonTerminalNodeVerified = nodeVerified; ///
 
@@ -102,6 +102,6 @@ class StatementAsCombinatorNodeVerifier extends NodeVerifier {
   }
 }
 
-const statementAsCombinatorNodeVerifier = new StatementAsCombinatorNodeVerifier();
+const statementAsCombinatorVerifier = new StatementAsCombinatorVerifier();
 
-export default statementAsCombinatorNodeVerifier;
+export default statementAsCombinatorVerifier;

package/src/verifier/{node/termAsConstructor.js → termAsConstructor.js}

@@ -1,24 +1,24 @@
 "use strict";
 
-import NodeVerifier from "../../verifier/node";
+import Verifier from "../verifier";
 
-import { nodeQuery } from "../../utilities/query";
-import { verifyNode } from "../../utilities/verifier";
-import { verifyStandaloneType } from "../../verify/type";
-import { verifyStandaloneTerm } from "../../verify/term";
+import { verify } from "../verifier";
+import { nodeQuery } from "../utilities/query";
+import { verifyStandaloneType } from "../verify/type";
+import { verifyStandaloneTerm } from "../verify/term";
 
 const termNodeQuery = nodeQuery("/term!"),
       typeNodeQuery = nodeQuery("/type!"),
       nonTerminalNodeQuery = nodeQuery("/*");
 
-class TermAsConstructorNodeVerifier extends NodeVerifier {
+class TermAsConstructorVerifier extends Verifier {
   verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead) {
     let nonTerminalNodeVerified;
 
     const nodeQueryMaps = [
       {
         nodeQuery: termNodeQuery,
-        verifyNode: (node, localContext, verifyAhead) => {
+        verify: (node, localContext, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const termNode = node, ///
@@ -31,7 +31,7 @@ class TermAsConstructorNodeVerifier extends NodeVerifier {
       },
       {
         nodeQuery: typeNodeQuery,
-        verifyNode: (node, localContext, verifyAhead) => {
+        verify: (node, localContext, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const typeNode = node, ///
@@ -44,7 +44,7 @@ class TermAsConstructorNodeVerifier extends NodeVerifier {
       },
       {
         nodeQuery: nonTerminalNodeQuery,
-        verifyNode: (node, localContext, verifyAhead) => {
+        verify: (node, localContext, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const nonTerminalNode = node; ///
@@ -58,7 +58,7 @@ class TermAsConstructorNodeVerifier extends NodeVerifier {
       }
     ];
 
-    const nodeVerified = verifyNode(nodeQueryMaps, nonTerminalNode, localContext, verifyAhead);
+    const nodeVerified = verify(nodeQueryMaps, nonTerminalNode, localContext, verifyAhead);
 
     nonTerminalNodeVerified = nodeVerified; ///
 
@@ -80,6 +80,6 @@ class TermAsConstructorNodeVerifier extends NodeVerifier {
   }
 }
 
-const termAsConstructorNodeVerifier = new TermAsConstructorNodeVerifier();
+const termAsConstructorVerifier = new TermAsConstructorVerifier();
 
-export default termAsConstructorNodeVerifier;
+export default termAsConstructorVerifier;

package/src/{verifier/node.js → verifier.js}

@@ -1,6 +1,6 @@
 "use strict";
 
-export default class NodeVerifier {
+export default class Verifier {
   verifyNode(node, ...remainingArguments) {
     let nodeVerified;
 
@@ -82,3 +82,21 @@ export default class NodeVerifier {
     return childNodesVerify;
   }
 }
+
+export function verify(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;
+}

package/src/verify/assertion/contained.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import metaLevelNodeVerifier from "../../verifier/node/metaLevel";
+import metaLevelVerifier from "../../verifier/metaLevel";
 
 import { isAssertionNegated } from "../../utilities/verify";
 import { nodeQuery, nodesQuery } from "../../utilities/query";
@@ -84,7 +84,7 @@ function verifyStatedContainedAssertion(containedAssertionNode, assignments, der
     localContext.debug(`The '${containedAssertionString}' stated contained assertion cannot be verified.`, containedAssertionNode);
 
     const nonTerminalNode = containedAssertionNode, ///
-          nonTerminalNodeVerified = metaLevelNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
+          nonTerminalNodeVerified = metaLevelVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;

package/src/verify/assertion/defined.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import verifyTerm from "../../verify/term";
-import metaLevelNodeVerifier from "../../verifier/node/metaLevel";
+import metaLevelVerifier from "../../verifier/metaLevel";
 
 import { first } from "../../utilities/array";
 import { nodeQuery } from "../../utilities/query";
@@ -113,7 +113,7 @@ function verifyStatedDefinedAssertion(definedAssertionNode, assignments, derived
     localContext.trace(`Verifying the '${definedAssertionString}' stated defined assertion...`, definedAssertionNode);
 
     const nonTerminalNode = definedAssertionNode, ///
-          nonTerminalNodeVerified = metaLevelNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
+          nonTerminalNodeVerified = metaLevelVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;

package/src/verify/declaration.js

@@ -1,14 +1,14 @@
 "use strict";
 
 import Declaration from "../declaration"
+import metaLevelUnifier from "../unifier/metaLevel";
 import referenceMetaType from "../metaType/reference";
-import metaLevelNodeVerifier from "../verifier/node/metaLevel";
 
 import { nodeQuery } from "../utilities/query";
 
 const referenceNodeQuery = nodeQuery("/declaration/reference!"),
       statementNodeQuery = nodeQuery("/declaration/statement!"),
-      metavariableNodeQuery = nodeQuery("/reference/metavariable!");
+      metavariableNodeQuery = nodeQuery("/metavariable!");
 
 export default function verifyDeclaration(declarationNode, declarations, localContext) {
   let declarationVerified = false;
@@ -23,7 +23,7 @@ export default function verifyDeclaration(declarationNode, declarations, localCo
   if (referenceVerified) {
     const statementNode = statementNodeQuery(declarationNode);
 
-    const { verifyStatement } = metaLevelNodeVerifier,
+    const { verifyStatement } = metaLevelUnifier,
           derived = false,
           assignments = [],
           statementVerified = verifyStatement(statementNode, assignments, derived, localContext);

package/src/verify/frame.js

@@ -19,27 +19,24 @@ export default function verifyFrame(frameNode, frames, assignments, derived, loc
 
   const declarations = [],
         declarationNodes = declarationNodesQuery(frameNode),
+        metavariableNodes = metavariableNodesQuery(frameNode),
         declarationsVerified = declarationNodes.every((declarationNode) => {
           const declarationVerified = verifyDeclaration(declarationNode, declarations, localContext);
 
           return declarationVerified;
-        });
-
-  if (declarationsVerified) {
-    const metavariableNodes = metavariableNodesQuery(frameNode),
-          metavariablesVerified = metavariableNodes.every((metavariableNode) => {
-            const metavariableVerified = verifyMetavariable(metavariableNode, declarations, localContext);
+        }),
+        metavariablesVerified = metavariableNodes.every((metavariableNode) => {
+          const metavariableVerified = verifyMetavariable(metavariableNode, declarations, localContext);
 
-            return metavariableVerified;
-          });
+          return metavariableVerified;
+        });
 
-    if (metavariablesVerified) {
-      const frame = Frame.fromDeclarations(declarations);
+  if (declarationsVerified && metavariablesVerified) {
+    const frame = Frame.fromDeclarations(declarations);
 
-      frames.push(frame);
+    frames.push(frame);
 
-      frameVerified = true;
-    }
+    frameVerified = true;
   }
 
   if (frameVerified) {

package/src/verify/judgement.js

@@ -9,7 +9,7 @@ import { first } from "../utilities/array";
 import { nodeQuery } from "../utilities/query";
 
 const frameNodeQuery = nodeQuery("/judgement/frame!"),
-      metavariableNodeQuery = nodeQuery("/judgement/metavariable!");
+      metavariableNodeQuery = nodeQuery("/judgement/statement/metavariable!");
 
 export default function verifyJudgement(judgementNode, assignments, derived, localContext) {
   let judgementVerified;

package/src/verify/statement/qualified.js

@@ -1,13 +1,13 @@
 "use strict";
 
+import unifyMetavariableAgainstStatement from "../../unify/metavariableAgainstStatement";
+
 import { nodeQuery } from "../../utilities/query";
 import { verifyStatementAsEquality, verifyStatementAsTypeAssertion } from "../../verify/statement";
 
 const statementNodeQuery = nodeQuery("/qualifiedStatement/statement!"),
       metavariableNodeQuery = nodeQuery("/qualifiedStatement/reference/metavariable!");
 
-import verifyMetavariableAgainstStatement from "../../verify/metavariableAgainstStatement";
-
 export default function verifyQualifiedStatement(qualifiedStatementNode, substitutions, assignments, localContext) {
   let qualifiedStatementVerified;
 
@@ -184,7 +184,16 @@ function verifyQualifiedStatementAAgainstReference(qualifiedStatementNode, subst
 
   if (metavariablePresent) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
-          metavariableVerifiedAgainstStatement = verifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNode, substitutions, localContextA, localContextB, verifyAhead);
+          localContextA = null,
+          localContextB = localContext, ///
+          statementNodeB = statementNode, ///
+          substitutionNode = null,
+          metavariableNodeA = metavariableString, ///
+          metavariableVerifiedAgainstStatement = unifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNode, substitutions, localContextA, localContextB, () => {
+            const verifiedAhead = true;
+
+            return verifiedAhead;
+          });
 
     qualifiedStatementVerifiedAgainstReference = metavariableVerifiedAgainstStatement; ///
   }

package/src/verify/statement/unqualified.js

@@ -3,7 +3,7 @@
 import verifyStatement from "../../verify/statement";
 
 import { nodeQuery } from "../../utilities/query";
-import { verifyStatementAsEquality, verifyStatementAsTypeAssertion } from "../../verify/statement";
+import { verifyStatementAsEquality, verifyStatementAsJudgement, verifyStatementAsTypeAssertion } from "../../verify/statement";
 
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
 
@@ -92,6 +92,7 @@ function verifyDerivedStatement(statementNode, assignments, derived, localContex
 
   const verifyStatementFunctions = [
     verifyStatementAsEquality,
+    verifyStatementAsJudgement,
     verifyStatementAsTypeAssertion
   ];
 

package/src/verify/statement.js

@@ -2,12 +2,13 @@
 
 import verifyEquality from "../verify/equality";
 import verifyJudgement from "../verify/judgement";
+import metaLevelUnifier from "../unifier/metaLevel";
 import bracketedCombinator from "../ocmbinator/bracketed";
 import verifyTypeAssertion from "../verify/assertion/type";
 import verifyDefinedAssertion from "../verify/assertion/defined";
 import verifySubproofAssertion from "../verify/assertion/subproof";
 import verifyContainedAssertion from "../verify/assertion/contained";
-import statementAgainstCombinatorNodesVerifier from "../verifier/nodes/statementAgainstCombinator";
+import statementAgainstCombinatorUnifier from "../unifier/statementAgainstCombinator";
 
 import { nodeQuery } from "../utilities/query";
 import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
@@ -15,10 +16,10 @@ import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 const variableNodeQuery = nodeQuery("/substitution/variable!"),
       equalityNodeQuery = nodeQuery("/statement/equality!"),
       judgementNodeQuery = nodeQuery("/statement/judgement!"),
-      termVariableNodeQuery = nodeQuery("/substitution/term/variable!"),
       metavariableNodeQuery = nodeQuery("/statement/metavariable!"),
       substitutionNodeQuery = nodeQuery("/statement/substitution!"),
       typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!"),
+      termVariableNodeQuery = nodeQuery("/substitution/term/variable!"),
       definedAssertionNodeQuery = nodeQuery("/statement/definedAssertion!"),
       subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion!"),
       containedAssertionNodeQuery = nodeQuery("/statement/containedAssertion!");
@@ -80,7 +81,11 @@ export function verifyStandaloneStatement(statementNode, localContext, verifyAhe
   return standaloneStatementVerified;
 }
 
-Object.assign(statementAgainstCombinatorNodesVerifier, {
+Object.assign(metaLevelUnifier, {
+  verifyStatement
+});
+
+Object.assign(statementAgainstCombinatorUnifier, {
   verifyStatement
 });
 
@@ -112,48 +117,48 @@ export function verifyStatementAsEquality(statementNode, assignments, derived, l
   return statementVerifiedAsEquality;
 }
 
-export function verifyStatementAsTypeAssertion(statementNode, assignments, derived, localContext) {
-  let statementVerifiedAsTypeAssertion = false;
+export function verifyStatementAsJudgement(statementNode, assignments, derived, localContext) {
+  let statementVerifiedAsJudgement = false;
 
-  const typeAssertionNode = typeAssertionNodeQuery(statementNode);
+  const judgementNode = judgementNodeQuery(statementNode);
 
-  if (typeAssertionNode !== null) {
+  if (judgementNode !== null) {
     const statementString = localContext.nodeAsString(statementNode);
 
-    localContext.trace(`Verifying the '${statementString}' statement as a type assertion...`, statementNode);
+    localContext.trace(`Verifying the '${statementString}' statement as a judgement...`, statementNode);
 
-    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, derived, localContext);
+    const judgementVerified = verifyJudgement(judgementNode, assignments, derived, localContext);
 
-    statementVerifiedAsTypeAssertion = typeAssertionVerified; ///
+    statementVerifiedAsJudgement = judgementVerified;  ///
 
-    if (statementVerifiedAsTypeAssertion) {
-      localContext.debug(`...verified the '${statementString}' statement as a type assertion.`, statementNode);
+    if (statementVerifiedAsJudgement) {
+      localContext.debug(`...verified the '${statementString}' statement as a judgement.`, statementNode);
     }
   }
 
-  return statementVerifiedAsTypeAssertion;
+  return statementVerifiedAsJudgement;
 }
 
-function verifyStatementAsJudgement(statementNode, assignments, derived, localContext) {
-  let statementVerifiedAsJudgement = false;
+export function verifyStatementAsTypeAssertion(statementNode, assignments, derived, localContext) {
+  let statementVerifiedAsTypeAssertion = false;
 
-  const judgementNode = judgementNodeQuery(statementNode);
+  const typeAssertionNode = typeAssertionNodeQuery(statementNode);
 
-  if (judgementNode !== null) {
+  if (typeAssertionNode !== null) {
     const statementString = localContext.nodeAsString(statementNode);
 
-    localContext.trace(`Verifying the '${statementString}' statement as a judgement...`, statementNode);
+    localContext.trace(`Verifying the '${statementString}' statement as a type assertion...`, statementNode);
 
-    const judgementVerified = verifyJudgement(judgementNode, assignments, derived, localContext);
+    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, derived, localContext);
 
-    statementVerifiedAsJudgement = judgementVerified;  ///
+    statementVerifiedAsTypeAssertion = typeAssertionVerified; ///
 
-    if (statementVerifiedAsJudgement) {
-      localContext.debug(`...verified the '${statementString}' statement as a judgement.`, statementNode);
+    if (statementVerifiedAsTypeAssertion) {
+      localContext.debug(`...verified the '${statementString}' statement as a type assertion.`, statementNode);
     }
   }
 
-  return statementVerifiedAsJudgement;
+  return statementVerifiedAsTypeAssertion;
 }
 
 function verifyStatementAsMetavariable(statementNode, assignments, derived, localContext) {
@@ -312,13 +317,13 @@ function verifyStatementAgainstCombinator(statementNode, combinator, localContex
   const combinatorStatementNode = combinator.getStatementNode(),
         nonTerminalNodeA = statementNode, ///
         nonTerminalNodeB = combinatorStatementNode, ///
-        nonTerminalNodeVerified = statementAgainstCombinatorNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, () => {
+        nonTerminalNodeUnify = statementAgainstCombinatorUnifier.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, () => {
           const verifiedAhead = true;
 
           return verifiedAhead;
         });
 
-  statementVerifiedAgainstCombinator = nonTerminalNodeVerified;  ///
+  statementVerifiedAgainstCombinator = nonTerminalNodeUnify;  ///
 
   if (statementVerifiedAgainstCombinator) {
     localContext.debug(`...verified the '${statementString}' statement against the '${combinatorString}' combinator.`, statementNode);

package/src/verify/statementAsCombinator.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import Combinator from "../combinator";
-import statementAsCombinatorNodeVerifier from "../verifier/node/statementAsCombinator";
+import statementAsCombinatorVerifier from "../verifier/statementAsCombinator";
 
 export default function verifyStatementAsCombinator(statementNode, fileContext) {
   let statementVerifiedAsCombinator = false;
@@ -12,7 +12,7 @@ export default function verifyStatementAsCombinator(statementNode, fileContext)
 
   const nonTerminalNode = statementNode, ///
         childNodes = nonTerminalNode.getChildNodes(),
-        childNodesVerified = statementAsCombinatorNodeVerifier.verifyChildNodes(childNodes, fileContext, () => {
+        childNodesVerified = statementAsCombinatorVerifier.verifyChildNodes(childNodes, fileContext, () => {
           const verifiedAhead = true;
 
           return verifiedAhead;