occam-verify-cli 0.0.1077 → 0.0.1078

package/src/statement.js

@@ -4,6 +4,7 @@ import shim from "./shim";
 import unifyMixins from "./mixins/statement/unify";
 import verifyMixins from "./mixins/statement/verify";
 import LocalContext from "./context/local";
+import resolveMixins from "./mixins/statement/resolve";
 import metaLevelUnifier from "./unifier/metaLevel";
 import statementAsCombinatorVerifier from "./verifier/statementAsCombinator";
 
@@ -105,6 +106,35 @@ class Statement {
     return statementNodeMatches;
   }
 
+  resolveIndependently(substitutions, localContextA, localContextB) {
+    let resolvedIndependently;
+
+    const statement = this, ///
+          statementString = this.string;  ///
+
+    localContextB.trace(`Resolving the '${statementString}' statement independently...`);
+
+    const context = localContextA;  ///
+
+    localContextA = LocalContext.fromContextAndTokens(context, this.tokens);
+
+    const resolved = resolveMixins.some((resolveMixin) => {
+      const resolved = resolveMixin(statement, substitutions, localContextA, localContextB);
+
+      if (resolved) {
+        return true;
+      }
+    });
+
+    resolvedIndependently = resolved; ///
+
+    if (resolvedIndependently) {
+      localContextB.debug(`...resolved the '${statementString}' statement independently.`);
+    }
+
+    return resolvedIndependently;
+  }
+
   unifyStatement(statement, substitutions, localContextA, localContextB) {
     let statementUnified;
 

package/src/substitution/statementForMetavariable.js

@@ -201,9 +201,9 @@ export default class StatementForMetavariableSubstitution extends Substitution {
 
     statement = Statement.fromStatementNode(statementNode, localContext);
 
-    const string = stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext),
+    const substitution = null,
           resolved = true,
-          substitution = null,
+          string = stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext),
           statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(string, resolved, statement, metavariable, substitution);
 
     return statementForMetavariableSubstitution;

package/src/term.js

@@ -42,13 +42,6 @@ class Term {
     this.type = type;
   }
 
-  match(term) {
-    const node = term.getNode(),
-          matches = this.node.match(node);
-
-    return matches;
-  }
-
   getVariable(localContext) {
     let variable = null;
 
@@ -98,6 +91,23 @@ class Term {
     return grounded;
   }
 
+  isEqualTo(term) {
+    let equalTo = false;
+
+    const termNode = term.getNode(),
+          termNodeMatches = this.node.match(termNode);
+
+    if (termNodeMatches) {
+      const termType = term.getType();
+
+      if (this.type === termType) {
+        equalTo = true;
+      }
+    }
+
+    return equalTo;
+  }
+
   matchTermNode(termNode) {
     const termNodeMatches = this.node.match(termNode);
 

package/src/type.js

@@ -83,12 +83,6 @@ class Type {
     return equalToOrSuperTypeOf;
   }
 
-  match(type) {
-    const matches = (type === this);  ///
-
-    return matches;
-  }
-
   matchName(name) {
     const nodeMatches = (this.name === name);
 

package/src/utilities/equivalences.js

@@ -57,9 +57,9 @@ export function findEquivalenceByType(equivalences, type) {
 
 export function findEquivalenceByTerm(equivalences, term) {
   const equivalence = equivalences.find((equivalence) => {
-    const equivalenceMatchesTerm = equivalence.matchTerm(term);
+    const termEquates = equivalence.equateTerm(term);
 
-    if (equivalenceMatchesTerm) {
+    if (termEquates) {
       return true;
     }
   }) || null;

package/src/utilities/substitutions.js

@@ -0,0 +1,77 @@
+"use strict";
+
+import { nodeQuery } from "../utilities/query";
+import { variableNameFromVariableNode } from "../utilities/name";
+
+const variableNodeQuery = nodeQuery("/term/variable!"),
+      metavariableNodeQuery = nodeQuery("/*/metavariable!");
+
+export function termFromTermAndSubstitutions(term, substitutions) {
+  if (term !== null) {
+    const termNode = term.getNode(),
+          variableNode = variableNodeQuery(termNode);
+
+    if (variableNode !== null) {
+      const variableName = variableNameFromVariableNode(variableNode),
+            substitution = substitutions.findSubstitution((substitution) => {
+              const variableNameMatches = substitution.matchVariableName(variableName);
+
+              if (variableNameMatches) {
+                return true;
+              }
+            });
+
+      if (substitution !== null) {
+        term = substitution.getTerm();
+      }
+    }
+  }
+
+  return term;
+}
+
+export function frameFromFrameAndSubstitutions(frame, substitutions) {
+  if (frame !== null) {
+    const frameNode = frame.getNode(),
+          metavariableNode = metavariableNodeQuery(frameNode);
+
+    if (metavariableNode !== null) {
+      const substitution = substitutions.findSubstitution((substitution) => {
+        const metavariableNodeMatches = substitution.matchMetavariableNode(metavariableNode);
+
+        if (metavariableNodeMatches) {
+          return true;
+        }
+      });
+
+      if (substitution !== null) {
+        frame = substitution.getTerm();
+      }
+    }
+  }
+
+  return frame;
+}
+
+export function statementFromStatementAndSubstitutions(statement, substitutions) {
+  if (statement !== null) {
+    const statementNode = statement.getNode(),
+          metavariableNode = metavariableNodeQuery(statementNode);
+
+    if (metavariableNode !== null) {
+      const substitution = substitutions.findSubstitution((substitution) => {
+        const metavariableNodeMatches = substitution.matchMetavariableNode(metavariableNode);
+
+        if (metavariableNodeMatches) {
+          return true;
+        }
+      });
+
+      if (substitution !== null) {
+        statement = substitution.getStatement();
+      }
+    }
+  }
+
+  return statement;
+}