occam-verify-cli 1.0.427 → 1.0.436

package/src/element/metavariable.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import Element from "../element";
 import elements from "../elements";
 
 import { define } from "../elements";
@@ -9,23 +10,15 @@ import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
 import { metaTypeFromJSON, metaTypeToMetaTypeJSON } from "../utilities/json";
 import { unifyMetavariable, unifyMetavariableIntrinsically } from "../process/unify";
 
-export default define(class Metavariable {
-  constructor(string, node, name, type, metaType) {
-    this.string = string;
-    this.node = node;
+export default define(class Metavariable extends Element {
+  constructor(context, string, node, name, type, metaType) {
+    super(context, string, node);
+    
     this.name = name;
     this.type = type;
     this.metaType = metaType;
   }
 
-  getString() {
-    return this.string;
-  }
-
-  getNode() {
-    return this.node;
-  }
-
   getName() {
     return this.name;
   }
@@ -62,14 +55,6 @@ export default define(class Metavariable {
 
   isMetaTypeEqualTo(metaType) { return this.metaType.isEqualTo(metaType); }
 
-  isEqualTo(metavariable) {
-    const metavariableNode = metavariable.getNode(),
-          matches = this.node.match(metavariableNode),
-          equalTo = matches;  ///
-
-    return equalTo;
-  }
-
   verify(context) {
     let verifies;
 
@@ -411,80 +396,7 @@ export default define(class Metavariable {
           node = metavariableNode,  ///
           type = typeFromJSON(json, context),
           metaType = metaTypeFromJSON(json, context),
-          metavariable = new Metavariable(string, node, name, type, metaType);
-
-    return metavariable;
-  }
-
-  static fromLabelNode(labelNode, context) {
-    const metavariableNode = labelNode.getMetavariableNode(),
-          metavariable = metavariableFromMetavariableNode(metavariableNode, context);
-
-    return metavariable;
-  }
-
-  static fromFrameNode(frameNode, context) {
-    let metavariable = null;
-
-    const singularMetavariableNode = frameNode.getSingularMetavariableNode();
-
-    if (singularMetavariableNode !== null) {
-      const metavariableNode = singularMetavariableNode;  ///
-
-      metavariable = metavariableFromMetavariableNode(metavariableNode, context);
-    }
-
-    return metavariable;
-  }
-
-  static fromReferenceNode(referenceNode, context) {
-    const metavariableNode = referenceNode.getMetavariableNode(),
-          metavariable = metavariableFromMetavariableNode(metavariableNode, context);
-
-    return metavariable;
-  }
-
-  static fromStatementNode(statementNode, context) {
-    let metavariable = null;
-
-    const singularMetavariableNode = statementNode.getSingularMetavariableNode();
-
-    if (singularMetavariableNode !== null) {
-      const metavariableNode = singularMetavariableNode;  ///
-
-      metavariable = metavariableFromMetavariableNode(metavariableNode, context);
-    }
-
-    return metavariable;
-  }
-
-  static fromAssumptionNode(assumptionNode, context) {
-    const metavariableNode = assumptionNode.getMetavariableNode(),
-          metavariable = metavariableFromMetavariableNode(metavariableNode, context);
-
-    return metavariable;
-  }
-
-  static fromMetavariableNode(metavariableNode, context) {
-    let metavariable = null;
-
-    if (metavariableNode !== null) {
-      metavariable = metavariableFromMetavariableNode(metavariableNode, context);
-    }
-
-    return metavariable;
-  }
-
-  static fromMetavariableDeclarationNode(metavariableDeclarationNode, context) {
-    const { MetaType } = elements,
-          metavariableNode = metavariableDeclarationNode.getMetavariableNode(),
-          type = typeFromMetavariableDeclarationNode(metavariableDeclarationNode, context),
-          metaType = MetaType.fromMetavariableDeclarationNode(metavariableDeclarationNode, context),
-          metavariable = metavariableFromMetavariableNode(metavariableNode, context);
-
-    metavariable.setType(type);
-
-    metavariable.setMetaType(metaType);
+          metavariable = new Metavariable(context, string, node, name, type, metaType);
 
     return metavariable;
   }

package/src/element/parameter.js

@@ -1,22 +1,20 @@
 "use strict";
 
+import Element from "../element";
+
 import { define } from "../elements";
 
-export default define(class Parameter {
-  constructor(name) {
+export default define(class Parameter extends Element {
+  constructor(context, string, node, name) {
+    super(context, string, node);
+
     this.name = name;
   }
-
+  
   getName() {
     return this.name;
   }
 
-  getString() {
-    const string = this.name; ///
-
-    return string;
-  }
-
   findReplacementNode(substitutions) {
     let replacementNode = null;
 
@@ -49,15 +47,9 @@ export default define(class Parameter {
 
   static fromJSON(json, context) {
     const { name } = json,
-          parameter = new Parameter(name);
-
-    return parameter;
-  }
-
-  static fromParameterNode(parameterNode, context) {
-    const parameterName = parameterNode.getParameterName(),
-          name = parameterName, ///
-          parameter = new Parameter(name);
+          string = null,
+          node = null,
+          parameter = new Parameter(context, string, node, name);
 
     return parameter;
   }

package/src/element/premise.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import Element from "../element";
 import elements from "../elements";
 import TemporaryContext from "../context/temporary";
 import assignAssignments from "../process/assign";
@@ -8,27 +9,14 @@ import { define } from "../elements";
 import { subproofAssertionFromStatement } from "../utilities/statement";
 import { termsFromJSON, framesFromJSON, statementFromJSON, procedureCallFromJSON, termsToTermsJSON, framesToFramesJSON, statementToStatementJSON, procedureCallToProcedureCallJSON } from "../utilities/json";
 
-export default define(class Premise {
+export default define(class Premise extends Element {
   constructor(context, string, node, statement, procedureCall) {
-    this.context = context;
-    this.string = string;
-    this.node = node;
+    super(context, string, node);
+
     this.statement = statement;
     this.procedureCall = procedureCall;
   }
 
-  getContext() {
-    return this.context;
-  }
-
-  getString() {
-    return this.string;
-  }
-
-  getNode() {
-    return this.node;
-  }
-
   getStatement() {
     return this.statement;
   }
@@ -277,19 +265,4 @@ export default define(class Premise {
 
     return premise;
   }
-
-  static fromPremiseNode(premiseNode, context) {
-    const { Statement, ProcedureCall } = elements,
-          node = premiseNode, ///
-          string = context.nodeAsString(node),
-          statement = Statement.fromPremiseNode(premiseNode, context),
-          procedureCall = ProcedureCall.fromPremiseNode(premiseNode, context),
-          temporaryContext = null;
-
-    context = temporaryContext; ///
-
-    const premise = new Premise(context, string, node, statement, procedureCall);
-
-    return premise
-  }
 });

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