occam-verify-cli 0.0.524 → 0.0.526

package/src/verify/metastatement/qualified.js

@@ -8,7 +8,7 @@ import { nodeQuery, referenceNameFromReferenceNode } from "../../utilities/query
 const referenceNodeQuery = nodeQuery("/qualifiedMetastatement/qualification!/reference!"),
       metastatementNodeQuery = nodeQuery("/qualifiedMetastatement/metastatement!");
 
-export default function verifyQualifiedMetastatement(qualifiedMetastatementNode, metaproofContext) {
+export default function verifyQualifiedMetastatement(qualifiedMetastatementNode, assertions, derived, metaproofContext) {
   let qualifiedMetastatementVerified = false;
 
   metaproofContext.begin(qualifiedMetastatementNode);
@@ -16,11 +16,11 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
   const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode);
 
   if (metastatementNode !== null) {
-    const metastatementString = nodeAsString(metastatementNode);
+    const metastatementString = metaproofContext.nodeAsString(metastatementNode);
 
-    metaproofContext.debug(`Verifying the ${metastatementString} qualified metastatement...`);
+    metaproofContext.debug(`Verifying the '${metastatementString}' qualified metastatement...`);
 
-    let ruleMatchesStatement = true;
+    let ruleMatchesMetastatement = true;
 
     const referenceNode = referenceNodeQuery(qualifiedMetastatementNode);
 
@@ -29,15 +29,12 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
             rule = metaproofContext.findRuleByReferenceName(referenceName);
 
       if (rule !== null) {
-        const ruleMatchesStatement = rule.matchMetastatement(metastatementNode, metaproofContext);
-
-        qualifiedMetastatementVerified = ruleMatchesStatement;  ///
+        ruleMatchesMetastatement = rule.matchMetastatement(metastatementNode, metaproofContext);
       }
     }
 
-    if (ruleMatchesStatement) {
-      const assertions = [],
-            metastatementVerified = verifyMetastatement(metastatementNode, assertions, metaproofContext);
+    if (ruleMatchesMetastatement) {
+      const metastatementVerified = verifyMetastatement(metastatementNode, assertions, derived, metaproofContext);
 
       qualifiedMetastatementVerified = metastatementVerified; ///
     }

package/src/verify/metastatement/unqualified.js

@@ -15,9 +15,9 @@ export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementN
   const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
 
   if (metastatementNode !== null) {
-    const metastatementString = nodeAsString(metastatementNode);
+    const metastatementString = metaproofContext.nodeAsString(metastatementNode);
 
-    metaproofContext.debug(`Verifying the ${metastatementString} unqualified metastatement...`);
+    metaproofContext.debug(`Verifying the '${metastatementString}' unqualified metastatement...`);
 
     let metastatementMatches = true;
 
@@ -26,7 +26,7 @@ export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementN
     }
 
     if (metastatementMatches) {
-      const metastatementVerified = verifyMetastatement(metastatementNode, assertions, metaproofContext);
+      const metastatementVerified = verifyMetastatement(metastatementNode, assertions, derived, metaproofContext);
 
       unqualifiedMetastatementVerified = metastatementVerified; ///
     }

package/src/verify/metastatement.js

@@ -1,6 +1,6 @@
 "use strict";
 
-export default function verifyMetastatement(metastatementNode, assertions, metaproofContext) {
+export default function verifyMetastatement(metastatementNode, assertions, derived, metaproofContext) {
   let metastatementVerified = true; ///
 
   metaproofContext.begin(metastatementNode);

package/src/verify/premise.js

@@ -5,7 +5,6 @@ import MetaproofStep from "../step/metaproof";
 import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
 
 import { nodeQuery } from "../utilities/query";
-import { nodeAsString } from "../utilities/string";
 
 const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
       unqualifiedMetastatementNodeQuery = nodeQuery("/premise/unqualifiedMetastatement!");
@@ -15,9 +14,9 @@ export default function verifyPremise(premiseNode, premises, metaproofContext) {
 
   metaproofContext.begin(premiseNode);
 
-  const premiseString = nodeAsString(premiseNode);
+  const premiseString = metaproofContext.nodeAsString(premiseNode);
 
-  metaproofContext.debug(`Verifying the ${premiseString} premise...`);
+  metaproofContext.debug(`Verifying the '${premiseString}' premise...`);
 
   const derived = false,
         assertions = [],

package/src/verify/rule.js

@@ -22,7 +22,7 @@ export default function verifyRule(ruleNode, fileContext) {
   fileContext.begin(ruleNode);
 
   const labelNodes = labelNodesQuery(ruleNode),
-        labelsString = nodesAsString(labelNodes),
+        labelsString = fileContext.nodesAsString(labelNodes),
         metaProofContext = MetaproofContext.fromFileContext(fileContext);
 
   fileContext.debug(`Verifying the '${labelsString}' rule...`);

package/src/verify/ruleDerivation.js

@@ -107,8 +107,10 @@ function verifyChild(childNode, metaproofContext) {
     }
 
     case QUALIFIED_METASTATEMENT_RULE_NAME: {
-      const qualifiedMetastatementNode = childNode,  ///
-            qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, metaproofContext);
+      const derived = true,
+            assertions = [],
+            qualifiedMetastatementNode = childNode,  ///
+            qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, assertions, derived, metaproofContext);
 
       if (qualifiedMetastatementVerified) {
         const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),

package/src/verify/statement/qualified.js

@@ -8,7 +8,7 @@ import { nodeQuery, referenceNameFromReferenceNode } from "../../utilities/query
 const referenceNodeQuery = nodeQuery("/qualifiedStatement/qualification!/reference!"),
       statementNodeQuery = nodeQuery("/qualifiedStatement/statement!");
 
-export default function verifyQualifiedStatement(qualifiedStatementNode, proofContext) {
+export default function verifyQualifiedStatement(qualifiedStatementNode, assertions, derived, proofContext) {
   let qualifiedStatementVerified = false;
 
   proofContext.begin(qualifiedStatementNode);
@@ -16,9 +16,9 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, proofCo
   const statementNode = statementNodeQuery(qualifiedStatementNode);
 
   if (statementNode !== null) {
-    const statementString = nodeAsString(statementNode);
+    const statementString = proofContext.nodeAsString(statementNode);
 
-    proofContext.debug(`Verifying the ${statementString} qualified statement...`);
+    proofContext.debug(`Verifying the '${statementString}' qualified statement...`);
 
     let ruleMatchesStatement = true;
 
@@ -34,8 +34,8 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, proofCo
     }
 
     if (ruleMatchesStatement) {
-      const assertions = [],
-            statementVerified = verifyStatement(statementNode, assertions, proofContext);
+      const context = proofContext,
+            statementVerified = verifyStatement(statementNode, assertions, derived, context);
 
       qualifiedStatementVerified = statementVerified; ///
     }

package/src/verify/statement/unqualified.js

@@ -15,9 +15,9 @@ export default function verifyUnqualifiedStatement(unqualifiedStatementNode, ass
   const statementNode = statementNodeQuery(unqualifiedStatementNode);
 
   if (statementNode !== null) {
-    const statementString = nodeAsString(statementNode);
+    const statementString = proofContext.nodeAsString(statementNode);
 
-    proofContext.debug(`Verifying the ${statementString} unqualified statement...`);
+    proofContext.debug(`Verifying the '${statementString}' unqualified statement...`);
 
     let statementMatches = true;
 
@@ -26,7 +26,8 @@ export default function verifyUnqualifiedStatement(unqualifiedStatementNode, ass
     }
 
     if (statementMatches) {
-      const statementVerified = verifyStatement(statementNode, assertions, proofContext);
+      const context = proofContext, ///
+            statementVerified = verifyStatement(statementNode, assertions, derived, context);
 
       unqualifiedStatementVerified = statementVerified;  ///
     }

package/src/verify/statement.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import Equality from "../equality";
 import verifyTerm from "../verify/term";
 import equalityCombinator from "../ocmbinator/equality";
 import bracketedCombinator from "../ocmbinator/bracketed";
@@ -7,9 +8,9 @@ import verifyTypeAssertion from "../verify/assertion/type";
 
 import { first } from "../utilities/array";
 import { objectType } from "../type";
-import { nodeAsString } from "../utilities/string";
 import { OBJECT_TYPE_NAME } from "../typeNames";
 import { STATEMENT_META_TYPE } from "../metaTypes";
+import { MAXIMUM_INDEXES_LENGTH } from "../constants";
 import { nodeQuery, typeNameFromTypeNode } from "../utilities/query";
 import { ARGUMENT_RULE_NAME, META_ARGUMENT_RULE_NAME } from "../ruleNames";
 
@@ -19,56 +20,65 @@ const termNodeQuery = nodeQuery("/argument/term!"),
       statementNodeQuery = nodeQuery("/metaArgument/statement!"),
       typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
 
-export default function verifyStatement(statementNode, assertions, proofContext) {
+export default function verifyStatement(statementNode, assertions, derived, context) {
   let statementVerified = false;
 
-  proofContext.begin(statementNode);
+  context.begin(statementNode);
 
   if (!statementVerified) {
-    const statementVerifiedAsEquality = verifyStatementAsEquality(statementNode, proofContext);
+    const statementVerifiedAsEquality = verifyStatementAsEquality(statementNode, derived, context);
 
     statementVerified = statementVerifiedAsEquality;  //
   }
 
   if (!statementVerified) {
-    const statementVerifiedAsTypeAssertion = verifyStatementAsTypeAssertion(statementNode, assertions, proofContext);
+    const statementVerifiedAsTypeAssertion = verifyStatementAsTypeAssertion(statementNode, assertions, context);
 
     statementVerified = statementVerifiedAsTypeAssertion; ///
   }
 
   if (!statementVerified) {
-    const statementVerifiedAgainstCombinators = verifyStatementAgainstCombinators(statementNode, proofContext);
+    const statementVerifiedAgainstCombinators = verifyStatementAgainstCombinators(statementNode, context);
 
     statementVerified = statementVerifiedAgainstCombinators;  ///
   }
 
   statementVerified ?
-    proofContext.complete(statementNode) :
-      proofContext.halt(statementNode);
+    context.complete(statementNode) :
+      context.halt(statementNode);
 
   return statementVerified;
 }
 
-function verifyStatementAsEquality(statementNode, proofContext) {
+function verifyStatementAsEquality(statementNode, derived, context) {
   let statementVerifiedAsEquality = false;
 
   const combinator = equalityCombinator,  ///
-        statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, proofContext);
+        statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, context);
 
   if (statementVerifiedAgainstCombinator) {
     statementVerifiedAsEquality = true;
+
+    if (derived) {
+      const equality = Equality.fromStatementNode(statementNode),
+            proofSteps = context.getProofSteps(),
+            equalities = equalitiesFromProofSteps(proofSteps),
+            equalityEquates = equality.equate(equalities);
+
+      statementVerifiedAsEquality = equalityEquates; ///
+    }
   }
 
   return statementVerifiedAsEquality;
 }
 
-function verifyStatementAsTypeAssertion(statementNode, assertions, proofContext) {
+function verifyStatementAsTypeAssertion(statementNode, assertions, context) {
   let statementVerifiedAsTypeAssertion = false;
 
   const typeAssertionNode = typeAssertionNodeQuery(statementNode);
 
   if (typeAssertionNode !== null) {
-    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assertions, proofContext);
+    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assertions, context);
 
     statementVerifiedAsTypeAssertion = typeAssertionVerified; ///
   }
@@ -76,10 +86,10 @@ function verifyStatementAsTypeAssertion(statementNode, assertions, proofContext)
   return statementVerifiedAsTypeAssertion;
 }
 
-function verifyStatementAgainstCombinators(statementNode, proofContext) {
+function verifyStatementAgainstCombinators(statementNode, context) {
   let statementVerifiedAgainstCombinators = false;
 
-  let combinators = proofContext.getCombinators();
+  let combinators = context.getCombinators();
 
   combinators = [ ///
     bracketedCombinator,
@@ -87,7 +97,7 @@ function verifyStatementAgainstCombinators(statementNode, proofContext) {
   ];
 
   const combinator = combinators.find((combinator) => {
-          const statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, proofContext);
+          const statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, context);
 
           if (statementVerifiedAgainstCombinator) {
             return true;
@@ -101,17 +111,17 @@ function verifyStatementAgainstCombinators(statementNode, proofContext) {
   return statementVerifiedAgainstCombinators;
 }
 
-function verifyStatementAgainstCombinator(statementNode, combinator, proofContext) {
+function verifyStatementAgainstCombinator(statementNode, combinator, context) {
   const combinatorStatementNode = combinator.getStatementNode(),
         node = statementNode,  ///
         combinatorNode = combinatorStatementNode, ///
-        nodeVerified = verifyNode(node, combinatorNode, proofContext),
+        nodeVerified = verifyNode(node, combinatorNode, context),
         statementVerifiedAgainstCombinator = nodeVerified;  ///
 
   return statementVerifiedAgainstCombinator;
 }
 
-function verifyNode(node, combinatorNode, proofContext) {
+function verifyNode(node, combinatorNode, context) {
   let nodeVerified;
 
   const nodeTerminalNode = node.isTerminalNode(),
@@ -121,13 +131,13 @@ function verifyNode(node, combinatorNode, proofContext) {
     if (nodeTerminalNode) {
       const terminalNode = node,  ///
             combinatorTerminalNode = combinatorNode,  ///
-            terminalNodeVerified = verifyTerminalNode(terminalNode, combinatorTerminalNode, proofContext);
+            terminalNodeVerified = verifyTerminalNode(terminalNode, combinatorTerminalNode, context);
 
       nodeVerified = terminalNodeVerified;  ///
     } else {
       const nonTerminalNode = node, ///
             combinatorNonTerminalNode = combinatorNode,  ///
-            nonTerminalNodeVerified = verifyNonTerminalNode(nonTerminalNode, combinatorNonTerminalNode, proofContext);
+            nonTerminalNodeVerified = verifyNonTerminalNode(nonTerminalNode, combinatorNonTerminalNode, context);
 
       nodeVerified = nonTerminalNodeVerified; ///
     }
@@ -136,7 +146,7 @@ function verifyNode(node, combinatorNode, proofContext) {
   return nodeVerified;
 }
 
-function verifyNodes(nodes, combinatorNodes, proofContext) {
+function verifyNodes(nodes, combinatorNodes, context) {
   let nodesVerified = false;
 
   const nodesLength = nodes.length,
@@ -145,7 +155,7 @@ function verifyNodes(nodes, combinatorNodes, proofContext) {
   if (nodesLength === combinatorNodesLength) {
     nodesVerified = nodes.every((node, index) => {
       const combinatorNode = combinatorNodes[index],
-            nodeVerified = verifyNode(node, combinatorNode, proofContext);
+            nodeVerified = verifyNode(node, combinatorNode, context);
 
       if (nodeVerified) {
         return true;
@@ -156,7 +166,7 @@ function verifyNodes(nodes, combinatorNodes, proofContext) {
   return nodesVerified;
 }
 
-function verifyTerminalNode(terminalNode, combinatorTerminalNode, proofContext) {
+function verifyTerminalNode(terminalNode, combinatorTerminalNode, context) {
   let terminalNodeVerified = false;
 
   const matches = terminalNode.match(combinatorTerminalNode);
@@ -168,7 +178,7 @@ function verifyTerminalNode(terminalNode, combinatorTerminalNode, proofContext)
   return terminalNodeVerified;
 }
 
-function verifyNonTerminalNode(nonTerminalNode, combinatorNonTerminalNode, proofContext) {
+function verifyNonTerminalNode(nonTerminalNode, combinatorNonTerminalNode, context) {
   let nonTerminalNodeVerified = false;
 
   const ruleName = nonTerminalNode.getRuleName(), ///
@@ -179,7 +189,7 @@ function verifyNonTerminalNode(nonTerminalNode, combinatorNonTerminalNode, proof
       case ARGUMENT_RULE_NAME: {
         const argumentNode = nonTerminalNode, ///
               combinatorArgumentNode = combinatorNonTerminalNode, ///
-              argumentNodeVerified = verifyArgumentNode(argumentNode, combinatorArgumentNode, proofContext);
+              argumentNodeVerified = verifyArgumentNode(argumentNode, combinatorArgumentNode, context);
 
         nonTerminalNodeVerified = argumentNodeVerified; ///
 
@@ -189,7 +199,7 @@ function verifyNonTerminalNode(nonTerminalNode, combinatorNonTerminalNode, proof
       case META_ARGUMENT_RULE_NAME: {
         const metaArgumentNode = nonTerminalNode, ///
               combinatorMetaargumentNode = combinatorNonTerminalNode, ///
-              metaArgumentNodeVerified = verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, proofContext);
+              metaArgumentNodeVerified = verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, context);
 
         nonTerminalNodeVerified = metaArgumentNodeVerified; ///
 
@@ -201,7 +211,7 @@ function verifyNonTerminalNode(nonTerminalNode, combinatorNonTerminalNode, proof
               combinatorChildNodes = combinatorNonTerminalNode.getChildNodes(),
               nodes = childNodes, ///
               combinatorNodes = combinatorChildNodes, ///
-              nodesVerified = verifyNodes(nodes, combinatorNodes, proofContext);
+              nodesVerified = verifyNodes(nodes, combinatorNodes, context);
 
         nonTerminalNodeVerified = nodesVerified; ///
 
@@ -213,18 +223,17 @@ function verifyNonTerminalNode(nonTerminalNode, combinatorNonTerminalNode, proof
   return nonTerminalNodeVerified;
 }
 
-function verifyArgumentNode(argumentNode, combinatorArgumentNode, proofContext) {
+function verifyArgumentNode(argumentNode, combinatorArgumentNode, context) {
   let argumentNodeVerified = false;
 
   const termNode = termNodeQuery(argumentNode);
 
   if (termNode === null) {
-    const argumentString = nodeAsString(argumentNode);
+    const argumentString = context.nodeAsString(argumentNode);
 
-    proofContext.error(`The ${argumentString} argument should be a term, not a type`);
+    context.error(`The ${argumentString} argument should be a term, not a type`);
   } else {
     const types = [],
-          context = proofContext, ///
           termVerified = verifyTerm(termNode, types, context);
 
     if (termVerified) {
@@ -234,7 +243,7 @@ function verifyArgumentNode(argumentNode, combinatorArgumentNode, proofContext)
             typeName = typeNameFromTypeNode(typeNode),
             type = (typeName === OBJECT_TYPE_NAME) ?
                      objectType :  ///
-                       proofContext.findTypeByTypeName(typeName),
+                       context.findTypeByTypeName(typeName),
             statementTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);
 
       if (statementTypeEqualToOrSubTypeOfType) {
@@ -246,18 +255,19 @@ function verifyArgumentNode(argumentNode, combinatorArgumentNode, proofContext)
   return argumentNodeVerified;
 }
 
-function verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, proofContext) {
+function verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, context) {
   let metaArgumentNodeVerified = false;
 
   const statementNode = statementNodeQuery(metaArgumentNode);
 
   if (statementNode === null) {
-    const metaArgumentString = nodeAsString(metaArgumentNode);
+    const metaArgumentString = context.nodeAsString(metaArgumentNode);
 
-    proofContext.error(`The '${metaArgumentString}' meta-argument should be a statement, not a meta-type.`);
+    context.error(`The '${metaArgumentString}' meta-argument should be a statement, not a meta-type.`);
   } else {
-    const assertions = null,
-          statementVerified = verifyStatement(statementNode, assertions, proofContext);
+    const derived = false,
+          assertions = null,
+          statementVerified = verifyStatement(statementNode, assertions, derived, context);
 
     if (statementVerified) {
       const combinatorMetaTYpeNode = metaTypeNodeQuery(combinatorMetaargumentNode);
@@ -271,12 +281,30 @@ function verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, pr
       }
 
       if (!metaArgumentNodeVerified) {
-        const combinatorMetaargumentString = nodeAsString(combinatorMetaargumentNode);
+        const combinatorMetaargumentString = context.nodeAsString(combinatorMetaargumentNode);
 
-        proofContext.error(`The '${combinatorMetaargumentString}' combinator meta-argument should be the 'Statement' meta-type.`);
+        context.error(`The '${combinatorMetaargumentString}' combinator meta-argument should be the 'Statement' meta-type.`);
       }
     }
   }
 
   return metaArgumentNodeVerified;
 }
+
+function equalitiesFromProofSteps(proofSteps) {
+  const start = -MAXIMUM_INDEXES_LENGTH;  ///
+
+  proofSteps = proofSteps.slice(start); ///
+
+  const equalities = proofSteps.reduce((equalities, proofStep, index) => {
+    const equality = Equality.fromProofStep(proofStep);
+
+    if (equality !== null) {
+      equalities.push(equality);
+    }
+
+    return equalities;
+  }, []);
+
+  return equalities;
+}

package/src/verify/statementAsCombinator.js

@@ -1,17 +1,18 @@
 "use strict";
 
 import Combinator from "../combinator";
+import verifyTerm from "../verify/term";
+import verifyStatement from "../verify/statement";
 
-import { nodeAsString } from "../utilities/string";
 import { typeNameFromTypeNode } from "../utilities/query";
-import { TERM_RULE_NAME, TYPE_RULE_NAME } from "../ruleNames";
+import { TYPE_RULE_NAME, TERM_RULE_NAME, STATEMENT_RULE_NAME } from "../ruleNames";
 
 export default function verifyStatementAsCombinator(statementNode, fileContext) {
   let statementVerifiedAsCombinator = false;
 
   fileContext.begin(statementNode);
 
-  const statementString = nodeAsString(statementNode);
+  const statementString = fileContext.nodeAsString(statementNode);
 
   fileContext.debug(`Verifying the '${statementString}' combinator....`);
 
@@ -58,29 +59,6 @@ function verifyNode(node, fileContext) {
   return nodeVerified;
 }
 
-function verifyTypeNode(typeNode, fileContext) {
-  let typeNodeVerified = false;
-
-  const typeName = typeNameFromTypeNode(typeNode),
-        typePresent = fileContext.isTypePresentByTypeName(typeName);
-
-  if (!typePresent) {
-    fileContext.error(`The type '${typeName}' is missing.`);
-  } else {
-    typeNodeVerified = true;
-  }
-
-  return typeNodeVerified;
-}
-
-function verifyTermNode(termNode, fileContext) {
-  let termNodeVerified = false;
-
-  debugger
-
-  return termNodeVerified;
-}
-
 function verifyChildNodes(childNodes, fileContext) {
   const childNodesVerified = childNodes.every((childNode) => {
     const node = childNode, ///
@@ -124,6 +102,15 @@ function verifyNonTerminalNode(nonTerminalNode, fileContext) {
       break;
     }
 
+    case STATEMENT_RULE_NAME: {
+      const statmentNode = nonTerminalNode, ///
+            statmentNodeVerified = verifyStatementNode(statmentNode, fileContext);
+
+      nonTerminalNodeVerified = statmentNodeVerified; ///
+
+      break;
+    }
+
     default: {
       const childNodes = nonTerminalNode.getChildNodes(),
             childNodesVerified = verifyChildNodes(childNodes, fileContext);
@@ -136,3 +123,38 @@ function verifyNonTerminalNode(nonTerminalNode, fileContext) {
 
   return nonTerminalNodeVerified;
 }
+
+function verifyTypeNode(typeNode, fileContext) {
+  let typeNodeVerified = false;
+
+  const typeName = typeNameFromTypeNode(typeNode),
+        typePresent = fileContext.isTypePresentByTypeName(typeName);
+
+  if (!typePresent) {
+    fileContext.error(`The type '${typeName}' is missing.`);
+  } else {
+    typeNodeVerified = true;
+  }
+
+  return typeNodeVerified;
+}
+
+function verifyTermNode(termNode, fileContext) {
+  const types = [],
+        context = fileContext,  ///
+        termVerified = verifyTerm(termNode, types, context),
+        termNodeVerified = termVerified;  ///
+
+  return termNodeVerified;
+}
+
+function verifyStatementNode(statementNode, fileContext) {
+  const context = fileContext,  ///
+        derived = false,
+        assertions = [],
+        statementVerified = verifyStatement(statementNode, assertions, derived, context),
+        statementNodeVerified = statementVerified;  ///
+
+  return statementNodeVerified;
+}
+

package/src/verify/supposition.js

@@ -5,7 +5,6 @@ import Supposition from "../supposition";
 import verifyUnqualifiedStatement from "./statement/unqualified";
 
 import { nodeQuery } from "../utilities/query";
-import { nodeAsString } from "../utilities/string";
 
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
       unqualifiedStatementNodeQuery = nodeQuery("/supposition/unqualifiedStatement!");
@@ -15,9 +14,9 @@ export default function verifySupposition(suppositionNode, suppositions, proofCo
 
   proofContext.begin(suppositionNode);
 
-  const suppositionString = nodeAsString(suppositionNode);
+  const suppositionString = proofContext.nodeAsString(suppositionNode);
 
-  proofContext.debug(`Verifying the ${suppositionString} supposition...`);
+  proofContext.debug(`Verifying the '${suppositionString}' supposition...`);
 
   const derived = false,
         assertions = [],

package/src/verify/term.js

@@ -2,7 +2,6 @@
 
 import { first } from "../utilities/array";
 import { objectType } from "../type";
-import { nodeAsString } from "../utilities/string";
 import { OBJECT_TYPE_NAME } from "../typeNames";
 import { ARGUMENT_RULE_NAME } from "../ruleNames";
 import { nodeQuery, typeNameFromTypeNode, variableNameFromVariableNode } from "../utilities/query";
@@ -16,7 +15,7 @@ export default function verifyTerm(termNode, types, context) {
 
   context.begin(termNode);
 
-  const termString = nodeAsString(termNode);
+  const termString = context.nodeAsString(termNode);
 
   context.debug(`Verifying the '${termString}' term...`);
 
@@ -218,7 +217,7 @@ function verifyArgumentNode(argumentNode, constructorArgumentNode, context) {
   const termNode = termNodeQuery(argumentNode);
 
   if (termNode === null) {
-    const argumentString = nodeAsString(argumentNode);
+    const argumentString = context.nodeAsString(argumentNode);
 
     context.error(`The ${argumentString} argument should be a term, not a type`);
   } else {