occam-verify-cli 1.0.578 → 1.0.581

package/src/context.js

@@ -3,6 +3,27 @@
 import { Context as ContextBase } from "occam-languages";
 
 export default class Context extends ContextBase {
+  getLexer() {
+    const context = this.getContext(),
+          lexer = context.getLexer();
+
+    return lexer;
+  }
+
+  getParser() {
+    const context = this.getContext(),
+          parser = context.getParser();
+
+    return parser;
+  }
+
+  getFilePath() {
+    const context = this.getContext(),
+          filePath = context.getFilePath();
+
+    return filePath;
+  }
+
   getCombinators(includeRelease) {
     const context = this.getContext(),
           combinators = context.getCombinators(includeRelease);
@@ -10,6 +31,21 @@ export default class Context extends ContextBase {
     return combinators;
   }
 
+  getSubproofOrProofAssertions() {
+    const context = this.getContext(),
+          subproofOrProofAssertions = context.getSubproofOrProofAssertions();
+
+    return subproofOrProofAssertions;
+  }
+
+  findMetavariable(metavariable) {
+    const context = this.getContext();
+
+    metavariable = context.findMetavariable(metavariable);  ///
+
+    return metavariable;
+  }
+
   findProcedureByName(name) {
     const context = this.getContext(),
           procedure = context.findProcedureByName(name);
@@ -17,6 +53,27 @@ export default class Context extends ContextBase {
     return procedure;
   }
 
+  findRuleByReference(reference) {
+    const context = this.getContext(),
+          rule = context.findRuleByReference(reference);
+
+    return rule;
+  }
+
+  findFrameByFrameNode(frameNode) {
+    const context = this.getContext(),
+          frame = context.findFrameByFrameNode(frameNode);
+
+    return frame;
+  }
+
+  findStatementByStatementNode(statementNode) {
+    const context = this.getContext(),
+          statement = context.findStatementByStatementNode(statementNode);
+
+    return statement;
+  }
+
   findVariableByVariableIdentifier(variableIdentifier) {
     const context = this.getContext(),
           variable = context.findVariableByVariableIdentifier(variableIdentifier);
@@ -31,6 +88,27 @@ export default class Context extends ContextBase {
     return metavariable;
   }
 
+  isLabelPresentByReference(reference) {
+    const context = this.getContext(),
+          labelPresent = context.isLabelPresentByReference(reference);
+
+    return labelPresent;
+  }
+
+  isMetavariablePresentByReference(reference) {
+    const context = this.getContext(),
+          metavariablePresent = context.isMetavariablePresentByReference(reference);
+
+    return metavariablePresent;
+  }
+
+  addJudgement(judgement) {
+    const context = this.getContext(),
+          judgementAdded = context.addJudgement(judgement);
+
+    return judgementAdded;
+  }
+
   addSubproofOrProofAssertion(subproofOrProofAssertion) {
     const context = this.getContext();
 

package/src/element/parameter.js

@@ -24,7 +24,7 @@ export default define(class Parameter extends Element {
     let replacementNode = null;
 
     const parameter = this, ///
-          substitution = substitutions.findSubstitution((substitution) => {
+          substitution = substitutions.find((substitution) => {
             const substitutionComparesToParamter = substitution.compareParameter(parameter);
 
             if (substitutionComparesToParamter) {

package/src/element/procedureCall.js

@@ -1,11 +1,13 @@
 "use strict";
 
 import { Element } from "occam-languages";
-import { Expressions } from "occam-furtle";
+import { termsUtilities } from "occam-furtle";
 
 import { define } from "../elements";
 import { parametersFromJSON, procedureReferenceFromJSON, parametersToParametersJSON, procedureReferenceToProcedureReferenceJSON } from "../utilities/json";
 
+const { termsFromPrimitives } = termsUtilities;
+
 export default define(class ProcedureCall extends Element {
   constructor(context, string, node, parameters, procedureReference) {
     super(context, string, node);
@@ -65,7 +67,7 @@ export default define(class ProcedureCall extends Element {
     return validates;
   }
 
-  unifyIndependently(substitutions, context) {
+  unifyIndependently(context) {
     let unifiesIndependently = false;
 
     const procedureCallString = this.getString(); ///
@@ -74,11 +76,11 @@ export default define(class ProcedureCall extends Element {
 
     const name = this.getName(),
           nodes = this.findNodes(context),
-          procedure = context.findProcedureByName(name),
-          expressions = Expressions.fromNodes(nodes, context);
+          terms = termsFromPrimitives(nodes, context),
+          procedure = context.findProcedureByName(name);
 
     try {
-      const value = procedure.call(expressions, context),
+      const value = procedure.call(terms, context),
             boolean = value.getBoolean();
 
       unifiesIndependently = boolean; ///

package/src/element/proofAssertion/premise.js

@@ -78,25 +78,17 @@ export default define(class Premise extends ProofAssertion {
     return verifies;
   }
 
-  unifyIndependently(substitutions, context) {
+  unifyIndependently(context) {
     let unifiesIndependently = false;
 
     const premiseString = this.getString(); ///
 
     context.trace(`Unifying the '${premiseString}' premise independently...`);
 
-    const specificContext = context; ///
-
-    context = this.getContext();
-
-    const generalContext = context;  ///
-
-    context = specificContext;  ///
-
     const statement = this.getStatement();
 
     if (statement !== null) {
-      const statementUnifiesIndependently = statement.unifyIndependently(substitutions, generalContext, specificContext);
+      const statementUnifiesIndependently = statement.unifyIndependently(context);
 
       if (statementUnifiesIndependently) {
         unifiesIndependently = true;
@@ -104,7 +96,7 @@ export default define(class Premise extends ProofAssertion {
     }
 
     if (this.procedureCall !== null) {
-      const procedureCallResolvedIndependently = this.procedureCall.unifyIndependently(substitutions, context);
+      const procedureCallResolvedIndependently = this.procedureCall.unifyIndependently(context);
 
       if (procedureCallResolvedIndependently) {
         unifiesIndependently = true;

package/src/element/proofAssertion/supposition.js

@@ -85,18 +85,10 @@ export default define(class Supposition extends ProofAssertion {
 
     context.trace(`Unifying the '${suppositionString}' supposition independently...`);
 
-    const specificContext = context;  ///
-
-    context = this.getContext();
-
-    const generalContext = context; ///
-
-    context = specificContext;  ///
-
     const statement = this.getStatement();
 
     if (statement !== null) {
-      const statementUnifiesIndependently = statement.unifyIndependently(substitutions, generalContext, specificContext);
+      const statementUnifiesIndependently = statement.unifyIndependently(context);
 
       if (statementUnifiesIndependently) {
         unifiesIndependently = true;
@@ -104,7 +96,7 @@ export default define(class Supposition extends ProofAssertion {
     }
 
     if (this.procedureCall !== null) {
-      const procedureCallResolvedIndependently = this.procedureCall.unifyIndependently(substitutions, context);
+      const procedureCallResolvedIndependently = this.procedureCall.unifyIndependently(context);
 
       if (procedureCallResolvedIndependently) {
         unifiesIndependently = true;

package/src/element/rule.js

@@ -146,6 +146,22 @@ export default define(class Rule extends Element {
     return statementAndSubproofOrProofAssertionsUnify;
   }
 
+  unifySubproofOrProofAssertionsWithPremises(subproofOrProofAssertions, context) {
+    let subproofOrProofAssertionsUnifiesWithPremises;
+
+    subproofOrProofAssertions = reverse(subproofOrProofAssertions); ///
+
+    subproofOrProofAssertionsUnifiesWithPremises = backwardsEvery(this.premises, (premise) => {
+      const stepUnifiesWithPremise = this.unifySubproofOrProofAssertionsWithPremise(subproofOrProofAssertions, premise, context);
+
+      if (stepUnifiesWithPremise) {
+        return true;
+      }
+    });
+
+    return subproofOrProofAssertionsUnifiesWithPremises;
+  }
+
   unifySubproofOrProofAssertionsWithPremise(subproofOrProofAssertions, premise, context) {
     let subproofOrProofAssertionsUnifiesWithPremise = false;
 
@@ -174,22 +190,6 @@ export default define(class Rule extends Element {
     return subproofOrProofAssertionsUnifiesWithPremise;
   }
 
-  unifySubproofOrProofAssertionsWithPremises(subproofOrProofAssertions, context) {
-    let subproofOrProofAssertionsUnifiesWithPremises;
-
-    subproofOrProofAssertions = reverse(subproofOrProofAssertions); ///
-
-    subproofOrProofAssertionsUnifiesWithPremises = backwardsEvery(this.premises, (premise) => {
-      const stepUnifiesWithPremise = this.unifySubproofOrProofAssertionsWithPremise(subproofOrProofAssertions, premise, context);
-
-      if (stepUnifiesWithPremise) {
-        return true;
-      }
-    });
-
-    return subproofOrProofAssertionsUnifiesWithPremises;
-  }
-
   async verify() {
     let verifies = false;
 

package/src/utilities/context.js

@@ -29,9 +29,10 @@ export function liminally(innerFunction, context) {
   return innerFunction(context);
 }
 
-export function literally(innerFunction) {
-  const literalContext = LiteralContext.fromNothing(),
-        context = literalContext;  ///
+export function literally(innerFunction, context) {
+  const literalContext = LiteralContext.fromNothing(context);
+
+  context = literalContext;  ///
 
   return innerFunction(context);
 }

package/src/utilities/instance.js

@@ -1,5 +1,7 @@
 "use strict";
 
+import nominalContext from "../context/nominal";
+
 import { literally } from "../utilities/context";
 import { BASE_TYPE_SYMBOL } from "../constants";
 import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
@@ -11,6 +13,8 @@ let bracketedCombinator = null,
 
 export function bracketedCombinatorFromNothing() {
   if (bracketedCombinator === null) {
+    const context = nominalContext; ///
+
     bracketedCombinator = literally((context) => {
       const bracketedCombinatorString = `(${STATEMENT_META_TYPE_NAME})`,
             string = bracketedCombinatorString, ///
@@ -19,7 +23,7 @@ export function bracketedCombinatorFromNothing() {
             bracketedCombinator = combinatorFromCombinatorNode(bracketedCombinatorNode, context);
 
       return bracketedCombinator;
-    });
+    }, context);
   }
 
   return bracketedCombinator;
@@ -27,6 +31,8 @@ export function bracketedCombinatorFromNothing() {
 
 export function bracketedConstructorFromNothing() {
   if (bracketedConstructor === null) {
+    const context = nominalContext; ///
+
     bracketedConstructor = literally((context) => {
       const bracketedConstructorString = `(${BASE_TYPE_SYMBOL})`,
             string = bracketedConstructorString,  ///
@@ -35,7 +41,7 @@ export function bracketedConstructorFromNothing() {
             bracketedConstructor = constructorFromConstructorNode(bracketedConstructorNode, context);
 
       return bracketedConstructor;
-    });
+    }, context);
   }
 
   return bracketedConstructor;