occam-verify-cli 1.0.405 → 1.0.415

package/src/utilities/unification.js

@@ -1,136 +0,0 @@
-"use string";
-
-import TemporaryContext from "../context/temporary";
-import metaLevelUnifier from "../unifier/metaLevel";
-import metavariableUnifier from "../unifier/metavariable";
-import intrinsicLevelUnifier from "../unifier/intrinsicLevel";
-import termWithConstructorUnifier from "../unifier/termWithConstructor";
-import statementWithCombinatorUnifier from "../unifier/statementWithCombinator";
-
-export function unifyStatement(generalStatement, specificStatement, substitutions, generalContext, specificContext) {
-  let statementUnifies = false;
-
-  const generalStatementNode = generalStatement.getNode(),
-        specificStatementNode = specificStatement.getNode(),
-        generalNonTerminalNode = generalStatementNode, ///
-        specificNonTerminalNode = specificStatementNode,  ///
-        unifiesAtMetaLevel = metaLevelUnifier.unify(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext);
-
-  if (unifiesAtMetaLevel) {
-    statementUnifies = true;
-  }
-
-  return statementUnifies;
-}
-
-export function unifySubstitution(generalSubstitution, specificSubstitution, substitutions, generalContext, specificContext) {
-  let substitutionUnifies = false;
-
-  const generalSubstitutionNode = generalSubstitution.getNode(),
-        specificSubstitutionNode = specificSubstitution.getNode(),
-        generalNonTerminalNode = generalSubstitutionNode, ///
-        specificNonTerminalNode = specificSubstitutionNode,
-        unifiesAtMetaLevel = metaLevelUnifier.unify(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext);
-
-  if (unifiesAtMetaLevel) {
-    substitutionUnifies = true;
-  }
-
-  return substitutionUnifies;
-}
-
-export function unifyMetavariable(generalMetavariable, specificMetavariable, generalContext, specificContext) {
-  let metavariableUnifies;
-
-  const generalMetavariableNode = generalMetavariable.getNode(),
-        specificMetavariableNode = specificMetavariable.getNode(),
-        generalMetavariableTokens = generalMetavariable.getTokens(),
-        specificMetavariableTokens = specificMetavariable.getTokens();
-
-  generalContext = contextFromTokens(generalMetavariableTokens, generalContext); ///
-
-  specificContext = contextFromTokens(specificMetavariableTokens, specificContext); ///
-
-  metavariableUnifies = metavariableUnifier.unify(generalMetavariableNode, specificMetavariableNode, generalContext, specificContext);
-
-  return metavariableUnifies;
-}
-
-export function unifyTermWithConstructor(term, constructor, context) {
-  let termUnifiesWithConstructor;
-
-  const termNode = term.getNode(),
-        constructorTerm = constructor.getTerm(),
-        constructorTermNode = constructorTerm.getNode();
-
-  termUnifiesWithConstructor = termWithConstructorUnifier.unify(constructorTermNode, termNode, context);
-
-  return termUnifiesWithConstructor;
-}
-
-export function unifyStatementIntrinsically(generalStatement, specificStatement, substitutions, generalContext, specificContext) {
-  let metavariableUnifiesIntrinsically;
-
-  const generalStatementNode = generalStatement.getNode(),
-        specificStatementNode = specificStatement.getNode(),
-        generalStatementTokens = generalStatement.getTokens(),
-        specificStatementTokens = specificStatement.getTokens();
-
-  generalContext = contextFromTokens(generalStatementTokens, generalContext); ///
-
-  specificContext = contextFromTokens(specificStatementTokens, specificContext); ///
-
-  const generalNonTerminalNode = generalStatementNode, ///
-        specificNonTerminalNode = specificStatementNode; ///
-
-  metavariableUnifiesIntrinsically = intrinsicLevelUnifier.unify(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext);
-
-  return metavariableUnifiesIntrinsically;
-}
-
-export function unifyStatementWithCombinator(statement, combinator, assignments, stated, context) {
-  let statementUnifiesWithCombinator;
-
-  const statementNode = statement.getNode(),
-        combinatorStatement = combinator.getStatement(),
-        combinatorStatementNode = combinatorStatement.getNode(),
-        combinatorStatementTokens = combinatorStatement.getTokens();
-
-  const specificContext = context;  ///
-
-  context = contextFromTokens(combinatorStatementTokens, context);  ///
-
-  const generalContext = context; ///
-
-  statementUnifiesWithCombinator = statementWithCombinatorUnifier.unify(combinatorStatementNode, statementNode, assignments, stated, generalContext, specificContext);
-
-  return statementUnifiesWithCombinator;
-}
-
-export function unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, substitutions, generalContext, specificContext) {
-  let metavariableUnifiesIntrinsically;
-
-  const generalMetavariableNode = generalMetavariable.getNode(),
-        specificMetavariableNode = specificMetavariable.getNode(),
-        generalMetavariableTokens = generalMetavariable.getTokens(),
-        specificMetavariableTokens = specificMetavariable.getTokens();
-
-  generalContext = contextFromTokens(generalMetavariableTokens, generalContext); ///
-
-  specificContext = contextFromTokens(specificMetavariableTokens, specificContext); ///
-
-  const generalNonTerminalNode = generalMetavariableNode, ///
-        specificNonTerminalNode = specificMetavariableNode; ///
-
-  metavariableUnifiesIntrinsically = intrinsicLevelUnifier.unify(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext);
-
-  return metavariableUnifiesIntrinsically;
-}
-
-function contextFromTokens(tokens, context) {
-  const temporaryContext = TemporaryContext.fromContextAndTokens(context, tokens);
-
-  context = temporaryContext;  ///
-
-  return context;
-}

package/src/utilities/variable.js

@@ -1,13 +0,0 @@
-"use strict";
-
-import { nodeQuery } from "../utilities/query";
-
-const termVariableIdentifierNodeQuery = nodeQuery("/term/variable!/@identifier!");
-
-export function termVariableIdentifierFromTermNode(TermNode) {
-  const termVariableIdentifierTerminalNode = termVariableIdentifierNodeQuery(TermNode),
-        termVariableIdentifierTerminalNodeContent = termVariableIdentifierTerminalNode.getContent(),
-        termVariableIdentifier = termVariableIdentifierTerminalNodeContent; ///
-
-  return termVariableIdentifier;
-}

package/src/verifier/combinator.js

@@ -1,72 +0,0 @@
-"use strict";
-
-import ontology from "../ontology";
-import Verifier from "../verifier";
-
-import { nodeQuery } from "../utilities/query";
-
-const termNodeQuery = nodeQuery("/term"),
-      typeNodeQuery = nodeQuery("/type"),
-      statementNodeQuery = nodeQuery("/statement");
-
-class CombinatorVerifier extends Verifier {
-  verifyStatement(statementNode, context) {
-    let statementVerifiesAsCombinator;
-
-    const nonTerminalNode = statementNode, ///
-          childNodes = nonTerminalNode.getChildNodes(),
-          childNodesVerify = this.verifyChildNodes(childNodes, context);
-
-    statementVerifiesAsCombinator = childNodesVerify;  ///
-
-    return statementVerifiesAsCombinator;
-  }
-
-  static maps = [
-    {
-      nodeQuery: statementNodeQuery,
-      verify: (statementNode, context) => {
-        const { Statement } = ontology,
-              statement = Statement.fromStatementNode(statementNode, context),
-              assignments = null,
-              stated = false,
-              statementVerifies = statement.verify(assignments, stated, context);
-
-        return statementVerifies;
-      }
-    },
-    {
-      nodeQuery: termNodeQuery,
-      verify: (termNode, context) => {
-        const { Term } = ontology,
-              term = Term.fromTermNode(termNode, context),
-              termVerifies = term.verify(context, () => {
-                const verifiesAhead = true;
-
-                return verifiesAhead;
-              });
-
-        return termVerifies;
-      }
-    },
-    {
-      nodeQuery: typeNodeQuery,
-      verify: (typeNode, context) => {
-        let typeVerifies = false;
-
-        const nominalTypeName = typeNode.getNominalTypeName(),
-              typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);
-
-        if (typePresent) {
-          typeVerifies = true;
-        }
-
-        return typeVerifies;
-      }
-    }
-  ];
-}
-
-const combinatorVerifier = new CombinatorVerifier();
-
-export default combinatorVerifier;

package/src/verifier/constructor.js

@@ -1,96 +0,0 @@
-"use strict";
-
-import { arrayUtilities } from "necessary";
-
-import ontology from "../ontology";
-import Verifier from "../verifier";
-
-import { nodeQuery } from "../utilities/query";
-import { TYPE_TYPE } from "../constants";
-
-const { last } = arrayUtilities;
-
-const termNodeQuery = nodeQuery("/term"),
-      typeNodeQuery = nodeQuery("/type");
-
-class ConstructorVerifier extends Verifier {
-  verifyTerm(termNode, context) {
-    let termVerifiesAsConstructor;
-
-    const nonTerminalNode = termNode, ///
-          childNodes = nonTerminalNode.getChildNodes(),
-          childNodesVerify = this.verifyChildNodes(childNodes, context, () => {
-            const verifiesAhead = true;
-
-            return verifiesAhead;
-          });
-
-    termVerifiesAsConstructor = childNodesVerify;  ///
-
-    return termVerifiesAsConstructor;
-  }
-
-  verifyTerminalNode(terminalNode, ...remainingArguments) {
-    let terminalNodeVerifies;
-
-    const type = terminalNode.getType();
-
-    if (type === TYPE_TYPE) {
-      const verifyAhead = remainingArguments.pop(), ///
-            lastRemainingArgument = last(remainingArguments),
-            context = lastRemainingArgument,  ///
-            content = terminalNode.getContent(),
-            typeString = content; ///
-
-      context.debug(`The '${typeString}' type is present in the constructor but has not been declared beforehand.`);
-
-      terminalNodeVerifies = false;
-
-      remainingArguments.push(verifyAhead);
-    } else {
-      terminalNodeVerifies = super.verifyTerminalNode(terminalNode, ...remainingArguments);
-    }
-
-    return terminalNodeVerifies;
-  }
-
-  static maps = [
-    {
-      nodeQuery: termNodeQuery,
-      verify: (termNode, context, verifyAhead) => {
-        const { Term } = ontology,
-              term = Term.fromTermNode(termNode, context),
-              termVerifies = term.verify(context, verifyAhead);
-
-        return termVerifies;
-      }
-    },
-    {
-      nodeQuery: typeNodeQuery,
-      verify: (typeNode, context, verifyAhead) => {
-        let typeVerifies;
-
-        const nominalTypeName = typeNode.getNominalTypeName(),
-              typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);
-
-        if (typePresent) {
-          const verifiesAhead = verifyAhead();
-
-          typeVerifies = verifiesAhead; ///
-        } else {
-          const typeString = nominalTypeName; ///
-
-          context.debug(`The '${typeString}' type is not present.`);
-
-          typeVerifies = false;
-        }
-
-        return typeVerifies;
-      }
-    }
-  ];
-}
-
-const constructorVerifier = new ConstructorVerifier();
-
-export default constructorVerifier;

package/src/verifier/topLevel.js

@@ -1,204 +0,0 @@
-"use strict";
-
-import ontology from "../ontology";
-import Verifier from "../verifier";
-
-import { nodeQuery } from "../utilities/query";
-
-const errorNodeQuery = nodeQuery("/error"),
-      ruleNodeQuery = nodeQuery("/rule"),
-      axiomNodeQuery = nodeQuery("/axiom"),
-      lemmaNodeQuery = nodeQuery("/lemma"),
-      sectionNodeQuery = nodeQuery("/section"),
-      theoremNodeQuery = nodeQuery("/theorem"),
-      metaLemmaNodeQuery = nodeQuery("/metaLemma"),
-      conjectureNodeQuery = nodeQuery("/conjecture"),
-      metatheoremNodeQuery = nodeQuery("/metatheorem"),
-      variableDeclarationNodeQuery = nodeQuery("/variableDeclaration"),
-      combinatorDeclarationNodeQuery = nodeQuery("/combinatorDeclaration"),
-      simpleTypeDeclarationNodeQuery = nodeQuery("/simpleTypeDeclaration"),
-      typePrefixDeclarationNodeQuery = nodeQuery("/typePrefixDeclaration"),
-      constructorDeclarationNodeQuery = nodeQuery("/constructorDeclaration"),
-      complexTypeDeclarationNodeQuery = nodeQuery("/complexTypeDeclaration"),
-      metavariableDeclarationNodeQuery = nodeQuery("/metavariableDeclaration");
-
-class TopLevelVerifier extends Verifier {
-  verify(node, fileContext) {
-    let verifiesAtTopLevel;
-
-    const context = fileContext,  ///
-          nonTerminalNode = node, ///
-          nonTerminalNodeVerifies = this.verifyNonTerminalNode(nonTerminalNode, context);
-
-    verifiesAtTopLevel = nonTerminalNodeVerifies;  ///
-
-    return verifiesAtTopLevel;
-  }
-
-  static maps = [
-    {
-      nodeQuery: errorNodeQuery,
-      verify: (errorNode, context) => {
-        const { Error } = ontology,
-              error = Error.fromErrorNode(errorNode, context),
-              errorVerifies = error.verify();
-
-        return errorVerifies;
-      }
-    },
-    {
-      nodeQuery: ruleNodeQuery,
-      verify: (ruleNode, context) => {
-        const { Rule } = ontology,
-              rule = Rule.fromRuleNode(ruleNode, context),
-              ruleVerifies = rule.verify();
-
-        return ruleVerifies;
-      }
-    },
-    {
-      nodeQuery: axiomNodeQuery,
-      verify: (axiomNode, context) => {
-        const { Axiom } = ontology,
-              axiom = Axiom.fromAxiomNode(axiomNode, context),
-              axiomVerifies = axiom.verify();
-
-        return axiomVerifies;
-      }
-    },
-    {
-      nodeQuery: lemmaNodeQuery,
-      verify: (lemmaNode, context) => {
-        const { Lemma } = ontology,
-              lemma = Lemma.fromLemmaNode(lemmaNode, context),
-              lemmaVerifies = lemma.verify();
-
-        return lemmaVerifies;
-      }
-    },
-    {
-      nodeQuery: sectionNodeQuery,
-      verify: (sectionNode, context) => {
-        const { Section } = ontology,
-              section = Section.fromSectionNode(sectionNode, context),
-              sectionVerifies = section.verify();
-
-        return sectionVerifies;
-      }
-    },
-    {
-      nodeQuery: theoremNodeQuery,
-      verify: (theoremNode, context) => {
-        const { Theorem } = ontology,
-              theorem = Theorem.fromTheoremNode(theoremNode, context),
-              theoremVerifies = theorem.verify();
-
-        return theoremVerifies;
-      }
-    },
-    {
-      nodeQuery: metaLemmaNodeQuery,
-      verify: (metaLemmaNode, context) => {
-        const { MetaLemma } = ontology,
-              metaLemma = MetaLemma.fromMetaLemmaNode(metaLemmaNode, context),
-              metaLemmaVerifies = metaLemma.verify();
-
-        return metaLemmaVerifies;
-      }
-    },
-    {
-      nodeQuery: conjectureNodeQuery,
-      verify: (conjectureNode, context) => {
-        const { Conjecture } = ontology,
-              conjecture = Conjecture.fromConjectureNode(conjectureNode, context),
-              conjectureVerifies = conjecture.verify();
-
-        return conjectureVerifies;
-      }
-    },
-    {
-      nodeQuery: metatheoremNodeQuery,
-      verify: (metatheoremNode, context) => {
-        const { Metatheorem } = ontology,
-              metatheorem = Metatheorem.fromMetatheoremNode(metatheoremNode, context),
-              metatheoremVerifies = metatheorem.verify();
-
-        return metatheoremVerifies;
-      }
-    },
-    {
-      nodeQuery: variableDeclarationNodeQuery,
-      verify: (variableDeclarationNode, context) => {
-        const { VariableDeclaration } = ontology,
-              variableDeclaration = VariableDeclaration.fromVariableDeclarationNode(variableDeclarationNode, context),
-              variableDeclarationVerifies = variableDeclaration.verify();
-
-        return variableDeclarationVerifies;
-      }
-    },
-    {
-      nodeQuery: simpleTypeDeclarationNodeQuery,
-      verify: (simpleTypeDeclarationNode, context) => {
-        const { SimpleTypeDeclaration } = ontology,
-              simpleTypeDeclaration = SimpleTypeDeclaration.fromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context),
-              simpleTypeDeclarationVerifies = simpleTypeDeclaration.verify();
-
-        return simpleTypeDeclarationVerifies;
-      }
-    },
-    {
-      nodeQuery: typePrefixDeclarationNodeQuery,
-      verify: (typePrefixDeclarationNode, context) => {
-        const { TypePrefixDeclaration } = ontology,
-              typePrefixDeclaration = TypePrefixDeclaration.fromTypePrefixDeclarationNode(typePrefixDeclarationNode, context),
-              typePrefixDeclarationVerifies = typePrefixDeclaration.verify();
-
-        return typePrefixDeclarationVerifies;
-      }
-    },
-    {
-      nodeQuery: combinatorDeclarationNodeQuery,
-      verify: (combinatorDeclarationNode, context) => {
-        const { CombinatorDeclaration } = ontology,
-              combinatorDeclaration = CombinatorDeclaration.fromCombinatorDeclarationNode(combinatorDeclarationNode, context),
-              combinatorDeclarationVerifies = combinatorDeclaration.verify();
-
-        return combinatorDeclarationVerifies;
-      }
-    },
-    {
-      nodeQuery: constructorDeclarationNodeQuery,
-      verify: (constructorDeclarationNode, context) => {
-        const { ConstructorDeclaration } = ontology,
-              constructorDeclaration = ConstructorDeclaration.fromConstructorDeclarationNode(constructorDeclarationNode, context),
-              constructorDeclarationVerifies = constructorDeclaration.verify();
-
-        return constructorDeclarationVerifies;
-      }
-    },
-    {
-      nodeQuery: complexTypeDeclarationNodeQuery,
-      verify: (complexTypeDeclarationNode, context) => {
-        const { ComplexTypeDeclaration } = ontology,
-              complexTypeDeclaration = ComplexTypeDeclaration.fromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
-              complexTypeDeclarationVerifies = complexTypeDeclaration.verify();
-
-        return complexTypeDeclarationVerifies;
-      }
-    },
-    {
-      nodeQuery: metavariableDeclarationNodeQuery,
-      verify: (metavariableDeclarationNode, context) => {
-        const { MetavariableDeclaration } = ontology,
-              metavariableDeclaration = MetavariableDeclaration.fromMetavariableDeclarationNode(metavariableDeclarationNode, context),
-              metavariableDeclarationVerifies = metavariableDeclaration.verify();
-
-        return metavariableDeclarationVerifies;
-      }
-    }
-  ];
-}
-
-const topLevelVerifier = new TopLevelVerifier();
-
-export default topLevelVerifier;

package/src/verifier.js

@@ -1,150 +0,0 @@
-"use strict";
-
-import { nodeQuery } from "./utilities/query";
-import { isLastRemainingArgumentFunction } from "./utilities/arguments";
-
-const nonTerminalNodeQuery = nodeQuery("/*");
-
-export default class Verifier {
-  verify(node, ...remainingArguments) {
-    let verifies;
-
-    const nodeVerifies = this.verifyNode(node, ...remainingArguments);
-
-    verifies = nodeVerifies;  ///
-
-    return verifies;
-  }
-
-  verifyNode(node, ...remainingArguments) {
-    let nodeVerifies;
-
-    const nodeTerminalNode = node.isTerminalNode();
-
-    if (nodeTerminalNode) {
-      const terminalNode = node,  ///
-            terminalNodeVerifies = this.verifyTerminalNode(terminalNode, ...remainingArguments);
-
-      nodeVerifies = terminalNodeVerifies;  ///
-    } else {
-      const nonTerminalNode = node,  ///
-            nonTerminalNodeVerifies = this.verifyNonTerminalNode(nonTerminalNode, ...remainingArguments);
-
-      nodeVerifies = nonTerminalNodeVerifies; ///
-    }
-
-    return nodeVerifies;
-  }
-
-  verifyChildNodes(childNodes, ...remainingArguments) {
-    let childNodesVerify;
-
-    const lastRemainingArgumentFunction = isLastRemainingArgumentFunction(remainingArguments);
-
-    if (lastRemainingArgumentFunction) {
-      const index = 0,
-            childNodesVerifyAhead = this.verifyChildNodesAhead(index, childNodes, ...remainingArguments);
-
-      childNodesVerify = childNodesVerifyAhead; ///
-    } else {
-      childNodesVerify = childNodes.every((childNode) => {
-        const node = childNode, ///
-              nodeVerifies = this.verifyNode(node, ...remainingArguments);
-
-        if (nodeVerifies) {
-          return true;
-        }
-      });
-    }
-
-    return childNodesVerify;
-  }
-
-  verifyTerminalNode(terminalNode, ...remainingArguments) {
-    let terminalNodeVerifies;
-
-    const lastRemainingArgumentFunction = isLastRemainingArgumentFunction(remainingArguments);
-
-    if (lastRemainingArgumentFunction) {
-      const verifyAhead = remainingArguments.pop(), ///
-            verifiesAhead = verifyAhead();
-
-      terminalNodeVerifies = verifiesAhead; ///
-
-      remainingArguments.push(verifyAhead);
-    } else {
-      terminalNodeVerifies = true;
-    }
-
-    return terminalNodeVerifies;
-  }
-
-  verifyNonTerminalNode(nonTerminalNode, ...remainingArguments) {
-    let nonTerminalNodeVerifies;
-
-    let { maps } = this.constructor;
-
-    maps = [ ///
-      ...maps,
-      {
-        nodeQuery: nonTerminalNodeQuery,
-        verify: (node, ...remainingArguments) => {
-          let nonTerminalNodeVerifies;
-
-          const childNodes = nonTerminalNode.getChildNodes(), ///
-                childNodesVerify = this.verifyChildNodes(childNodes, ...remainingArguments);
-
-          nonTerminalNodeVerifies = childNodesVerify; ///
-
-          return nonTerminalNodeVerifies;
-        }
-      }
-    ]
-
-    let nodeVerifies = false;
-
-    maps.some((map) => {
-      const { nodeQuery, verify } = map;
-
-      const node = nodeQuery(nonTerminalNode);
-
-      if (node !== null) {
-        nodeVerifies = verify(node, ...remainingArguments);
-
-        return true;
-      }
-    });
-
-    nonTerminalNodeVerifies = nodeVerifies; ///
-
-    return nonTerminalNodeVerifies;
-  }
-
-  verifyChildNodesAhead(index, childNodes, ...remainingArguments) {
-    let childNodesVerify;
-
-    const verifyAhead = remainingArguments.pop(), ///
-          childNodesLength = childNodes.length;
-
-    if (index === childNodesLength) {
-      const verifiesAhead = verifyAhead();
-
-      childNodesVerify = verifiesAhead; ///
-    } else {
-      const childNode = childNodes[index],
-            node = childNode, ///
-            nodeVerifies = this.verifyNode(node, ...remainingArguments, () => {
-              remainingArguments.push(verifyAhead);
-
-              const aheadIndex = index + 1,
-                    childNodesVerifyAhead = this.verifyChildNodesAhead(aheadIndex, childNodes, ...remainingArguments);
-
-              return childNodesVerifyAhead;
-            });
-
-      childNodesVerify = nodeVerifies;  ///
-    }
-
-    return childNodesVerify;
-  }
-}