occam-verify-cli 1.0.428 → 1.0.436

package/src/element/procedureCall.js

@@ -2,27 +2,18 @@
 
 import { Expressions } from "occam-furtle";
 
-import elements from "../elements";
+import Element from "../element";
 
 import { define } from "../elements";
 import { parametersFromJSON, procedureReferenceFromJSON, parametersToParametersJSON, procedureReferenceToProcedureReferenceJSON } from "../utilities/json";
 
-export default define(class ProcedureCall {
-  constructor(string, node, parameters, procedureReference) {
-    this.string = string;
-    this.node = node;
+export default define(class ProcedureCall extends Element {
+  constructor(context, string, node, parameters, procedureReference) {
+    super(context, string, node);
     this.parameters = parameters;
     this.procedureReference = procedureReference;
   }
 
-  getString() {
-    return this.string;
-  }
-
-  getNode() {
-    return this.node;
-  }
-
   getParameters() {
     return this.parameters;
   }
@@ -122,71 +113,8 @@ export default define(class ProcedureCall {
           parameters = parametersFromJSON(json, context),
           procedureReference = procedureReferenceFromJSON(json, context),
           string = stringFromProcedureReferenceAndParameters(procedureReference, parameters),
-          procedureCall = new ProcedureCall(string, node, parameters, procedureReference);
-
-    return procedureCall;
-  }
-
-  static fromPremiseNode(premiseNode, context) {
-    let procedureCall = null;
-
-    const procedureCallNode = premiseNode.getProcedureCallNode();
-
-    if (procedureCallNode !== null) {
-      procedureCall = procedureCallFromProcedureCallNode(procedureCallNode, context);
-    }
-
-    return procedureCall;
-  }
-
-  static fromSuppositionNode(suppositionNode, context) {
-    let procedureCall = null;
-
-    const procedureCallNode = suppositionNode.getProcedureCallNode();
-
-    if (procedureCallNode !== null) {
-      procedureCall = procedureCallFromProcedureCallNode(procedureCallNode, context);
-    }
+          procedureCall = new ProcedureCall(context, string, node, parameters, procedureReference);
 
     return procedureCall;
   }
 });
-
-function procedureCallFromProcedureCallNode(procedureCallNode, context) {
-  const { ProcedureCall, ProcedureReference } = elements,
-        node = procedureCallNode, ///
-        parameters = parametersFromProcedureCallNode(procedureCallNode, context),
-        procedureReference = ProcedureReference.fromProcedureCallNode(procedureCallNode, context),
-        string = stringFromProcedureReferenceAndParameters(procedureReference, parameters),
-        procedureCall = new ProcedureCall(string, node, parameters, procedureReference);
-
-  return procedureCall;
-}
-
-function parametersFromProcedureCallNode(procedureCallNode, context) {
-  const { Parameter } = elements,
-        parameterNodes = procedureCallNode.getParameterNodes(),
-        parameters = parameterNodes.map((parameterNode) => {
-          const parameter = Parameter.fromParameterNode(parameterNode, context);
-
-          return parameter;
-        });
-
-  return parameters;
-}
-
-function stringFromProcedureReferenceAndParameters(procedureReference, parameters) {
-  const name = procedureReference.getName(),
-        parametersString = parameters.reduce((parametersString, parameter) => {
-          const parameterString = parameter.getString();
-
-          parametersString = (parametersString === null) ?
-                                parameterString : ///
-                                  `${parametersString}, ${parameterString}`;
-
-          return parametersString;
-        }, null),
-        string = `${name}(${parametersString})`;
-
-  return string;
-}

package/src/element/procedureReference.js

@@ -1,17 +1,15 @@
 "use strict";
 
+import Element from "../element";
+
 import { define } from "../elements";
 
-export default define(class ProcedureReference {
-  constructor(string, name) {
-    this.string = string;
+export default define(class ProcedureReference extends Element {
+  constructor(context, string, node, name) {
+    super(context, string, node);
     this.name = name;
   }
 
-  getString() {
-    return this.string;
-  }
-
   getName() {
     return this.name;
   }
@@ -30,16 +28,8 @@ export default define(class ProcedureReference {
   static fromJSON(json, context) {
     const { name } = json,
           string = name,  ///
-          procedureReference = new ProcedureReference(string, name);
-
-    return procedureReference;
-  }
-
-  static fromProcedureCallNode(procedureCallNode, context) {
-    const procedureName = procedureCallNode.getProcedureName(),
-          name = procedureName, ///
-          string = name,  ///
-          procedureReference = new ProcedureReference(string, name);
+          node = null,
+          procedureReference = new ProcedureReference(context, string, node, name);
 
     return procedureReference;
   }

package/src/element/proof.js

@@ -1,12 +1,14 @@
 "use strict";
 
-import elements from "../elements";
+import Element from "../element";
 import LocalContext from "../context/local";
 
 import { define } from "../elements";
 
-export default define(class Proof {
-  constructor(derivation) {
+export default define(class Proof extends Element {
+  constructor(context, string, node, derivation) {
+    super(context, string, node);
+
     this.derivation = derivation;
   }
 
@@ -51,18 +53,4 @@ export default define(class Proof {
   }
 
   static name = "Proof";
-
-  static fromProofNode(proofNode, context) {
-    let proof = null;
-
-    if (proofNode !== null) {
-      const { Derivation } = elements,
-            derivationNode = proofNode.getDerivationNode(),
-            derivation = Derivation.fromDerivationNode(derivationNode, context);
-
-      proof = new Proof(derivation);
-    }
-
-    return proof;
-  }
 });

package/src/element/property.js

@@ -1,23 +1,17 @@
 "use strict";
 
+import Element from "../element";
+
 import { define } from "../elements";
 
-export default define(class Property {
-  constructor(string, node, name, nominalTypeName) {
-    this.string = string;
-    this.node = node;
+export default define(class Property extends Element {
+  constructor(context, string, node, name, nominalTypeName) {
+    super(context, string, node);
+
     this.name = name;
     this.nominalTypeName = nominalTypeName;
   }
 
-  getString() {
-    return this.string;
-  }
-
-  getNode() {
-    return this.node;
-  }
-
   getName() {
     return this.name;
   }
@@ -54,24 +48,8 @@ export default define(class Property {
   static fromJSON(json, context) {
     const { name, nominalTypeName } = json,
           string = name, ///
-          property = new Property(string, name, nominalTypeName);
-
-    return property;
-  }
-
-  static fromPropertyRelationNode(propertyRelationNode, context) {
-    const propertyNode = propertyRelationNode.getPropertyNode(),
-          property = propertyFromPropertyNode(propertyNode, context);
-
-    return property;
-  }
-
-  static fromPropertyDeclarationNode(propertyDeclarationNode, context) {
-    const propertyName = propertyDeclarationNode.getPropertyName(),
-          nominalTypeName = propertyDeclarationNode.getNominalTypeName(),
-          name = propertyName,  ///
-          string = name,  ///
-          property = new Property(string, name, nominalTypeName);
+          node = null,
+          property = new Property(context, string, node, name, nominalTypeName);
 
     return property;
   }

package/src/element/propertyRelation.js

@@ -1,25 +1,17 @@
 "use strict";
 
-import elements from "../elements";
+import Element from "../element";
 
 import { define } from "../elements";
 
-export default define(class PropertyRelation {
-  constructor(string, node, property, term) {
-    this.string = string;
-    this.node = node;
+export default define(class PropertyRelation extends Element {
+  constructor(context, string, node, property, term) {
+    super(context, string, node);
+
     this.property = property;
     this.term = term;
   }
 
-  getString() {
-    return this.string;
-  }
-
-  getNode() {
-    return this.node;
-  }
-
   getProperty() {
     return this.property;
   }
@@ -28,14 +20,6 @@ export default define(class PropertyRelation {
     return this.term;
   }
 
-  isEqualTo(propertyRelation) {
-    const propertyRelationNode = propertyRelation.getNode(),
-          matches = this.node.match(propertyRelationNode),
-          equalTo = matches;  ///
-
-    return equalTo;
-  }
-
   verify(context) {
     let verifies = false;
 
@@ -113,16 +97,4 @@ export default define(class PropertyRelation {
   }
 
   static name = "PropertyRelation";
-
-  static fromPropertyAssertionNode(propertyAssertionNode, context) {
-    const { Term, Property } = elements,
-          propertyRelationNode = propertyAssertionNode.getPropertyRelationNode(),
-          node = propertyRelationNode,  ///
-          string = context.nodeAsString(node),
-          property = Property.fromPropertyRelationNode(propertyRelationNode, context),
-          term = Term.fromPropertyRelationNode(propertyRelationNode, context),
-          propertyRelation = new PropertyRelation(string, node, property, term);
-
-    return propertyRelation;
-  }
 });

package/src/element/reference.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import Element from "../element";
 import elements from "../elements";
 
 import { define } from "../elements";
@@ -7,8 +8,10 @@ import { referenceMetaType } from ".//metaType";
 import { unifyMetavariableIntrinsically } from "../process/unify";
 import { metavariableFromJSON, metavariableToMetavariableJSON } from "../utilities/json";
 
-export default define(class Reference {
-  constructor(metavariable) {
+export default define(class Reference extends Element {
+  constructor(context, string, node, metavariable) {
+    super(context, string, node);
+
     this.metavariable = metavariable;
   }
 
@@ -18,10 +21,6 @@ export default define(class Reference {
 
   getName() { return this.metavariable.getName(); }
 
-  getName() { return this.metavariable.getName(); }
-
-  getString() { return this.metavariable.getString(); }
-
   getMetavariableName() {
     const metavariableName = this.metavariable.getName();
 
@@ -34,14 +33,6 @@ export default define(class Reference {
     return metavariableNode;
   }
 
-  isEqualTo(refernece) {
-    const metavariable = refernece.getMetavariable(),
-          metavariableEqualToMetvariable = this.metavariable.isEqualTo(metavariable),
-          equalTo = metavariableEqualToMetvariable; ///
-
-    return equalTo;
-  }
-
   isMetavariableEqualToMetavariable(metavariable) { return this.metavariable.isEqualTo(metavariable); }
 
   matchMetavariableName(metavariableName) { return this.metavariable.matchMetavariableName(metavariableName); }
@@ -194,65 +185,10 @@ export default define(class Reference {
 
   static fromJSON(json, context) {
     const metavariable = metavariableFromJSON(json, context),
-          reference = new Reference(metavariable);
-
-    return reference;
-  }
-
-  static fromStepNode(stepNode, context) {
-    let reference = null;
-
-    const referenceNode = stepNode.getReferenceNode();
-
-    if (referenceNode !== null) {
-      reference = referenceFromReferenceNode(referenceNode, context);
-    }
-
-    return reference;
-  }
-
-  static fromAssumptionNode(assumptionNode, context) {
-    let reference = null;
-
-    const metavariableNode = assumptionNode.getMetavariableNode();
-
-    if (metavariableNode !== null) {
-      reference = referenceFromMetavariableNode(metavariableNode, context);
-    }
-
-    return reference;
-  }
-
-  static fromMetavariableNode(metavariableNode, context) {
-    const reference = referenceFromMetavariableNode(metavariableNode, context);
-
-    return reference;
-  }
-
-  static fromProcedureCallNode(procedureCallNode, context) {
-    let reference = null;
-
-    const referenceNode = procedureCallNode.getReferenceNode();
-
-    if (referenceNode !== null) {
-      reference = referenceFromReferenceNode(referenceNode, context);
-    }
-
-    return reference;
-  }
-
-  static fromSatisfiesAssertionNode(satisfiesAssertionNode, context) {
-    const metavariableNode = satisfiesAssertionNode.getMetavariableNode(),
-          reference = referenceFromMetavariableNode(metavariableNode, context);
+          string = metavariable.getString(),
+          node = metavariable.getNode(),
+          reference = new Reference(context, string, node, metavariable);
 
     return reference;
   }
 });
-
-function referenceFromMetavariableNode(metavariableNode, context) {
-  const { Reference, Metavariable } = elements,
-        metavariable = Metavariable.fromMetavariableNode(metavariableNode, context),
-        reference = new Reference(metavariable);
-
-  return reference;
-}

package/src/element/rule.js

@@ -2,11 +2,11 @@
 
 import { arrayUtilities } from "necessary";
 
+import Element from "../element";
 import elements from "../elements";
 import LocalContext from "../context/local";
 
 import { define } from "../elements";
-import { labelsStringFromLabels } from "./axiomLemmaTheoremConjecture";
 import { labelsFromJSON,
          premisesFromJSON,
          conclusionFromJSON,
@@ -16,29 +16,16 @@ import { labelsFromJSON,
 
 const { reverse, extract, backwardsEvery } = arrayUtilities;
 
-export default define(class Rule {
+export default define(class Rule extends Element {
   constructor(context, string, node, labels, premises, conclusion, proof) {
-    this.context = context;
-    this.string = string;
-    this.node = node;
+    super(context, string, node);
+
     this.labels = labels;
     this.premises = premises;
     this.conclusion = conclusion;
     this.proof = proof;
   }
 
-  getContext() {
-    return this.context;
-  }
-
-  getNode() {
-    return this.node;
-  }
-
-  getString() {
-    return this.string;
-  }
-
   getLabels() {
     return this.labels;
   }
@@ -319,27 +306,3 @@ function conclusionFromRuleNode(ruleNode, context) {
   return conclusion;
 }
 
-function premisesStringFromPremises(premises) {
-  const premisesString = premises.reduce((premisesString, premise) => {
-    const premiseString = premise.getString();
-
-    premisesString = (premisesString !== null) ?
-                       `${premisesString}, ${premiseString}` :
-                         premiseString;  ///
-
-    return premisesString;
-  }, null);
-
-  return premisesString;
-}
-
-function stringFromLabelsPremisesAndConclusion(labels, premises, conclusion) {
-  const premisesString = premisesStringFromPremises(premises),
-        conclusionString = conclusion.getString(),
-        labelsString = labelsStringFromLabels(labels),
-        string = (premisesString !== null) ?
-                    `${labelsString} :: [${premisesString}] ... ${conclusionString}` :
-                      `${labelsString} :: ${conclusionString}`;
-
-  return string;
-}

package/src/element/section.js

@@ -1,15 +1,13 @@
 "use strict";
 
-import elements from "../elements";
-import LocalContext from "../context/local";
+import Element from "../element";
 
 import { define } from "../elements";
 
-export default define(class Section {
+export default define(class Section extends Element {
   constructor(context, string, node, hypotheses, axiom, lemma, theorem, conjecture) {
-    this.context = context;
-    this.string = string;
-    this.node = node;
+    super(context, string, node);
+
     this.hypotheses = hypotheses;
     this.axiom = axiom;
     this.lemma = lemma;
@@ -17,18 +15,6 @@ export default define(class Section {
     this.conjecture = conjecture;
   }
 
-  getContext() {
-    return this.context;
-  }
-
-  getNode() {
-    return this.node;
-  }
-
-  getString() {
-    return this.string;
-  }
-
   getHypotheses() {
     return this.hypotheses;
   }
@@ -89,115 +75,4 @@ export default define(class Section {
   }
 
   static name = "Section";
-
-  static fromSectionNode(sectionNode, context) {
-    const localContext = LocalContext.fromNothing(context);
-
-    context = localContext; ///
-
-    const hypothesisNodes = sectionNode.getHypothesisNodes(),
-          hypotheses = hypothesesFromHypothesisNodes(hypothesisNodes, context),
-          axiom = axiomFroSectionNode(sectionNode, context),
-          lemma = lemmaFroSectionNode(sectionNode, context),
-          theorem = theoremFroSectionNode(sectionNode, context),
-          conjecture = conjectureFroSectionNode(sectionNode, context),
-          node = sectionNode, ///
-          string = stringFromHypothesesAxiomLemmaTheoremAndConjecture(hypotheses, axiom, lemma, theorem, conjecture, context),
-          section = new Section(context, string, node, hypotheses, axiom, lemma, theorem, conjecture);
-
-    return section;
-  }
 });
-
-function axiomFroSectionNode(sectionNode, context) {
-  let axiom = null;
-
-  const axiomNode = sectionNode.getAxiomNode();
-
-  if (axiomNode !== null) {
-    const { Axiom } = elements;
-
-    axiom = Axiom.fromAxiomNode(axiomNode, context);
-  }
-
-  return axiom;
-}
-
-function lemmaFroSectionNode(sectionNode, context) {
-  let lemma = null;
-
-  const lemmaNode = sectionNode.getLemmaNode();
-
-  if (lemmaNode !== null) {
-    const { Lemma } = elements;
-
-    lemma = Lemma.fromLemmaNode(lemmaNode, context);
-  }
-
-  return lemma;
-}
-
-function theoremFroSectionNode(sectionNode, context) {
-  let theorem = null;
-
-  const theoremNode = sectionNode.getTheoremNode();
-
-  if (theoremNode !== null) {
-    const { Theorem } = elements;
-
-    theorem = Theorem.fromTheoremNode(theoremNode, context);
-  }
-
-  return theorem;
-}
-
-function conjectureFroSectionNode(sectionNode, context) {
-  let conjecture = null;
-
-  const conjectureNode = sectionNode.getConjectureNode();
-
-  if (conjectureNode !== null) {
-    const { Conjecture } = elements;
-
-    conjecture = Conjecture.fromConjectureNode(conjectureNode, context);
-  }
-
-  return conjecture;
-}
-
-function hypothesesFromHypothesisNodes(hypothesisNodes, context) {
-  const hypotheses = hypothesisNodes.map((hypothesisNode) => {
-    const { Hypothesis } = elements,
-          hypothesis = Hypothesis.fromHypothesisNode(hypothesisNode, context);
-
-    return hypothesis;
-  });
-
-  return hypotheses;
-}
-
-function hypothesesStringFromHypotheses(hypotheses, context) {
-  const hypothesesString = hypotheses.reduce((hypothesesString, hypothesis) => {
-    const hypothesisString = hypothesis.getString();
-
-    hypothesesString = (hypothesesString !== null) ?
-                         `${hypothesesString}, ${hypothesisString}` :
-                           hypothesisString;  ///
-
-    return hypothesesString;
-  }, null);
-
-  return hypothesesString;
-}
-
-function stringFromHypothesesAxiomLemmaTheoremAndConjecture(hypotheses, axiom, lemma, theorem, conjecture, context) {
-  const axiomLemmaTheoremOrConjecture = (axiom || lemma || theorem || conjecture),
-        axiomLemmaTheoremOrConjectureString = axiomLemmaTheoremOrConjecture.getString(),
-        hypothesesString = hypothesesStringFromHypotheses(hypotheses, context),
-        string = (axiomLemmaTheoremOrConjectureString !== null) ?
-                   `[${hypothesesString}]::: ${axiomLemmaTheoremOrConjectureString}` :
-                     `[${hypothesesString}]::: `;
-
-
-  return string;
-}

package/src/element/signature.js

@@ -2,6 +2,7 @@
 
 import { arrayUtilities } from "necessary";
 
+import Element from "../element";
 import elements from "../elements";
 
 import { define } from "../elements";
@@ -10,19 +11,11 @@ import { termsFromJSON, termsToTermsJSON } from "../utilities/json";
 
 const { match, compare, correlate } = arrayUtilities;
 
-export default define(class Signature {
-  constructor(string, node, terms) {
-    this.string = string;
-    this.node = node;
-    this.terms = terms;
-  }
+export default define(class Signature extends Element {
+  constructor(context, string, node, terms) {
+    super(context, string, node);
 
-  getString() {
-    return this.string;
-  }
-
-  getNode() {
-    return this.node;
+    this.terms = terms;
   }
 
   getTerms() {
@@ -160,7 +153,8 @@ export default define(class Signature {
     const terms = termsFromJSON(json, context),
           signatureString = signatureStringFromTerms(terms),
           string = signatureString, ///
-          signature = new Signature(string, terms);
+          node = null,
+          signature = new Signature(context, string, node, terms);
 
     return signature;
   }