occam-verify-cli 0.0.951 → 0.0.955

package/src/context/release.js

@@ -4,15 +4,15 @@ import { lexersUtilities, parsersUtilities } from "occam-custom-grammars";
 
 import FileContext from "./file";
 
-import { push } from "../utilities/array";
 import { objectType } from "../type";
+import { tail, push, leftDifference } from "../utilities/array";
 import { customGrammarFromNameAndEntries, combinedCustomGrammarFromReleaseContexts } from "../utilities/customGrammar";
 
 const { florenceLexerFromCombinedCustomGrammar } = lexersUtilities,
       { florenceParserFromCombinedCustomGrammar } = parsersUtilities;
 
 export default class ReleaseContext {
-  constructor(log, json, name, entries, lexer, parser, verified, customGrammar, fileContexts, dependencyReleaseContexts) {
+  constructor(log, json, name, entries, lexer, parser, verified, fileContexts, customGrammar, loggingDisabled, dependencyReleaseContexts) {
     this.log = log;
     this.json = json;
     this.name = name;
@@ -20,8 +20,9 @@ export default class ReleaseContext {
     this.lexer = lexer;
     this.parser = parser;
     this.verified = verified;
-    this.customGrammar = customGrammar;
     this.fileContexts = fileContexts;
+    this.customGrammar = customGrammar;
+    this.loggingDisabled = loggingDisabled;
     this.dependencyReleaseContexts = dependencyReleaseContexts;
   }
 
@@ -53,18 +54,66 @@ export default class ReleaseContext {
     return this.verified;
   }
 
+  getFileContexts() {
+    return this.fileContexts;
+  }
+
   getCustomGrammar() {
     return this.customGrammar;
   }
 
-  getFileContexts() {
-    return this.fileContexts;
+  isLoggingDisabled() {
+    return this.loggingDisabled;
   }
 
   getDependencyReleaseContexts() {
     return this.dependencyReleaseContexts;
   }
 
+  setLog(log) {
+    this.log = log;
+  }
+
+  setJSON(json) {
+    this.json = json;
+  }
+
+  setName(name) {
+    this.name = name;
+  }
+
+  setEntries(entries) {
+    this.entries = entries;
+  }
+
+  setLexer(lexer) {
+    this.lexer = lexer;
+  }
+
+  setParser(parser) {
+    this.parser = parser;
+  }
+
+  setVerified(verified) {
+    this.verified = verified;
+  }
+
+  setFileContexts(fileContexts) {
+    this.fileContexts = fileContexts;
+  }
+
+  setCustomGrammar(customGrammar) {
+    this.customGrammar = customGrammar;
+  }
+
+  setLoggingDisabled(loggingDisabled) {
+    this.loggingDisabled = loggingDisabled;
+  }
+
+  setDependencyReleaseContexts(dependencyReleaseContexts) {
+    this.dependencyReleaseContexts = dependencyReleaseContexts;
+  }
+
   getLabels(includeDependencies = true) {
     const labels = [];
 
@@ -356,53 +405,87 @@ export default class ReleaseContext {
 
   matchShortenedVersion(shortenedVersion) { return this.entries.matchShortenedVersion(shortenedVersion); }
 
-  setVerified(verified) {
-    this.verified = verified;
+  disableLogging() {
+    const loggingDisabled = true;
+
+    this.setLoggingDisabled(loggingDisabled);
+  }
+
+  enableLogging() {
+    const loggingDisabled = false;
+
+    this.setLoggingDisabled(loggingDisabled);
   }
 
-  tokenise(content) { return this.lexer.tokenise(content); }
+  trace(message, node = null, tokens = null, filePath = null) {
+    if (this.loggingDisabled) {
+      return;
+    }
+
+    this.log.trace(message, node, tokens, filePath);
+  }
+
+  debug(message, node = null, tokens = null, filePath = null) {
+    if (this.loggingDisabled) {
+      return;
+    }
+
+    this.log.debug(message, node, tokens, filePath);
+  }
 
-  parse(tokens) { return this.parser.parse(tokens); }
+  info(message, node = null, tokens = null, filePath = null) {
+    if (this.loggingDisabled) {
+      return;
+    }
 
-  trace(message, node = null, tokens = null, filePath = null) { this.log.trace(message, node, tokens, filePath); }
+    this.log.info(message, node, tokens, filePath);
+  }
 
-  debug(message, node = null, tokens = null, filePath = null) { this.log.debug(message, node, tokens, filePath); }
+  warning(message, node = null, tokens = null, filePath = null) {
+    if (this.loggingDisabled) {
+      return;
+    }
 
-  info(message, node = null, tokens = null, filePath = null) { this.log.info(message, node, tokens, filePath); }
+    this.log.warning(message, node, tokens, filePath);
+  }
 
-  warning(message, node = null, tokens = null, filePath = null) { this.log.warning(message, node, tokens, filePath); }
+  error(message, node = null, tokens = null, filePath = null) {
+    if (this.loggingDisabled) {
+      return;
+    }
 
-  error(message, node = null, tokens = null, filePath = null) { this.log.error(message, node, tokens, filePath); }
+    this.log.error(message, node, tokens, filePath);
+  }
 
-  fatal(message, node = null, tokens = null, filePath = null) { this.log.fatal(message, node, tokens, filePath); }
+  fatal(message, node = null, tokens = null, filePath = null) {
+    if (this.loggingDisabled) {
+      return;
+    }
 
-  initialise(releaseContexts) {
-    releaseContexts = releaseContexts.slice();  ///
+    this.log.fatal(message, node, tokens, filePath);
+  }
 
+  verify(releaseContexts) {
     const combinedCustomGrammar = combinedCustomGrammarFromReleaseContexts(releaseContexts),
-          florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar),
-          florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar);
+          florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar),
+          florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar);
 
     this.lexer = florenceLexer; ///
 
     this.parser = florenceParser; ///
 
-    const releaseContext = releaseContexts.shift(),
-          dependencyReleaseContexts = releaseContexts;  ///
-
-    this.dependencyReleaseContexts = dependencyReleaseContexts;
+    this.dependencyReleaseContexts = tail(releaseContexts)
 
     if (this.json !== null) {
-      const fileContextsJSON = this.json; ///
+      const releaseContext = this;
 
-      fileContextsJSON.forEach((fileContextJSON) => {
-        const json = fileContextJSON, ///
-              fileContext = FileContext.fromJSONAndReleaseContext(json, releaseContext);
+      releaseContext.disableLogging();
 
-        fileContext.initialise(json);
+      this.fileContexts = fileContextsFromJSON(this.json, releaseContext);
 
-        this.fileContexts.push(fileContext);
-      });
+      verifyFileContexts(this.fileContexts, releaseContext);
+
+      releaseContext.enableLogging();
 
       this.verified = true;
     }
@@ -423,11 +506,59 @@ export default class ReleaseContext {
     const lexer = null,
           parser = null,
           verified = false,
-          customGrammar = customGrammarFromNameAndEntries(name, entries),
           fileContexts = [],
+          customGrammar = customGrammarFromNameAndEntries(name, entries),
+          loggingDisabled = false,
           dependencyReleaseContexts = null,
-          releaseContext = new ReleaseContext(log, json, name, entries, lexer, parser, verified, customGrammar, fileContexts, dependencyReleaseContexts);
+          releaseContext = new ReleaseContext(log, json, name, entries, lexer, parser, verified, fileContexts, customGrammar, loggingDisabled, dependencyReleaseContexts);
 
     return releaseContext;
   }
-}
+}
+
+function verifyFileContexts(fileContexts, releaseContext) {
+  fileContexts = [  ///
+    ...fileContexts
+  ];
+
+  for (;;) {
+    const fileContextsLength = fileContexts.length;
+
+    if (fileContextsLength === 0) {
+      break;
+    }
+
+    const verifiedFileContexts = [];
+
+    fileContexts.forEach((fileContext) => {
+      const verified = fileContext.verify(releaseContext);
+
+      if (verified) {
+        const verifiedFileContext = fileContext;  ///
+
+        verifiedFileContexts.push(verifiedFileContext);
+      }
+    });
+
+    const verifiedFileContextsLength = verifiedFileContexts.length,
+          fileVerified = (verifiedFileContextsLength > 0);
+
+    if (!fileVerified) {
+      break;
+    }
+
+    leftDifference(fileContexts, verifiedFileContexts);
+  }
+}
+
+function fileContextsFromJSON(json, releaseContext) {
+  const fileContextsJSON = json, ///
+        fileContexts = fileContextsJSON.map((fileContextJSON) => {
+          const json = fileContextJSON, ///
+                fileContext = FileContext.fromJSONAndReleaseContext(json, releaseContext);
+
+          return fileContext;
+        });
+
+  return fileContexts;
+}

package/src/declaration.js

@@ -16,23 +16,23 @@ export default class Declaration {
     return this.statementNode;
   }
 
-  matchSubstitution(substitution) {
+  unifySubstitution(substitution) {
     const statementNode = substitution.getStatementNode(),
           metavariableNode = substitution.getMetavariableNode(),
-          matchesStatementNode = this.matchStatementNode(statementNode),
-          matchesMetavariableNode = this.matchMetavariableNode(metavariableNode),
-          matchesSubstitution = (matchesMetavariableNode && matchesStatementNode);
+          statementUnified = this.unifyStatement(statementNode),
+          metavariableUnified = this.unifyMetavariable(metavariableNode),
+          substitutionUnified = (metavariableUnified && statementUnified);
 
-    return matchesSubstitution;
+    return substitutionUnified;
   }
 
-  matchMetavariableNode(metavariableNode) {
+  unifyMetavariable(metavariableNode) {
     const matchesMetavariableNode = this.metavariableNode.match(metavariableNode);
 
     return matchesMetavariableNode;
   }
 
-  matchStatementNode(statementNode) {
+  unifyStatement(statementNode) {
     const statementNodeA = statementNode, ///
           statementNodeB = this.statementNode,  ///
           statementMatches = matchStatementModuloBrackets(statementNodeA, statementNodeB),
@@ -41,13 +41,13 @@ export default class Declaration {
     return matchesStatementNode;
   }
 
-  matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem) {
+  unifyMetaLemmaOrMetatheorem(metaLemmaMetatheorem) {
     const consequent = metaLemmaMetatheorem.getConsequent(),
           statementNode = consequent.getStatementNode(),
           matches = this.statementNode.match(statementNode),
-          matchesMetaLemmaOrMetaTheorem = matches;  ///
+          metaLemmaOrMetaTheoremUnified = matches;  ///
 
-    return matchesMetaLemmaOrMetaTheorem;
+    return metaLemmaOrMetaTheoremUnified;
   }
 
   static fromMetavariableNodeAndStatementNode(metavariableNode, statementNode) {

package/src/frame.js

@@ -36,29 +36,30 @@ export default class Frame {
     push(this.declarations, declarations);
   }
 
-  matchSubstitution(substitution) {
-    const matchesSubstitution = this.declarations.some((declaration) => {
-      const declarationMatchesSubstitution = declaration.matchSubstitution(substitution);
+  unifySubstitution(substitution) {
+    const substitutionUnified = this.declarations.some((declaration) => {
+      const substitutionUnifiedAgainstDeclaration = declaration.unifySubstitution(substitution);
 
-      if (declarationMatchesSubstitution) {
+      if (substitutionUnifiedAgainstDeclaration) {
         return true;
       }
     });
 
-    return matchesSubstitution;
+    return substitutionUnified;
   }
 
-  matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem) {
+  unifyMetaLemmaOrMetaTheorem(metaLemmaMetatheorem) {
     const substitutions = metaLemmaMetatheorem.getSubstitutions(),
-          matchesMetaLemmaOrMetaTheorem = substitutions.everySubstitution((substitution) => {
-            const frameMatchesSubstitution = this.matchSubstitution(substitution);
+          substitutionsUnified = substitutions.everySubstitution((substitution) => {
+            const substitutionUnified = this.unifySubstitution(substitution);
 
-            if (frameMatchesSubstitution) {
+            if (substitutionUnified) {
               return true;
             }
-          });
+          }),
+          metaLemmaOrMetaTheoremUnified = substitutionsUnified; ///
 
-    return matchesMetaLemmaOrMetaTheorem;
+    return metaLemmaOrMetaTheoremUnified;
   }
 
   static fromDeclarations(declarations) {

package/src/index.js

@@ -1,11 +1,9 @@
 "use strict";
 
 export { default as Log } from "./log";
-
 export { default as verifyRelease } from "./verify/release";
 export { default as ReleaseContext } from "./context/release";
-
+export { default as createReleaseContext } from "./releaseContext/create";
+export { default as verifyReleaseContext } from "./releaseContext/verify";
 export { default as customGrammarUtilities } from "./utilities/customGrammar";
 
-export { default as createReleaseContext } from "./releaseContext/create";
-export { default as initialiseReleaseContext } from "./releaseContext/initialise";

package/src/judgement.js

@@ -27,7 +27,7 @@ export default class Judgement {
     return matchesMetavariableNode;
   }
 
-  matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem) { return this.frame.matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem); }
+  unifyMetaLemmaOrmetatheorem(metaLemmaMetatheorem) { return this.frame.unifyMetaLemmaOrmetatheorem(metaLemmaMetatheorem); }
 
   static fromJudgementNodeFrameAndMetavariableNode(judgementNode, frame, metavariableNode) {
     const node = judgementNode,

package/src/metavariable.js

@@ -65,9 +65,9 @@ export default class Metavariable {
         } else if ((termNode === null) && (this.termType === null)) {
           matchesNode = true;
         } else if ((termNode !== null) && (this.termType !== null)) {
-          const termVerifiedAgainstTermType = verifyTermAgainstTermType(termNode, this.termType, localContext);
+          const termUnifiedAgainstTermType = unifyTermAgainstTermType(termNode, this.termType, localContext);
 
-          matchesNode = termVerifiedAgainstTermType;  ///
+          matchesNode = termUnifiedAgainstTermType;  ///
         }
       }
     }
@@ -128,28 +128,29 @@ export default class Metavariable {
   }
 }
 
-export function verifyTermAgainstTermType(termNode, termType, localContext) {
-  let termVerifiedAgainstTermType;
+export function unifyTermAgainstTermType(termNode, termType, localContext) {
+  let termUnifiedAgainstTermType;
 
   const type = termType,  ///
-        terms = [];
+        terms = [],
+        termVerified = verifyTerm(termNode, terms, localContext, () => {
+          let verifiedAhead = false;
 
-  termVerifiedAgainstTermType = verifyTerm(termNode, terms, localContext, () => {
-    let verifiedAhead = false;
+          const firstTerm = first(terms),
+                term = firstTerm, ///
+                termType = term.getType(),
+                termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);
 
-    const firstTerm = first(terms),
-          term = firstTerm, ///
-          termType = term.getType(),
-          termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);
+          if (termTypeEqualToOrSubTypeOfType) {
+            verifiedAhead = true;
+          }
 
-    if (termTypeEqualToOrSubTypeOfType) {
-      verifiedAhead = true;
-    }
+          return verifiedAhead;
+        });
 
-    return verifiedAhead;
-  });
+  termUnifiedAgainstTermType = termVerified;  ///
 
-  return termVerifiedAgainstTermType;
+  return termUnifiedAgainstTermType;
 }
 
 function termTypeFromMetavariableNode(metavariableNode, fileContext) {

package/src/releaseContext/{initialise.js → verify.js}

@@ -1,6 +1,6 @@
 "use strict";
 
-export default function initialiseReleaseContext(dependency, dependentName, dependentReleased, context) {
+export default function verifyReleaseContext(dependency, dependentName, dependentReleased, context) {
   let releaseContextInitialised = false;
 
   const { releaseContextMap } = context,
@@ -11,11 +11,11 @@ export default function initialiseReleaseContext(dependency, dependentName, depe
   if (releaseContext === null) {
     const { log } = context;
 
-    log.error(`Unable to initialise the '${dependencyName}' dependency's context because it has not been created.`);
+    log.error(`Unable to verify the '${dependencyName}' dependency's context because it has not been created.`);
   } else {
-    const initialised = releaseContext.isInitialised();
+    const verified = releaseContext.isInitialised();
 
-    if (initialised) {
+    if (verified) {
       releaseContextInitialised = true;
     } else {
       const released = releaseContext.isReleased();
@@ -23,7 +23,7 @@ export default function initialiseReleaseContext(dependency, dependentName, depe
       if (!released && dependentReleased) {
         const { log } = context;
 
-        log.error(`Unable to initialise the '${dependencyName}' dependency's context because its '${dependentName}' dependent is a package.`);
+        log.error(`Unable to verify the '${dependencyName}' dependency's context because its '${dependentName}' dependent is a package.`);
       } else {
         const dependencies = releaseContext.getDependencies();
 
@@ -32,7 +32,7 @@ export default function initialiseReleaseContext(dependency, dependentName, depe
         dependentReleased = released;  ///
 
         releaseContextInitialised = dependencies.everyDependency((dependency) => {  ///
-          const releaseContextInitialised = initialiseReleaseContext(dependency, dependentName, dependentReleased, context);
+          const releaseContextInitialised = verifyReleaseContext(dependency, dependentName, dependentReleased, context);
 
           if (releaseContextInitialised) {
             return true;
@@ -42,7 +42,7 @@ export default function initialiseReleaseContext(dependency, dependentName, depe
         if (releaseContextInitialised) {
           const releaseContexts = retrieveReleaseContexts(releaseContext, releaseContextMap);
 
-          releaseContext.initialise(releaseContexts);
+          releaseContext.verify(releaseContexts);
         }
       }
     }

package/src/substitution/statementForMetavariable.js

@@ -38,14 +38,14 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return node;
   }
 
-  matchStatementNode(statementNode, substitutions, localContextA, localContextB) {
+  unifyStatement(statementNode, substitutions, localContextA, localContextB) {
     let statementNodeMatches;
 
     const substitution = this.substitution, ///
           statementNodeA = statementNode,  ///
           statementNodeB = this.statementNode; ///
 
-    statementNodeMatches = matchStatementNode(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB);
+    statementNodeMatches = unifyStatement(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB);
 
     if (!statementNodeMatches) {
       const bracketedStatementChildNode = bracketedStatementChildNodeFromStatementNode(statementNode);
@@ -53,7 +53,7 @@ export default class StatementForMetavariableSubstitution extends Substitution {
       if (bracketedStatementChildNode !== null) {
         const statementNodeA = bracketedStatementChildNode; ///
 
-        statementNodeMatches = matchStatementNode(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB);
+        statementNodeMatches = unifyStatement(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB);
       }
     }
 
@@ -153,19 +153,18 @@ export default class StatementForMetavariableSubstitution extends Substitution {
   }
 }
 
-function matchStatementNode(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB) {
-  let statementNodeMatches;
+function unifyStatement(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB) {
+  let statementUnified;
 
   if (substitution === null) {
     const statementNodeAMatchesStatementNodeB = statementNodeB.match(statementNodeA);
 
-    statementNodeMatches = statementNodeAMatchesStatementNodeB; ///
+    statementUnified = statementNodeAMatchesStatementNodeB; ///
   } else {
-    const statementVerifiedAgainstStatement = unifyStatementAgainstStatement(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB);
+    const statementUnifiedAgainstStatement = unifyStatementAgainstStatement(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB);
 
-    statementNodeMatches = statementVerifiedAgainstStatement; ///
+    statementUnified = statementUnifiedAgainstStatement; ///
   }
 
-  return statementNodeMatches;
-
+  return statementUnified;
 }

package/src/unifier/equality.js

@@ -25,14 +25,14 @@ class EqualityUnifier extends Unifier {
       nodeQueryA: termNodeQuery,
       nodeQueryB: termNodeQuery,
       unify: (termNodeA, termNodeB, localContext) => {
-        let termVerifiedAgainstTerm;
+        let termUnifiedAgainstTerm;
 
         const leftTermNode = termNodeA, ///
               rightTermNode = termNodeB;  ///
 
-        termVerifiedAgainstTerm = unifyTermAgainstTerm(leftTermNode, rightTermNode, localContext);
+        termUnifiedAgainstTerm = unifyTermAgainstTerm(leftTermNode, rightTermNode, localContext);
 
-        if (!termVerifiedAgainstTerm) {
+        if (!termUnifiedAgainstTerm) {
           const nonTerminalNodeA = termNodeA, ///
                 nonTerminalNodeB = termNodeB, ///
                 nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
@@ -41,10 +41,10 @@ class EqualityUnifier extends Unifier {
                 childNodesB = nonTerminalNodeBChildNodes, ///
                 childNodesVerified = equalityUnifier.unifyChildNodes(childNodesA, childNodesB, localContext);
 
-          termVerifiedAgainstTerm = childNodesVerified; ///
+          termUnifiedAgainstTerm = childNodesVerified; ///
         }
 
-        return termVerifiedAgainstTerm;
+        return termUnifiedAgainstTerm;
       }
     }
   ];

package/src/unifier/metaLevel.js

@@ -31,7 +31,7 @@ class MetaLevelUnifier extends Unifier {
       nodeQueryA: statementNodeQuery,
       nodeQueryB: statementNodeQuery,
       unify: (statementNodeA, statementNodeB, substitutions, localContextA, localContextB) => {
-        let statementVerifiedAgainstStatement;
+        let statementUnifiedAgainstStatement;
 
         const metavariableNodeA = metavariableNodeQuery(statementNodeA);
 
@@ -39,7 +39,7 @@ class MetaLevelUnifier extends Unifier {
           const substitutionNodeA = substitutionNodeQuery(statementNodeA),
                 metavariableUnifiedAgainstStatement = unifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNodeA, substitutions, localContextA, localContextB);
 
-          statementVerifiedAgainstStatement = metavariableUnifiedAgainstStatement;  ///
+          statementUnifiedAgainstStatement = metavariableUnifiedAgainstStatement;  ///
         } else {
           const nonTerminalNodeA = statementNodeA, ///
                 nonTerminalNodeB = statementNodeB, ///
@@ -49,10 +49,10 @@ class MetaLevelUnifier extends Unifier {
                 childNodesB = nonTerminalNodeBChildNodes, ///
                 childNodesVerified = metaLevelUnifier.unifyChildNodes(childNodesA, childNodesB, substitutions, localContextA, localContextB);
 
-          statementVerifiedAgainstStatement = childNodesVerified; ///
+          statementUnifiedAgainstStatement = childNodesVerified; ///
         }
 
-        return statementVerifiedAgainstStatement;
+        return statementUnifiedAgainstStatement;
       }
     },
     {

package/src/unify/statementAgainstMetaType.js

@@ -9,7 +9,7 @@ const metavariableNodeQuery = nodeQuery("/statement/metavariable"),
       metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type!");
 
 export default function unifyStatementAgainstMetaType(statementNode, metaTypeNode, localContext) {
-  let statementVerifiedAgainstMetaType = false;
+  let statementUnifiedAgainstMetaType = false;
 
   const metaTypeTerminalNode = metaTypeTerminalNodeQuery(metaTypeNode),
         metaTypeTerminalNodeContent = metaTypeTerminalNode.getContent(),
@@ -26,7 +26,7 @@ export default function unifyStatementAgainstMetaType(statementNode, metaTypeNod
           const metavariableMetaTypeName = metavariable.getMetaTypeName();
 
           if (metavariableMetaTypeName === metaTypeName) {
-            statementVerifiedAgainstMetaType = true;
+            statementUnifiedAgainstMetaType = true;
           }
         }
       }
@@ -40,11 +40,11 @@ export default function unifyStatementAgainstMetaType(statementNode, metaTypeNod
             assignments = [],
             statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
 
-      statementVerifiedAgainstMetaType = statementVerified;
+      statementUnifiedAgainstMetaType = statementVerified;
 
       break;
     }
   }
 
-  return statementVerifiedAgainstMetaType;
+  return statementUnifiedAgainstMetaType;
 }

package/src/utilities/array.js

@@ -2,7 +2,7 @@
 
 import { arrayUtilities } from "necessary";
 
-export const { first, second, last, extract, push, match, prune, filter, compress, separate } = arrayUtilities;
+export const { first, second, last, extract, tail, push, match, prune, filter, compress, separate } = arrayUtilities;
 
 export function reverse(array) {
   array = [ ///

package/src/verify/judgement.js

@@ -70,10 +70,10 @@ function verifyDerivedJudgement(judgementNode, assignments, derived, localContex
                   metaLemmaMetatheorem = (metaLemma || metatheorem);  ///
 
             if (metaLemmaMetatheorem !== null) {
-              const declarationMatchesMetaLemmaMetatheorem = declaration.matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem),
-                    judgementMatchesMetaLemmaMetatheorem = judgement.matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem);
+              const metaLemmaMetatheoremUnifiedAgainstDeclaration = declaration.unifyMetaLemmaOrMetaTheorem(metaLemmaMetatheorem),
+                    metaLemmaMetatheoremUnifiedAgainstJudgement = judgement.unifyMetaLemmaOrMetaTheorem(metaLemmaMetatheorem);
 
-              derivedJudgementVerified = (declarationMatchesMetaLemmaMetatheorem && judgementMatchesMetaLemmaMetatheorem);
+              derivedJudgementVerified = (metaLemmaMetatheoremUnifiedAgainstDeclaration && metaLemmaMetatheoremUnifiedAgainstJudgement);
             } else {
               const metavariableString = localContext.nodeAsString(metavariableNode);