occam-verify-cli 1.0.405 → 1.0.414

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;
-}

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;