occam-verify-cli 0.0.935 → 0.0.937

package/src/verifier/metaLevel.js

@@ -2,7 +2,6 @@
 
 import Verifier from "../verifier";
 
-import { verify } from "../verifier";
 import { nodeQuery } from "../utilities/query";
 import { verifyStandaloneTerm } from "../verify/term";
 import { verifyStandaloneVariable } from "../verify/variable";
@@ -10,96 +9,53 @@ import { verifyStandaloneMetavariable } from "../verify/metavariable";
 
 const termNodeQuery = nodeQuery("/term!"),
       variableNodeQuery = nodeQuery("/variable!"),
-      nonTerminalNodeQuery = nodeQuery("/*"),
       metavariableNodeQuery = nodeQuery("/metavariable!");
 
 class MetaLevelVerifier extends Verifier {
-  verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead) {
-    let nonTerminalNodeVerified;
+  verify(node, localContext) {
+    let verified;
 
-    const nodeQueryMaps = [
-      {
-        nodeQuery: termNodeQuery,
-        verify: (node, localContext, verifyAhead) => {
-          let nonTerminalNodeVerified;
+    const nonTerminalNode = node, ///
+          nonTerminalNodeVerified = this.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
+            const verifiedAhead = true;
 
-          const termNode = node, ///
-                termNodeVerified = this.verifyTermNode(termNode, localContext, verifyAhead);
+            return verifiedAhead;
+          });
 
-          nonTerminalNodeVerified = termNodeVerified; ///
+    verified = nonTerminalNodeVerified;  ///
 
-          return nonTerminalNodeVerified;
-        }
-      },
-      {
-        nodeQuery: variableNodeQuery,
-        verify: (node, localContext, verifyAhead) => {
-          let nonTerminalNodeVerified;
-
-          const variableNode = node, ///
-                variableNodeVerified = this.verifyVariableNode(variableNode, localContext, verifyAhead);
-
-          nonTerminalNodeVerified = variableNodeVerified; ///
-
-          return nonTerminalNodeVerified;
-        }
-      },
-      {
-        nodeQuery: metavariableNodeQuery,
-        verify: (node, localContext, verifyAhead) => {
-          let nonTerminalNodeVerified;
-
-          const metavariableNode = node, ///
-                metavariableNodeVerified = this.verifyMetavariableNode(metavariableNode, localContext, verifyAhead);
-
-          nonTerminalNodeVerified = metavariableNodeVerified; ///
-
-          return nonTerminalNodeVerified;
-        }
-      },
-      {
-        nodeQuery: nonTerminalNodeQuery,
-        verify: (node, localContext, verifyAhead) => {
-          let nonTerminalNodeVerified;
-
-          const nonTerminalNode = node; ///
-
-          nonTerminalNodeVerified =
-
-            super.verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead);
-
-          return nonTerminalNodeVerified;
-        }
-      }
-    ];
-
-    const nodeVerified = verify(nodeQueryMaps, nonTerminalNode, localContext, verifyAhead);
-
-    nonTerminalNodeVerified = nodeVerified; ///
-
-    return nonTerminalNodeVerified;
-  }
-
-  verifyMetavariableNode(metavariableNode, localContext, verifyAhead) {
-    const standaloneMetavariableVerified = verifyStandaloneMetavariable(metavariableNode, localContext, verifyAhead),
-          metavariableNodeVerified = standaloneMetavariableVerified;  ///
-
-    return metavariableNodeVerified;
-  }
-
-  verifyVariableNode(variableNode, localContext, verifyAhead) {
-    const standaloneVariableVerified = verifyStandaloneVariable(variableNode, localContext, verifyAhead),
-          variableNodeVerified = standaloneVariableVerified;  ///
-
-    return variableNodeVerified;
+    return verified;
   }
 
-  verifyTermNode(termNode, localContext, verifyAhead) {
-    const standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
-          termNodeVerified = standaloneTermVerified;  ///
+  static maps = [
+    {
+      nodeQuery: metavariableNodeQuery,
+      verify: (metavariableNode, localContext, verifyAhead) => {
+        const standaloneMetavariableVerified = verifyStandaloneMetavariable(metavariableNode, localContext, verifyAhead),
+              metavariableVerified = standaloneMetavariableVerified;  ///
 
-    return termNodeVerified;
-  }
+        return metavariableVerified;
+      }
+    },
+    {
+      nodeQuery: variableNodeQuery,
+      verify: (variableNode, localContext, verifyAhead) => {
+        const standaloneVariableVerified = verifyStandaloneVariable(variableNode, localContext, verifyAhead),
+              variableVerified = standaloneVariableVerified;  ///
+
+        return variableVerified;
+      }
+    },
+    {
+      nodeQuery: termNodeQuery,
+      verify: (termNode, localContext, verifyAhead) => {
+        const standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
+              termVerified = standaloneTermVerified;  ///
+
+        return termVerified;
+      }
+    }
+  ];
 }
 
 const metaLevelVerifier = new MetaLevelVerifier();

package/src/verifier/statementAsCombinator.js

@@ -2,7 +2,6 @@
 
 import Verifier from "../verifier";
 
-import { verify } from "../verifier";
 import { nodeQuery } from "../utilities/query";
 import { verifyStandaloneType } from "../verify/type";
 import { verifyStandaloneTerm } from "../verify/term";
@@ -10,96 +9,54 @@ import { verifyStandaloneStatement } from "../verify/statement";
 
 const termNodeQuery = nodeQuery("/term!"),
       typeNodeQuery = nodeQuery("/type!"),
-      statementNodeQuery = nodeQuery("/statement!"),
-      nonTerminalNodeQuery = nodeQuery("/*");
+      statementNodeQuery = nodeQuery("/statement!");
 
 class StatementAsCombinatorVerifier extends Verifier {
-  verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead) {
-    let nonTerminalNodeVerified;
+  verify(statementNode, fileContext) {
+    let statementVerifiedAsCombinator;
 
-    const nodeQueryMaps = [
-      {
-        nodeQuery: termNodeQuery,
-        verify: (node, localContext, verifyAhead) => {
-          let nonTerminalNodeVerified;
+    const nonTerminalNode = statementNode, ///
+          childNodes = nonTerminalNode.getChildNodes(),
+          childNodesVerified = this.verifyChildNodes(childNodes, fileContext, () => {
+            const verifiedAhead = true;
 
-          const termNode = node, ///
-                termNodeVerified = this.verifyTermNode(termNode, localContext, verifyAhead);
+            return verifiedAhead;
+          });
 
-          nonTerminalNodeVerified = termNodeVerified; ///
+    statementVerifiedAsCombinator = childNodesVerified;  ///
 
-          return nonTerminalNodeVerified;
-        }
-      },
-      {
-        nodeQuery: typeNodeQuery,
-        verify: (node, localContext, verifyAhead) => {
-          let nonTerminalNodeVerified;
-
-          const typeNode = node, ///
-                typeNodeVerified = this.verifyTypeNode(typeNode, localContext, verifyAhead);
-
-          nonTerminalNodeVerified = typeNodeVerified; ///
-
-          return nonTerminalNodeVerified;
-        }
-      },
-      {
-        nodeQuery: statementNodeQuery,
-        verify: (node, localContext, verifyAhead) => {
-          let nonTerminalNodeVerified;
-
-          const statementNode = node, ///
-                statementNodeVerified = this.verifyStatementNode(statementNode, localContext, verifyAhead);
-
-          nonTerminalNodeVerified = statementNodeVerified; ///
-
-          return nonTerminalNodeVerified;
-        }
-      },
-      {
-        nodeQuery: nonTerminalNodeQuery,
-        verify: (node, localContext, verifyAhead) => {
-          let nonTerminalNodeVerified;
-
-          const nonTerminalNode = node; ///
-
-          nonTerminalNodeVerified =
-
-            super.verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead);
-
-          return nonTerminalNodeVerified;
-        }
-      }
-    ];
-
-    const nodeVerified = verify(nodeQueryMaps, nonTerminalNode, localContext, verifyAhead);
-
-    nonTerminalNodeVerified = nodeVerified; ///
-
-    return nonTerminalNodeVerified;
-  }
-
-  verifyStatementNode(statementNode, localContext, verifyAhead) {
-    const standaloneStatementVerified = verifyStandaloneStatement(statementNode, localContext, verifyAhead),
-          statementNodeVerified = standaloneStatementVerified;  ///
-
-    return statementNodeVerified;
-  }
-
-  verifyTermNode(termNode, localContext, verifyAhead) {
-    const standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
-          termNodeVerified = standaloneTermVerified;  ///
-
-    return termNodeVerified;
+    return statementVerifiedAsCombinator;
   }
 
-  verifyTypeNode(typeNode, localContext, verifyAhead) {
-    const standaloneTypeVerified = verifyStandaloneType(typeNode, localContext, verifyAhead),
-          typeNodeVerified = standaloneTypeVerified;  ///
+  static maps = [
+    {
+      nodeQuery: termNodeQuery,
+      verify: (termNode, localContext, verifyAhead) => {
+        const standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
+              termVerified = standaloneTermVerified;  ///
 
-    return typeNodeVerified;
-  }
+        return termVerified;
+      }
+    },
+    {
+      nodeQuery: typeNodeQuery,
+      verify: (typeNode, localContext, verifyAhead) => {
+        const standaloneTypeVerified = verifyStandaloneType(typeNode, localContext, verifyAhead),
+              typeVerified = standaloneTypeVerified;  ///
+
+        return typeVerified;
+      }
+    },
+    {
+      nodeQuery: statementNodeQuery,
+      verify: (statementNode, localContext, verifyAhead) => {
+        const standaloneStatementVerified = verifyStandaloneStatement(statementNode, localContext, verifyAhead),
+              statementVerified = standaloneStatementVerified;  ///
+
+        return statementVerified;
+      }
+    }
+  ];
 }
 
 const statementAsCombinatorVerifier = new StatementAsCombinatorVerifier();

package/src/verifier/termAsConstructor.js

@@ -1,83 +1,54 @@
 "use strict";
 
 import Verifier from "../verifier";
+import LocalContext from "../context/local";
 
-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("/*");
+      typeNodeQuery = nodeQuery("/type!");
 
 class TermAsConstructorVerifier extends Verifier {
-  verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead) {
-    let nonTerminalNodeVerified;
+  verify(termNode, fileContext) {
+    let termVerifiedAsConstructor;
 
-    const nodeQueryMaps = [
-      {
-        nodeQuery: termNodeQuery,
-        verify: (node, localContext, verifyAhead) => {
-          let nonTerminalNodeVerified;
+    const nonTerminalNode = termNode, ///
+          childNodes = nonTerminalNode.getChildNodes(),
+          childNodesVerified = this.verifyChildNodes(childNodes, fileContext, () => {
+            const verifiedAhead = true;
 
-          const termNode = node, ///
-            termNodeVerified = this.verifyTermNode(termNode, localContext, verifyAhead);
+            return verifiedAhead;
+          });
 
-          nonTerminalNodeVerified = termNodeVerified; ///
+    termVerifiedAsConstructor = childNodesVerified;  ///
 
-          return nonTerminalNodeVerified;
-        }
-      },
-      {
-        nodeQuery: typeNodeQuery,
-        verify: (node, localContext, verifyAhead) => {
-          let nonTerminalNodeVerified;
-
-          const typeNode = node, ///
-            typeNodeVerified = this.verifyTypeNode(typeNode, localContext, verifyAhead);
-
-          nonTerminalNodeVerified = typeNodeVerified; ///
-
-          return nonTerminalNodeVerified;
-        }
-      },
-      {
-        nodeQuery: nonTerminalNodeQuery,
-        verify: (node, localContext, verifyAhead) => {
-          let nonTerminalNodeVerified;
-
-          const nonTerminalNode = node; ///
-
-          nonTerminalNodeVerified =
-
-            super.verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead);
-
-          return nonTerminalNodeVerified;
-        }
-      }
-    ];
-
-    const nodeVerified = verify(nodeQueryMaps, nonTerminalNode, localContext, verifyAhead);
-
-    nonTerminalNodeVerified = nodeVerified; ///
-
-    return nonTerminalNodeVerified;
-  }
-
-  verifyTermNode(termNode, localContext, verifyAhead) {
-    const standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
-          termNodeVerified = standaloneTermVerified;  ///
-
-    return termNodeVerified;
+    return termVerifiedAsConstructor;
   }
 
-  verifyTypeNode(typeNode, localContext, verifyAhead) {
-    const standaloneTypeVerified = verifyStandaloneType(typeNode, localContext, verifyAhead),
-          typeNodeVerified = standaloneTypeVerified;  ///
+  static maps = [
+    {
+      nodeQuery: termNodeQuery,
+      verify: (termNode, fileContext, verifyAhead) => {
+        const localContext = LocalContext.fromFileContext(fileContext),
+              standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
+              termVerified = standaloneTermVerified;  ///
 
-    return typeNodeVerified;
-  }
+        return termVerified;
+      }
+    },
+    {
+      nodeQuery: typeNodeQuery,
+      verify: (typeNode, fileContext, verifyAhead) => {
+        const localContext = LocalContext.fromFileContext(fileContext),
+              standaloneTypeVerified = verifyStandaloneType(typeNode, localContext, verifyAhead),
+              typeVerified = standaloneTypeVerified;  ///
+
+        return typeVerified;
+      }
+    }
+  ];
 }
 
 const termAsConstructorVerifier = new TermAsConstructorVerifier();

package/src/verifier.js

@@ -1,6 +1,20 @@
 "use strict";
 
+import { nodeQuery } from "./utilities/query";
+
+const nonTerminalNodeQuery = nodeQuery("/*");
+
 export default class Verifier {
+  verify(node, ...remainingArguments) {
+    let verified;
+
+    const nodeVerified = this.verifyNode(node, ...remainingArguments);
+
+    verified = nodeVerified;  ///
+
+    return verified;
+  }
+
   verifyNode(node, ...remainingArguments) {
     let nodeVerified;
 
@@ -46,10 +60,40 @@ export default class Verifier {
   verifyNonTerminalNode(nonTerminalNode, ...remainingArguments) {
     let nonTerminalNodeVerified;
 
-    const childNodes = nonTerminalNode.getChildNodes(), ///
-          childNodesVerify = this.verifyChildNodes(childNodes, ...remainingArguments);
+    let { maps } = this.constructor;
+
+    maps = [ ///
+      ...maps,
+      {
+        nodeQuery: nonTerminalNodeQuery,
+        verify: (node, ...remainingArguments) => {
+          let nonTerminalNodeVerified;
+
+          const childNodes = nonTerminalNode.getChildNodes(), ///
+                childNodesVerify = this.verifyChildNodes(childNodes, ...remainingArguments);
+
+          nonTerminalNodeVerified = childNodesVerify; ///
+
+          return nonTerminalNodeVerified;
+        }
+      }
+    ]
+
+    let nodeVerified = false;
 
-    nonTerminalNodeVerified = childNodesVerify; ///
+    maps.some((map) => {
+      const { nodeQuery, verify } = map;
+
+      const node = nodeQuery(nonTerminalNode);
+
+      if (node !== null) {
+        nodeVerified = verify(node, ...remainingArguments);
+
+        return true;
+      }
+    });
+
+    nonTerminalNodeVerified = nodeVerified; ///
 
     return nonTerminalNodeVerified;
   }
@@ -82,21 +126,3 @@ export default class Verifier {
     return childNodesVerify;
   }
 }
-
-export function verify(nodeQueryMaps, nonTerminalNode, ...remainingArguments) {
-  let nodeVerified = false;
-
-  nodeVerified = nodeQueryMaps.some((nodeQueryMap) => {
-    const { nodeQuery, verify } = nodeQueryMap;
-
-    const node = nodeQuery(nonTerminalNode);
-
-    if (node !== null) {
-      nodeVerified = verify(node, ...remainingArguments);
-
-      return true;
-    }
-  });
-
-  return nodeVerified;
-}

package/src/verify/assertion/contained.js

@@ -84,11 +84,7 @@ function verifyStatedContainedAssertion(containedAssertionNode, assignments, der
     localContext.debug(`The '${containedAssertionString}' stated contained assertion cannot be verified.`, containedAssertionNode);
 
     const nonTerminalNode = containedAssertionNode, ///
-          nonTerminalNodeVerified = metaLevelVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
-            const verifiedAhead = true;
-
-            return verifiedAhead;
-          });
+          nonTerminalNodeVerified = metaLevelVerifier.verify(nonTerminalNode, localContext);
 
     statedContainedAssertionVerified = nonTerminalNodeVerified; ///
 

package/src/verify/assertion/defined.js

@@ -113,11 +113,7 @@ function verifyStatedDefinedAssertion(definedAssertionNode, assignments, derived
     localContext.trace(`Verifying the '${definedAssertionString}' stated defined assertion...`, definedAssertionNode);
 
     const nonTerminalNode = definedAssertionNode, ///
-          nonTerminalNodeVerified = metaLevelVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
-            const verifiedAhead = true;
-
-            return verifiedAhead;
-          });
+          nonTerminalNodeVerified = metaLevelVerifier.verify(nonTerminalNode, localContext);
 
     statedDefinedAssertionVerified = nonTerminalNodeVerified; ///
 

package/src/verify/statement/qualified.js

@@ -192,9 +192,9 @@ function verifyQualifiedStatementAAgainstReference(qualifiedStatementNode, subst
           localContextA = null,
           localContextB = localContext, ///
           statementNodeB = statementNode, ///
-          substitutionNode = null,
+          substitutionNodeA = null,
           metavariableNodeA = metavariableNode, ///
-          metavariableVerifiedAgainstStatement = unifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNode, substitutions, localContextA, localContextB, () => {
+          metavariableVerifiedAgainstStatement = unifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNodeA, substitutions, localContextA, localContextB, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;

package/src/verify/statement.js

@@ -13,16 +13,17 @@ import statementAgainstCombinatorUnifier from "../unifier/statementAgainstCombin
 import { nodeQuery } from "../utilities/query";
 import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 
-const variableNodeQuery = nodeQuery("/substitution/variable!"),
+const variableNodeQuery = nodeQuery("/*/variable!"),
       equalityNodeQuery = nodeQuery("/statement/equality!"),
       judgementNodeQuery = nodeQuery("/statement/judgement!"),
-      metavariableNodeQuery = nodeQuery("/statement/metavariable!"),
+      metavariableNodeQuery = nodeQuery("/*/metavariable!"),
       substitutionNodeQuery = nodeQuery("/statement/substitution!"),
-      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!"),
       termVariableNodeQuery = nodeQuery("/substitution/term/variable!"),
+      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!"),
       definedAssertionNodeQuery = nodeQuery("/statement/definedAssertion!"),
       subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion!"),
-      containedAssertionNodeQuery = nodeQuery("/statement/containedAssertion!");
+      containedAssertionNodeQuery = nodeQuery("/statement/containedAssertion!"),
+      statementMetavariableNodeQuery = nodeQuery("/substitution/statement/metavariable!");
 
 function verifyStatement(statementNode, assignments, derived, localContext) {
   let statementVerified;
@@ -311,16 +312,9 @@ function verifyStatementAgainstCombinator(statementNode, combinator, localContex
 
   localContext.trace(`Verifying the '${statementString}' statement against the '${combinatorString}' combinator...`, statementNode);
 
-  const combinatorStatementNode = combinator.getStatementNode(),
-        nonTerminalNodeA = statementNode, ///
-        nonTerminalNodeB = combinatorStatementNode, ///
-        nonTerminalNodeUnify = statementAgainstCombinatorUnifier.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, () => {
-          const verifiedAhead = true;
-
-          return verifiedAhead;
-        });
+  const combinatorStatementNode = combinator.getStatementNode();
 
-  statementVerifiedAgainstCombinator = nonTerminalNodeUnify;  ///
+  statementVerifiedAgainstCombinator = statementAgainstCombinatorUnifier.unify(statementNode, combinatorStatementNode, localContext);
 
   if (statementVerifiedAgainstCombinator) {
     localContext.debug(`...verified the '${statementString}' statement against the '${combinatorString}' combinator.`, statementNode);
@@ -352,15 +346,33 @@ function verifySubstitution(substitutionNode, localContext) {
     substitutionVerified = true;
   } else {
     const variableNode = variableNodeQuery(substitutionNode),
-          variablePresent = localContext.isVariablePresentByVariableNode(variableNode);
+          metavariableNode = metavariableNodeQuery(substitutionNode);
+
+    if (variableNode !== null) {
+      const variablePresent = localContext.isVariablePresentByVariableNode(variableNode);
+
+      if (variablePresent) {
+        const termVariableNode = termVariableNodeQuery(substitutionNode);
+
+        if (termVariableNode !== null) {
+          const termVariablePresent = localContext.isVariablePresentByVariableNode(termVariableNode);
+
+          substitutionVerified = termVariablePresent; ///
+        }
+      }
+    }
+
+    if (metavariableNode !== null) {
+      const metavariablePresent = localContext.isMetavariablePresentByMetavariableNode(metavariableNode);
 
-    if (variablePresent) {
-      const termVariableNode = termVariableNodeQuery(substitutionNode);
+      if (metavariablePresent) {
+        const statementMetavariableNode = statementMetavariableNodeQuery(substitutionNode);
 
-      if (termVariableNode !== null) {
-        const termVariablePresent = localContext.isVariablePresentByVariableNode(termVariableNode);
+        if (statementMetavariableNode !== null) {
+          const statementMetavariablePresent = localContext.isMetavariablePresentByMetavariableNode(statementMetavariableNode);
 
-        substitutionVerified = termVariablePresent; ///
+          substitutionVerified = statementMetavariablePresent; ///
+        }
       }
     }
   }

package/src/verify/statementAsCombinator.js

@@ -4,27 +4,19 @@ import Combinator from "../combinator";
 import statementAsCombinatorVerifier from "../verifier/statementAsCombinator";
 
 export default function verifyStatementAsCombinator(statementNode, fileContext) {
-  let statementVerifiedAsCombinator = false;
+  let statementVerifiedAsCombinator;
 
   const statementString = fileContext.nodeAsString(statementNode);
 
   fileContext.trace(`Verifying the '${statementString}' statement as a combinator....`, statementNode);
 
-  const nonTerminalNode = statementNode, ///
-        childNodes = nonTerminalNode.getChildNodes(),
-        childNodesVerified = statementAsCombinatorVerifier.verifyChildNodes(childNodes, fileContext, () => {
-          const verifiedAhead = true;
+  statementVerifiedAsCombinator = statementAsCombinatorVerifier.verify(statementNode, fileContext);
 
-          return verifiedAhead;
-        });
-
-  if (childNodesVerified) {
+  if (statementVerifiedAsCombinator) {
     const tokens = fileContext.getTokens(),
           combinator = Combinator.fromStatementNodeAndTokens(statementNode, tokens);
 
     fileContext.addCombinator(combinator);
-
-    statementVerifiedAsCombinator = true;
   }
 
   if (statementVerifiedAsCombinator) {