occam-verify-cli 1.0.405 → 1.0.415

package/src/unifier/metaLevel.js

@@ -1,151 +0,0 @@
-"use strict";
-
-import Unifier from "../unifier";
-import ontology from "../ontology";
-
-import { nodeQuery } from "../utilities/query";
-import { metavariableNameFromMetavariableNode } from "../utilities/metavariable";
-
-const termNodeQuery = nodeQuery("/term"),
-      frameNodeQuery = nodeQuery("/frame"),
-      statementNodeQuery = nodeQuery("/statement"),
-      termVariableNodeQuery = nodeQuery("/term/variable!"),
-      statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!"),
-      assumptionMetavariableNodeQuery = nodeQuery("/assumption/metavariable!"),
-      frameAssumptionMetavariableNodeQuery = nodeQuery("/frame/assumption!/metavariable!");
-
-class MetaLevelUnifier extends Unifier {
-  unify(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext) {
-    let unifiesAtMetaLevel;
-
-    const nonTerminalNodeUnifies = this.unifyNonTerminalNode(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext);
-
-    unifiesAtMetaLevel = nonTerminalNodeUnifies; ///
-
-    return unifiesAtMetaLevel;
-  }
-
-  static maps = [
-    {
-      generalNodeQuery: statementMetavariableNodeQuery,
-      specificNodeQuery: statementNodeQuery,
-      unify: (generalStatementMetavariableNode, specificStatementNode, substitutions, generalContext, specificContext) => {
-        let statementUnifies;
-
-        let context,
-            statement,
-            statementNode;
-
-        context = generalContext; ///
-
-        const metavariableNode = generalStatementMetavariableNode,  ///
-              metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-              metavariable = context.findMetavariableByMetavariableName(metavariableName);
-
-        const metavariableNodeParentNode = metavariableNode.getParentNode();
-
-        statementNode = metavariableNodeParentNode; ///
-
-        statement = context.findStatementByStatementNode(statementNode);
-
-        const { TermSubstitution, FrameSubstitution } = ontology,
-              frameSubstitution = FrameSubstitution.fromStatement(statement, context),
-              termSubstitution = TermSubstitution.fromStatement(statement, context),
-              substitution = (frameSubstitution || termSubstitution);
-
-        context = specificContext; ///
-
-        statementNode = specificStatementNode;  ///
-
-        statement = context.findStatementByStatementNode(statementNode);
-
-        statementUnifies = metavariable.unifyStatement(statement, substitution, substitutions, generalContext, specificContext);
-
-        return statementUnifies;
-      }
-    },
-    {
-      generalNodeQuery: frameAssumptionMetavariableNodeQuery,
-      specificNodeQuery: frameNodeQuery,
-      unify: (generalFrameAssumptionMetavariableNode, specificFrameNode, substitutions, generalContext, specificContext) => {
-        let frameUnifies;
-
-        const frameNode = specificFrameNode, ///
-              metavariableNode = generalFrameAssumptionMetavariableNode,  ///
-              metavariableName = metavariableNameFromMetavariableNode(metavariableNode);
-
-        let context;
-
-        context = generalContext; ///
-
-        const metavariable = context.findMetavariableByMetavariableName(metavariableName);
-
-        context = specificContext;  ///
-
-        const frame = context.findFrameByFrameNode(frameNode);
-
-        frameUnifies = metavariable.unifyFrame(frame, substitutions, generalContext, specificContext);
-
-        return frameUnifies;
-      }
-    },
-    {
-      generalNodeQuery: termVariableNodeQuery,
-      specificNodeQuery: termNodeQuery,
-      unify: (generalTermVariableNode, specificTermNode, substitutions, generalContext, specificContext) => {
-        let termUnifies;
-
-        const termNode = specificTermNode, ///
-              variableNode = generalTermVariableNode, ///
-              variableIdentifier = variableNode.getVariableIdentifier();
-
-        let context;
-
-        context = generalContext; ///
-
-        const variable = context.findVariableByVariableIdentifier(variableIdentifier);
-
-        context = specificContext;  ///
-
-        const term = context.findTermByTermNode(termNode);
-
-        termUnifies = variable.unifyTerm(term, substitutions, generalContext, specificContext);
-
-        return termUnifies;
-      }
-    },
-    {
-      generalNodeQuery: assumptionMetavariableNodeQuery,
-      specificNodeQuery: assumptionMetavariableNodeQuery,
-      unify: (generalAssumptionMetavariableNode, specificAssumptionMetavariableNode, substitutions, generalContext, specificContext) => {
-        let referenceUnifies;
-
-        const { Reference } = ontology;
-
-        let context,
-            metavariableNode;
-
-        context = generalContext; ///
-
-        metavariableNode = generalAssumptionMetavariableNode;  ///
-
-        const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-              metavariable = context.findMetavariableByMetavariableName(metavariableName);
-
-        context = specificContext;  ///
-
-        metavariableNode = specificAssumptionMetavariableNode; ///
-
-        const reference = Reference.fromMetavariableNode(metavariableNode, context);
-
-        referenceUnifies = metavariable.unifyReference(reference, substitutions, generalContext, specificContext);
-
-        return referenceUnifies;
-      }
-    }
-  ];
-}
-
-const metaLevelUnifier = new MetaLevelUnifier();
-
-export default metaLevelUnifier;

package/src/unifier/metavariable.js

@@ -1,50 +0,0 @@
-"use strict";
-
-import ontology from "../ontology";
-import Unifier from "../unifier";
-
-import { nodeQuery } from "../utilities/query";
-
-const typeNodeQuery = nodeQuery("/type"),
-      termNodeQuery = nodeQuery("/term");
-
-class MetavariableUnifier extends Unifier {
-  unify(generalMetavariableNode, specificMetavariableNode, generalContext, specificContext) {
-    let metavariableUnifies;
-
-    const generalNonTerminalNode = generalMetavariableNode, ///
-          specificNonTerminalNode = specificMetavariableNode, ///
-          nonTerminalNodeUnifies = this.unifyNonTerminalNode(generalNonTerminalNode, specificNonTerminalNode, generalContext, specificContext);
-
-    metavariableUnifies = nonTerminalNodeUnifies; ///
-
-    return metavariableUnifies;
-  }
-
-  static maps = [
-    {
-      generalNodeQuery: typeNodeQuery,
-      specificNodeQuery: termNodeQuery,
-      unify: (generalTypeNode, specificTermNode, generalContext, specificContext) => {
-        let termUnifies;
-
-        const { Term } = ontology,
-              typeNode = generalTypeNode, ///
-              termNode = specificTermNode, ///
-              nominalTypeName = typeNode.getNominalTypeName(),
-              type = generalContext.findTypeByNominalTypeName(nominalTypeName),
-              context = specificContext, ///
-              term = Term.fromTermNode(termNode, context),
-              termVerifiesGivenType = term.verifyGivenType(type, generalContext, specificContext);
-
-        termUnifies = termVerifiesGivenType;  ///
-
-        return termUnifies;
-      }
-    }
-  ];
-}
-
-const metavariableUnifier = new MetavariableUnifier();
-
-export default metavariableUnifier;

package/src/unifier/statementWithCombinator.js

@@ -1,114 +0,0 @@
-"use strict";
-
-import ontology from "../ontology";
-import Unifier from "../unifier";
-
-import { nodeQuery } from "../utilities/query";
-
-const termNodeQuery = nodeQuery("/term"),
-      typeNodeQuery = nodeQuery("/type"),
-      frameNodeQuery = nodeQuery("/frame"),
-      metaTypeNodeQuery = nodeQuery("/metaType"),
-      statementNodeQuery = nodeQuery("/statement");
-
-class StatementWithCombinatorUnifier extends Unifier {
-  unify(combinatorStatementNode, statementNode, assignments, stated, generalContext, specificContext) {
-    let statementUnifiesWithCombinator;
-
-    const generalNonTerminalNode = combinatorStatementNode, ///
-          specificNonTerminalNode = statementNode, ///
-          nonTerminalNodeUnifies = this.unifyNonTerminalNode(generalNonTerminalNode, specificNonTerminalNode, assignments, stated, generalContext, specificContext);
-
-    statementUnifiesWithCombinator = nonTerminalNodeUnifies; ///
-
-    return statementUnifiesWithCombinator;
-  };
-
-  static maps = [
-    {
-      generalNodeQuery: metaTypeNodeQuery,
-      specificNodeQuery: statementNodeQuery,
-      unify: (generalMetaTypeNode, specificStatementNode, assignments, stated, generalContext, specificContext) => {
-        let unifies;
-
-        const { Statement, MetaType } = ontology,
-              metaTypeNode = generalMetaTypeNode, ///
-              statementNode = specificStatementNode; ///
-
-        let context;
-
-        context = generalContext; ///
-
-        const metaType = MetaType.fromMetaTypeNode(metaTypeNode, context);
-
-        context = specificContext;  ///
-
-        const statement = Statement.fromStatementNode(statementNode, context),
-              statementVerifiesGivenType = statement.verifyGivenMetaType(metaType, assignments, stated, context);
-
-        unifies = statementVerifiesGivenType;
-
-        return unifies;
-      }
-    },
-    {
-      generalNodeQuery: metaTypeNodeQuery,
-      specificNodeQuery: frameNodeQuery,
-      unify: (generalMetaTypeNode, specificFrameNode, assignments, stated, generalContext, specificContext) => {
-        let unifies;
-
-        const { Frame, MetaType } = ontology,
-              metaTypeNode = generalMetaTypeNode, ///
-              frameNode = specificFrameNode; ///
-
-        let context;
-
-        context = generalContext; ///
-
-        const metaType = MetaType.fromMetaTypeNode(metaTypeNode, context);
-
-        context = specificContext;  ///
-
-        const frame = Frame.fromFrameNode(frameNode, context),
-              frameVerifiesGivenType = frame.verifyGivenMetaType(metaType, assignments, stated, context);
-
-        unifies = frameVerifiesGivenType;
-
-        return unifies;
-      }
-    },
-    {
-      generalNodeQuery: typeNodeQuery,
-      specificNodeQuery: termNodeQuery,
-      unify: (generalTypeNode, specificTermNode, assignments, stated, generalContext, specificContext) => {
-        let unifies = false;
-
-        const { Term } = ontology,
-              typeNode = generalTypeNode, ///
-              termNode = specificTermNode, ///
-              nominalTypeName = typeNode.getNominalTypeName();
-
-        let context;
-
-        context = generalContext; ///
-
-        const type = context.findTypeByNominalTypeName(nominalTypeName);
-
-        context = specificContext;  ///
-
-        const term = Term.fromTermNode(termNode, context),
-              termVerifiesGivenType = term.verifyGivenType(type, generalContext, specificContext);
-
-        if (termVerifiesGivenType) {
-          unifies = true;
-        }
-
-        return unifies;
-      }
-    }
-  ];
-}
-
-const statementWithCombinatorUnifier = new StatementWithCombinatorUnifier();
-
-export default statementWithCombinatorUnifier;

package/src/unifier/termWithConstructor.js

@@ -1,56 +0,0 @@
-"use strict";
-
-import ontology from "../ontology";
-import Unifier from "../unifier";
-
-import { nodeQuery } from "../utilities/query";
-
-const termNodeQuery = nodeQuery("/term"),
-      typeNodeQuery = nodeQuery("/type");
-
-class TermWithConstructorUnifier extends Unifier {
-  unify(constructorTermNode, termNode, context) {
-    let termUnifiesWithConstructor;
-
-    const generalNonTerminalNode = constructorTermNode, ///
-          specificNonTerminalNode = termNode, ///
-          nonTerminalNodeUnifies = this.unifyNonTerminalNode(generalNonTerminalNode, specificNonTerminalNode, context);
-
-    termUnifiesWithConstructor = nonTerminalNodeUnifies; ///
-
-    return termUnifiesWithConstructor;
-  };
-
-  static maps = [
-    {
-      generalNodeQuery: typeNodeQuery,
-      specificNodeQuery: termNodeQuery,
-      unify: (generalTypeNode, specificTermNode, context) => {
-        let unifies = false;
-
-        const { Term } = ontology,
-              typeNode = generalTypeNode, ///
-              nominalTypeName = typeNode.getNominalTypeName(),
-              type = context.findTypeByNominalTypeName(nominalTypeName);
-
-        if (type !== null) {
-          const termNode = specificTermNode, ///
-                term = Term.fromTermNode(termNode, context),
-                generalContext = context, ///
-                specificContext = context,  ///
-                termVerifiesGivenType = term.verifyGivenType(type, generalContext, specificContext);
-
-          if (termVerifiesGivenType) {
-            unifies = true;
-          }
-        }
-
-        return unifies;
-      }
-    }
-  ];
-}
-
-const termWithConstructorUnifier = new TermWithConstructorUnifier();
-
-export default termWithConstructorUnifier;

package/src/unifier.js

@@ -1,183 +0,0 @@
-"use strict";
-
-import { nodeQuery } from "./utilities/query";
-import { isLastRemainingArgumentFunction } from "./utilities/arguments";
-import { terminalNodeMapFromNodes, areTerminalNodeMapsEqual } from "./utilities/unifier";
-
-const nonTerminalNodeQuery = nodeQuery("/*");
-
-export default class Unifier {
-  unify(generalNode, specificNode, ...remainingArguments) {
-    let unifies;
-
-    const nodeUnifies = this.unifyNode(generalNode, specificNode, ...remainingArguments);
-
-    unifies = nodeUnifies;  ///
-
-    return unifies;
-  }
-
-  unifyNode(generalNode, specificNode, ...remainingArguments) {
-    let nodeUnifies = false;
-
-    const generalNodeTerminalNode = generalNode.isTerminalNode(),
-          specificNodeTerminalNode = specificNode.isTerminalNode(),
-          generalNodeNonTerminalNode = generalNode.isNonTerminalNode(),
-          specificNodeNonTerminalNode = specificNode.isNonTerminalNode();
-
-    if (false) {
-      ///
-    } else if (generalNodeTerminalNode && specificNodeTerminalNode) {
-      const generalTerminalNode = generalNode,  ///
-            specificTerminalNode = specificNode,  ///
-            terminalNodeUnifies = this.unifyTerminalNode(generalTerminalNode, specificTerminalNode, ...remainingArguments);
-
-      nodeUnifies = terminalNodeUnifies;  ///
-    } else if (generalNodeNonTerminalNode && specificNodeNonTerminalNode) {
-      const generalNonTerminalNode = generalNode,  ///
-            specificNonTerminalNode = specificNode, ///
-            nonTerminalNodeUnifies = this.unifyNonTerminalNode(generalNonTerminalNode, specificNonTerminalNode, ...remainingArguments);
-
-      nodeUnifies = nonTerminalNodeUnifies; ///
-    }
-
-    return nodeUnifies;
-  }
-
-  unifyChildNodes(generalChildNodes, specificChildNodes, ...remainingArguments) {
-    let childNodesUnify = false;
-
-    const generalChildNodesLength = generalChildNodes.length,
-          specificChildNodesLength = specificChildNodes.length;
-
-    if (generalChildNodesLength === specificChildNodesLength) {
-      const specificTerminalNodeMap = terminalNodeMapFromNodes(specificChildNodes),
-            generalTerminalNodeMap = terminalNodeMapFromNodes(generalChildNodes),
-            terminalNodeMapsEqual = areTerminalNodeMapsEqual(generalTerminalNodeMap, specificTerminalNodeMap);
-
-      if (terminalNodeMapsEqual) {
-        const lastRemainingArgumentFunction = isLastRemainingArgumentFunction(remainingArguments);
-
-        if (lastRemainingArgumentFunction) {
-          const index = 0,
-                childNodesUnifyAhead = this.unifyChildNodesAhead(index, generalChildNodes, specificChildNodes,...remainingArguments);
-
-          childNodesUnify = childNodesUnifyAhead; ///
-        } else {
-          childNodesUnify = generalChildNodes.every((generalChildNode, index) => {
-            const specificChildNode = specificChildNodes[index],
-                  specificNode = specificChildNode, ///
-                  generalNode = generalChildNode, ///
-                  nodeUnifies = this.unifyNode(generalNode, specificNode, ...remainingArguments);
-
-            if (nodeUnifies) {
-              return true;
-            }
-          });
-        }
-      }
-    }
-
-    return childNodesUnify;
-  }
-
-  unifyTerminalNode(generalTerminalNode, specificTerminalNode, ...remainingArguments) { ///
-    let terminalNodeUnifies;
-
-    const lastRemainingArgumentFunction = isLastRemainingArgumentFunction(remainingArguments);
-
-    if (lastRemainingArgumentFunction) {
-      const unifyAhead = remainingArguments.pop(),
-            unifiesAhead = unifyAhead();
-
-      terminalNodeUnifies = unifiesAhead;  ///
-
-      remainingArguments.push(unifiesAhead);
-    } else {
-      terminalNodeUnifies = true;
-    }
-
-    return terminalNodeUnifies;
-  }
-
-  unifyNonTerminalNode(generalNonTerminalNode, specificNonTerminalNode, ...remainingArguments) {
-    let nonTerminalNodeUnifies;
-
-    let { maps } = this.constructor;
-
-    maps = [ ///
-      ...maps,
-      {
-        generalNodeQuery: nonTerminalNodeQuery,
-        specificNodeQuery: nonTerminalNodeQuery,
-        unify: (generalNode, specificNode, ...remainingArguments) => {
-          let nonTerminalNodeUnifies;
-
-          const generalNonTerminalNodeRuleName = generalNonTerminalNode.getRuleName(), ///
-                specificNonTerminalNodeRuleName = specificNonTerminalNode.getRuleName(); ///
-
-          if (generalNonTerminalNodeRuleName === specificNonTerminalNodeRuleName) {
-            const generalNonTerminalNodeChildNodes = generalNonTerminalNode.getChildNodes(),
-                  specificNonTerminalNodeChildNode = specificNonTerminalNode.getChildNodes(),
-                  generalChildNodes = generalNonTerminalNodeChildNodes, ///
-                  specificChildNodes = specificNonTerminalNodeChildNode, ///
-                  childNodesUnify = this.unifyChildNodes(generalChildNodes, specificChildNodes, ...remainingArguments);
-
-            nonTerminalNodeUnifies = childNodesUnify; ///
-          }
-
-          return nonTerminalNodeUnifies;
-        }
-      }
-    ]
-
-    let nodeUnifies = false;
-
-    maps.some((map) => {
-      const { generalNodeQuery, specificNodeQuery, unify } = map;
-
-      const generalNode = generalNodeQuery(generalNonTerminalNode),  ///
-            specificNode = specificNodeQuery(specificNonTerminalNode);  ///
-
-      if ((generalNode !== null) && (specificNode !== null)) {
-        nodeUnifies = unify(generalNode, specificNode, ...remainingArguments);
-
-        return true;
-      }
-    });
-
-    nonTerminalNodeUnifies = nodeUnifies; ///
-
-    return nonTerminalNodeUnifies;
-  }
-
-  unifyChildNodesAhead(index, generalChildNodes, specificChildNodes, ...remainingArguments) {
-    let childNodesUnify;
-
-    const unifyAhead = remainingArguments.pop(), ///
-          generalChildNodesLength = generalChildNodes.length;
-
-    if (index === generalChildNodesLength) {
-      const unifiesAhead = unifyAhead();
-
-      childNodesUnify = unifiesAhead; ///
-    } else {
-      const generalChildNode = generalChildNodes[index],
-            specificChildNode = specificChildNodes[index],
-            generalNode = generalChildNode, ///
-            specificNode = specificChildNode, ///
-            nodeUnifies = this.unifyNode(generalNode, specificNode, ...remainingArguments, () => {
-              remainingArguments.push(unifyAhead); ///
-
-              const aheadIndex = index + 1,
-                    childNodesUnifyAhead = this.unifyChildNodesAhead(aheadIndex, generalChildNodes, specificChildNodes, ...remainingArguments);
-
-              return childNodesUnifyAhead;
-            });
-
-      childNodesUnify = nodeUnifies;  ///
-    }
-
-    return childNodesUnify;
-  }
-}

package/src/utilities/arguments.js

@@ -1,21 +0,0 @@
-"use strict";
-
-import { arrayUtilities } from "necessary";
-
-import { FUNCTION } from "../constants";
-
-const { last } = arrayUtilities;
-
-export function isLastRemainingArgumentFunction(remainingArguments) {
-  let lastRemainingArgumentFunction = false;
-
-  const remainingArgumentsLength = remainingArguments.length;
-
-  if (remainingArgumentsLength > 0) {
-    const lastRemainingArgument = last(remainingArguments);
-
-    lastRemainingArgumentFunction = (typeof lastRemainingArgument === FUNCTION);
-  }
-
-  return lastRemainingArgumentFunction;
-}

package/src/utilities/frame.js

@@ -1,13 +0,0 @@
-"use strict";
-
-import { nodeQuery } from "../utilities/query";
-
-const frameMetavariableNameNodeQuery = nodeQuery("/frame/assumption!/metavariable!/@name!");
-
-export function frameMetavariableNameFromFrameNode(frmaeNode) {
-  const frameMetavariableNameTerminalNode = frameMetavariableNameNodeQuery(frmaeNode),
-        frameMetavariableNameTerminalNodeContent = frameMetavariableNameTerminalNode.getContent(),
-        frameMetavariableName = frameMetavariableNameTerminalNodeContent; ///
-
-  return frameMetavariableName;
-}

package/src/utilities/metavariable.js

@@ -1,13 +0,0 @@
-"use strict";
-
-import { nodeQuery } from "../utilities/query";
-
-const metavariableNameNodeQuery = nodeQuery("/metavariable/@name!");
-
-export function metavariableNameFromMetavariableNode(metavariableNode) {
-  const metavariableNameTerminalNode = metavariableNameNodeQuery(metavariableNode),
-        metavariableNameTerminalNodeContent = metavariableNameTerminalNode.getContent(),
-        metavariableName = metavariableNameTerminalNodeContent; ///
-
-  return metavariableName;
-}

package/src/utilities/statement.js

@@ -1,13 +0,0 @@
-"use strict";
-
-import { nodeQuery } from "../utilities/query";
-
-const statementMetavariableNameNodeQuery = nodeQuery("/statement/metavariable!/@name!");
-
-export function statementMetavariableNameFromFrameNode(frmaeNode) {
-  const statementMetavariableNameTerminalNode = statementMetavariableNameNodeQuery(frmaeNode),
-        statementMetavariableNameTerminalNodeContent = statementMetavariableNameTerminalNode.getContent(),
-        statementMetavariableName = statementMetavariableNameTerminalNodeContent; ///
-
-  return statementMetavariableName;
-}