occam-verify-cli 1.0.611 → 1.0.617

package/src/element/equality.js

@@ -22,6 +22,13 @@ export default define(class Equality extends Element {
     return this.rightTerm;
   }
 
+  getEqualityNode() {
+    const node = this.getNode(),
+          equalityNde = node; ///
+
+    return equalityNde;
+  }
+
   getType() {
     let type;
 

package/src/element/equivalence.js

@@ -15,6 +15,7 @@ const { compress } = arrayUtilities;
 export default define(class Equivalence extends Element {
   constructor(context, string, node, terms) {
     super(context, string, node);
+
     this.terms = terms;
   }
 
@@ -22,6 +23,13 @@ export default define(class Equivalence extends Element {
     return this.terms;
   }
 
+  getEquivalenceNode() {
+    const node = this.getNode(),
+          equivalenceNode = node; ///
+
+    return equivalenceNode;
+  }
+
   getType() {
     const type = this.terms.reduce((type, term) => {
       const termType = term.getType();

package/src/element/equivalences.js

@@ -20,6 +20,13 @@ export default define(class Equivalences extends Element {
     return this.array;
   }
 
+  getEquivalencesNode() {
+    const node = this.getNode(),
+          equivalencesNode = node;  ///
+
+    return equivalencesNode;
+  }
+
   getLength() { return this.array.length; }
 
   getTypes() {

package/src/element/error.js

@@ -5,8 +5,11 @@ import { Element } from "occam-languages";
 import { define } from "../elements";
 
 export default define(class Error extends Element {
-  constructor(context, string, node) {
-    super(context, string, node);
+  getErrorNode() {
+    const node = this.getNode(),
+          errorNode = node; ///
+
+    return errorNode;
   }
 
   async verify() {

package/src/element/hypothesis.js

@@ -18,6 +18,13 @@ export default define(class Hypothesis extends Element {
     return this.statement;
   }
 
+  getHypothesisNode() {
+    const node = this.getNode(),
+          hypothesisNode = node;  ///
+
+    return hypothesisNode;
+  }
+
   verify(context) {
     let verifies = false;
 

package/src/element/judgement.js

@@ -21,9 +21,15 @@ export default define(class Judgement extends Element {
     return this.assumption;
   }
 
-  isSingular() {
+  getJudgementNode() {
     const node = this.getNode(),
-          judgementNode = node, ///
+          judgementNode = node; ///
+
+    return judgementNode;
+  }
+
+  isSingular() {
+    const judgementNode = this.getJudgementNode(),
           singular = judgementNode.isSingular();
 
     return singular;

package/src/element/label.js

@@ -16,6 +16,13 @@ export default define(class Label extends Element {
     return this.metavariable;
   }
 
+  getLabelNode() {
+    const node = this.getNode(),
+          labelNode = node; ///
+
+    return labelNode;
+  }
+
   getMetavariableName() { return this.metavariable.getName(); }
 
   getMetavariableNode() { return this.metavariable.getNode(); }

package/src/element/metaType.js

@@ -15,6 +15,13 @@ export default define(class MetaType extends Element {
     return this.name;
   }
 
+  getMetaTypeNode() {
+    const node = this.getNode(),
+          metaTypeNode = node;  ///
+
+    return metaTypeNode;
+  }
+
   isEqualTo(metaType) {
     const equalTo = (this === metaType);
 

package/src/element/metavariable.js

@@ -126,13 +126,13 @@ export default define(class Metavariable extends Element {
 
     context.trace(`Unifying the '${frameString}' frame with the '${metavariableString}' metavariable...`);
 
-    const metavariable = this, ///
-          frameMetavariableUnifies = this.unifyFrameMetavariable(frame, generalContext, specificContext);
+    const frameMetavariableUnifies = this.unifyFrameMetavariable(frame, generalContext, specificContext);
 
     if (frameMetavariableUnifies) {
       frameUnifies = true;
     } else {
-      const simpleSubstitution = context.findSimpleSubstitutionByMetavariable(metavariable);
+      const metavariableName = this.getMetavariableName(),
+            simpleSubstitution = context.findSimpleSubstitutionByMetavariableName(metavariableName);
 
       if (simpleSubstitution !== null) {
         const substitution = simpleSubstitution,  ///
@@ -143,14 +143,11 @@ export default define(class Metavariable extends Element {
         }
       } else {
         const { FrameSubstitution } = elements,
+              metavariable = this, ///
               frameSubstitution = FrameSubstitution.fromFrameAndMetavariable(frame, metavariable, context),
               framesubstitutionValidates = frameSubstitution.validate(generalContext, specificContext);
 
         if (framesubstitutionValidates) {
-          const substitution = frameSubstitution; ///
-
-          context.addSubstitution(substitution);
-
           frameUnifies = true;
         }
       }
@@ -211,10 +208,6 @@ export default define(class Metavariable extends Element {
         const statementSubstitutionValidates = statementSubstitution.validate(generalContext, specificContext);
 
         if (statementSubstitutionValidates) {
-          const substitution = statementSubstitution; ///
-
-          context.addSubstitution(substitution);
-
           statementUnifies = true;
         }
       }
@@ -236,16 +229,16 @@ export default define(class Metavariable extends Element {
 
     context.trace(`Unifying the '${referenceString}' reference with the '${metavariableString}' metavariable...`);
 
-    const metavariable = this, ///
-          referenceMetavariableUnifies = this.unifyReferenceMetavariable(reference, generalContext, specificContext);
+    const referenceMetavariableUnifies = this.unifyReferenceMetavariable(reference, generalContext, specificContext);
 
     if (referenceMetavariableUnifies) {
       referenceUnifies = true;
     } else {
-      const simpleSubstitutionPresent = context.isSimpleSubstitutionPresentByMetavariable(metavariable);
+      const metavariableName = this.getMetavariableName(),
+            simpleSubstitutionPresent = context.isSimpleSubstitutionPresentByMetavariableName(metavariableName);
 
       if (simpleSubstitutionPresent) {
-        const simpleSubstitution = context.findSimpleSubstitutionByMetavariable(metavariable),
+        const simpleSubstitution = context.findSimpleSubstitutionByMetavariableName(metavariableName),
               substitution = simpleSubstitution,  ///
               substitutionReferenceEqualToReference = substitution.isReferenceEqualToReference(reference);
 
@@ -254,12 +247,14 @@ export default define(class Metavariable extends Element {
         }
       } else {
         const { ReferenceSubstitution } = elements,
+              metavariable = this, ///
               referenceSubstitution = ReferenceSubstitution.fromReferenceAndMetavariable(reference, metavariable, context),
-              substitution = referenceSubstitution; ///
+              referenceSubstitutionValidates = referenceSubstitution.validate(generalContext, specificContext);
 
-        context.addSubstitution(substitution);
+        if (referenceSubstitutionValidates) {
+          referenceUnifies = true;
 
-        referenceUnifies = true;
+        }
       }
     }
 

package/src/element/parameter.js

@@ -20,6 +20,13 @@ export default define(class Parameter extends Element {
     return this.identifier;
   }
 
+  getParameterNode() {
+    const node = this.getNode(),
+          parameterNode = node; ///
+
+    return parameterNode;
+  }
+
   findPrimitive(substitutions) {
     let primitive = null;
 

package/src/element/procedureCall.js

@@ -24,7 +24,14 @@ export default define(class ProcedureCall extends Element {
     return this.procedureReference;
   }
 
-  getName() { return this.procedureReference.getName(); }
+  getProcedureCallNode() {
+    const node = this.getNode(),
+          procedureCallNode = node;
+
+    return procedureCallNode;
+  }
+
+  getProcedureName() { return this.procedureReference.getProcedureName(); }
 
   findPrimitives(context) {
     const substitutions = context.getSubstitutions(),
@@ -44,8 +51,8 @@ export default define(class ProcedureCall extends Element {
 
     context.trace(`Validating the '${procedureCallString}' procedure call...`);
 
-    const name = this.getName(),
-          procedure = context.findProcedureByName(name);
+    const procedureName = this.getProcedureName(),
+          procedure = context.findProcedureByProcedureName(procedureName);
 
     if (procedure !== null) {
       const procedureBoolean = procedure.isBoolean();
@@ -73,13 +80,13 @@ export default define(class ProcedureCall extends Element {
 
     context.trace(`Unifying the '${procedureCallString}' procedure call independently...`);
 
-    const name = this.getName(),
-          primitives = this.findPrimitives(context),
-          terms = termsFromPrimitives(primitives),
-          procedure = context.findProcedureByName(name);
+    const procedureName = this.getProcedureName(),
+          procedure = context.findProcedureByProcedureName(procedureName);
 
-    try {
-      const term = await procedure.call(terms, context),
+    // try {
+      const primitives = this.findPrimitives(context),
+            terms = termsFromPrimitives(primitives),
+            term = await procedure.call(terms, context),
             boolean = term.isBoolean();
 
       if (!boolean) {
@@ -91,11 +98,11 @@ export default define(class ProcedureCall extends Element {
           unifiesIndependently = true;
         }
       }
-    } catch (exception) {
-      const message = exception.getMessage();
-
-      context.info(message);
-    }
+    // } catch (exception) {
+    //   const message = exception.getMessage();
+    //
+    //   context.info(message);
+    // }
 
     if (unifiesIndependently) {
       context.debug(`...unified the '${procedureCallString}' procedure call independently.`);

package/src/element/procedureReference.js

@@ -14,6 +14,19 @@ export default define(class ProcedureReference extends Element {
     return this.name;
   }
 
+  getProcedureReferenceNode() {
+    const node = this.getNode(),
+          procedureReferenceNode = node;  ///
+
+    return procedureReferenceNode;
+  }
+
+  getProcedureName() {
+    const procedureName = this.name;  ///
+
+    return procedureName;
+  }
+
   toJSON() {
     const name = this.name,
           json = {

package/src/element/proof.js

@@ -16,6 +16,13 @@ export default define(class Proof extends Element {
     return this.derivation;
   }
 
+  getProofNode() {
+    const node = this.getNode(),
+          proofNode = node; ///
+
+    return proofNode;
+  }
+
   getLastProofAssertion() { return this.derivation.getLastProofAssertion(); }
 
   getStatement() {

package/src/element/proofAssertion/premise.js

@@ -17,6 +17,13 @@ export default define(class Premise extends ProofAssertion {
     return this.procedureCall;
   }
 
+  getPremiseNode() {
+    const node = this.getNode(),
+          premiseNode = node; ///
+
+    return premiseNode;
+  }
+
   isStated() {
     const stated = true; ///
 

package/src/element/proofAssertion/step.js

@@ -27,6 +27,13 @@ export default define(class Step extends ProofAssertion {
     return this.satisfiesAssertion;
   }
 
+  getStepNode() {
+    const node = this.getNode(),
+          stepNode = node;  ///
+
+    return stepNode;
+  }
+
   isSatisfied() {
     const satisfied = (this.satisfiesAssertion !== null);
 

package/src/element/proofAssertion/supposition.js

@@ -17,6 +17,13 @@ export default define(class Supposition extends ProofAssertion {
     return this.procedureCall;
   }
 
+  getSuppositionNode() {
+    const node = this.getNode(),
+          suppositionNode = node; ///
+
+    return suppositionNode;
+  }
+
   isStated() {
     const stated = true; ///
 

package/src/element/proofAssertion.js

@@ -15,6 +15,13 @@ export default class ProofAssertion extends Element {
     return this.statement;
   }
 
+  getProofAssertionNode() {
+    const node = this.getNode(),
+          proofAssertionNode = node;  ///
+
+    return proofAssertionNode;
+  }
+
   isProofAssertion() {
     const proofAssertion = true;
 

package/src/element/property.js

@@ -20,6 +20,13 @@ export default define(class Property extends Element {
     return this.nominalTypeName;
   }
 
+  getPropertyNode() {
+    const node = this.getNode(),
+          properetyNode = node; ///
+
+    return properetyNode;
+  }
+
   comparePropertyName(propertyName) {
     const comparesToPropertyName = (this.name === propertyName);
 

package/src/element/propertyRelation.js

@@ -20,6 +20,13 @@ export default define(class PropertyRelation extends Element {
     return this.term;
   }
 
+  getPropertyRelationNode() {
+    const node = this.getNode(),
+          propertyRelationNode = node;  ///
+
+    return propertyRelationNode;
+  }
+
   verify(context) {
     let verifies = false;
 

package/src/element/reference.js

@@ -20,6 +20,14 @@ export default define(class Reference extends Element {
     return this.metavariable;
   }
 
+  getReferenceNode() {
+    const node = this.getNode(),
+          referenceNode = node; ///
+
+    return referenceNode;
+  }
+
+
   getName() { return this.metavariable.getName(); }
 
   getMetavariableName() {
@@ -34,13 +42,6 @@ export default define(class Reference extends Element {
     return metavariableNode;
   }
 
-  getReferenceNode() {
-    const node = this.getNode(),
-          assertionNode = node; ///
-
-    return assertionNode;
-  }
-
   matchReferenceNode(assertionNode) {
     const assertionNodeA = assertionNode; ///
 

package/src/element/rule.js

@@ -43,6 +43,13 @@ export default define(class Rule extends Element {
     return this.conclusion;
   }
 
+  getRuleNode() {
+    const node = this.getNode(),
+          ruleNode = node;  ///
+
+    return ruleNode;
+  }
+
   compareMetavariableName(metavariableName) {
     const comparesToMetavariableName = this.labels.some((label) => {
       const labelComparesToMetavariableName = label.compareMetavariableName(metavariableName);
@@ -221,15 +228,7 @@ export default define(class Rule extends Element {
       const subproofOrProofAssertionsUnifiesWithPremises = await this.unifySubproofOrProofAssertionsWithPremises(subproofOrProofAssertions, context);
 
       if (subproofOrProofAssertionsUnifiesWithPremises) {
-        const specificContext = context;  ///
-
-        context = this.getContext();
-
-        const generalContext = context; ///
-
-        context = specificContext;  ///
-
-        const substitutionsResolved = context.areSubstitutionsResolved(generalContext, specificContext);
+        const substitutionsResolved = context.areSubstitutionsResolved();
 
         if (substitutionsResolved) {
           statementAndSubproofOrProofAssertionsUnify = true;

package/src/element/section.js

@@ -35,6 +35,13 @@ export default define(class Section extends Element {
     return this.conjecture;
   }
 
+  getSectionNode() {
+    const node = this.getNode(),
+          sectionNode = node; ///
+
+    return sectionNode;
+  }
+
   verifyHypotheses() {
     const hypothesesVerify = this.hypotheses.every((hypothesis) => {
       const hypothesisVerifies = hypothesis.verify(this.context);

package/src/element/signature.js

@@ -20,6 +20,13 @@ export default define(class Signature extends Element {
     return this.terms;
   }
 
+  getSignatureNode() {
+    const node = this.getNode(),
+          signatureNode = node; ///
+
+    return signatureNode;
+  }
+
   verify(context) {
     let verifies;
 

package/src/element/statement.js

@@ -11,30 +11,25 @@ import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 const { match, backwardsSome } = arrayUtilities;
 
 export default define(class Statement extends Element {
-  constructor(context, string, node) {
-    super(context, string, node);
-  }
-
-  isSingular() {
+  getStatementNode() {
     const node = this.getNode(),
-          statementNode = node, ///
-          singular = statementNode.isSingular();
+          statementNode = node; ///
 
-    return singular;
+    return statementNode;
   }
 
   getMetavariableName() {
-    const node = this.getNode(),
-          metavariableName = node.getMetavariableName();
+    const sttaementNode = this.getStatementNode(),
+          metavariableName = sttaementNode.getMetavariableName();
 
     return metavariableName;
   }
 
-  getStatementNode() {
-    const node = this.getNode(),
-          statementNode = node; ///
+  isSingular() {
+    const statementNode = this.getStatementNode(),
+          singular = statementNode.isSingular();
 
-    return statementNode;
+    return singular;
   }
 
   matchStatementNode(statementNode) {

package/src/element/subDerivation.js

@@ -20,6 +20,13 @@ export default define(class SubDerivation extends Element {
     return this.subproofOrProofAssertions;
   }
 
+  getSubDerivationNode() {
+    const node = this.getNode(),
+          subDerivationNode = node; ///
+
+    return subDerivationNode;
+  }
+
   getLastProofAssertion() {
     const lastSubproofOrProofAssertion = last(this.subproofOrProofAssertions),
           lastProofAssertion = lastSubproofOrProofAssertion;  ///

package/src/element/subproof.js

@@ -21,6 +21,13 @@ export default define(class Subproof extends Element {
     return this.subDerivation;
   }
 
+  getSubproofNode() {
+    const node = this.getNode(),
+          subproofNode = node;  ///
+
+    return subproofNode;
+  }
+
   getLastProofAssertion() { return this.subDerivation.getLastProofAssertion(); }
 
   getStatements() {

package/src/element/substitution/frame.js

@@ -24,6 +24,13 @@ export default define(class FrameSubstitution extends Substitution {
     return this.replacementFrame;
   }
 
+  getFrameSubstitutionNode() {
+    const node = this.getNode(),
+          frameSubstitutionNode = node; ///
+
+    return frameSubstitutionNode;
+  }
+
   getTargetNode() {
     const targetFrameNode = this.targetFrame.getNode(),
           tergetNode = targetFrameNode; ///
@@ -92,9 +99,9 @@ export default define(class FrameSubstitution extends Substitution {
       }
 
       if (validates) {
-        const substititoin = this;  ///
+        const substitution = this;  ///
 
-        context.addSubstitution(substititoin);
+        context.addSubstitution(substitution);
 
         context.debug(`...validated the '${frameSubstitutionString}' frame substitution.`);
       }
@@ -145,7 +152,7 @@ export default define(class FrameSubstitution extends Substitution {
     replacementFrameValidates = this.replacementFrame.validate(assignments, stated, context);
 
     if (replacementFrameValidates) {
-      context.debug(`...validated the '${frameSubstitutionString}' frame subtitution's '${replacementFrameString}' replacement frame...`);
+      context.debug(`...validated the '${frameSubstitutionString}' frame subtitution's '${replacementFrameString}' replacement frame.`);
     }
 
     return replacementFrameValidates;

package/src/element/substitution/reference.js

@@ -24,6 +24,13 @@ export default define(class ReferenceSubstitution extends Substitution {
     return this.replacementReference;
   }
 
+  getReferenceSubstitutionNode() {
+    const node = this.getNode(),
+          referenceSubstitution = node; ///
+
+    return referenceSubstitution;
+  }
+
   getTargetNode() {
     const targetReferenceNode = this.targetReference.getNode(),
           tergetNode = targetReferenceNode; ///
@@ -92,9 +99,9 @@ export default define(class ReferenceSubstitution extends Substitution {
       }
 
       if (validates) {
-        const substititoin = this;  ///
+        const subsitution = this;  ///
 
-        context.addSubstitution(substititoin);
+        context.addSubstitution(subsitution);
 
         context.debug(`...validated the '${referenceSubstitutionString}' reference substitution.`);
       }
@@ -139,7 +146,7 @@ export default define(class ReferenceSubstitution extends Substitution {
     replacementReferenceValidates = this.replacementReference.validate(context);
 
     if (replacementReferenceValidates) {
-      context.debug(`...validated the '${referenceSubstitutionString}' reference subtitution's '${replacementReferenceString}' replacement reference...`);
+      context.debug(`...validated the '${referenceSubstitutionString}' reference subtitution's '${replacementReferenceString}' replacement reference.`);
     }
 
     return replacementReferenceValidates;