occam-verify-cli 1.0.935 → 1.0.936

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "1.0.935",
+  "version": "1.0.936",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",
@@ -12,7 +12,7 @@
   "dependencies": {
     "argumentative": "^2.0.47",
     "necessary": "^17.1.7",
-    "occam-furtle": "^3.0.200",
+    "occam-furtle": "^3.0.202",
     "occam-grammars": "^1.3.524",
     "occam-languages": "^0.0.204",
     "occam-lexers": "^23.1.44",

package/src/action/verify.js

@@ -13,7 +13,7 @@ const { last } = arrayUtilities,
       { createReleaseContexts, verifyReleaseContexts, initialiseReleaseContexts } = verificationUtilities;
 
 export default async function verifyAction(name, log) {
-  const callback = async (context, filePath, lineIndex) => {
+  const callback = async (context, breakPoint) => {
           ///
         },
         releaseContexts = [],

package/src/element/assertion/contained.js

@@ -13,8 +13,8 @@ import { termFromContainedAssertionNode,
          containedAssertionFromStatementNode } from "../../utilities/element";
 
 export default define(class ContainedAssertion extends Assertion {
-  constructor(context, string, node, lineIndex, term, frame, negated, statement) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, term, frame, negated, statement) {
+    super(context, string, node, breakPoint);
 
     this.term = term;
     this.frame = frame;
@@ -253,7 +253,7 @@ export default define(class ContainedAssertion extends Assertion {
 
     if (this.name === name) {
       instantiate((context) => {
-        const { string, lineIndex } = json,
+        const { string, breakPoint } = json,
               containedAssertionNode = instantiateContainedAssertion(string, context),
               node = containedAssertionNode,  ///
               term = termFromContainedAssertionNode(containedAssertionNode, context),
@@ -263,7 +263,7 @@ export default define(class ContainedAssertion extends Assertion {
 
         context = null;
 
-        containedAssertion = new ContainedAssertion(context, string, node, lineIndex, term, frame, negated, statement);
+        containedAssertion = new ContainedAssertion(context, string, node, breakPoint, term, frame, negated, statement);
       }, context);
     }
 

package/src/element/assertion/defined.js

@@ -10,8 +10,8 @@ import { termFromTermAndSubstitutions, frameFromFrameAndSubstitutions } from "..
 import { termFromJDefinedAssertionNode, frameFromJDefinedAssertionNode, negatedFromJDefinedAssertionNode, definedAssertionFromStatementNode } from "../../utilities/element";
 
 export default define(class DefinedAssertion extends Assertion {
-  constructor(context, string, node, lineIndex, term, frame, negated) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, term, frame, negated) {
+    super(context, string, node, breakPoint);
 
     this.term = term;
     this.frame= frame;
@@ -221,7 +221,7 @@ export default define(class DefinedAssertion extends Assertion {
 
     if (this.name === name) {
       instantiate((context) => {
-        const { string, lineIndex } = json,
+        const { string, breakPoint } = json,
               definedAssertionNode = instantiateDefinedAssertion(string, context),
               node = definedAssertionNode,  ///
               term = termFromJDefinedAssertionNode(definedAssertionNode, context),
@@ -230,7 +230,7 @@ export default define(class DefinedAssertion extends Assertion {
 
         context = null;
 
-        definedAssertion = new DefinedAssertion(context, string, node, lineIndex, term, frame, negated);
+        definedAssertion = new DefinedAssertion(context, string, node, breakPoint, term, frame, negated);
       }, context);
     }
 

package/src/element/assertion/property.js

@@ -9,8 +9,8 @@ import { variableAssignmentFromPrepertyAssertion } from "../../process/assign";
 import { termFromPropertyAssertionNode, propertyAssertionFromStatementNode, propertyRelationFromPropertyAssertionNode } from "../../utilities/element";
 
 export default define(class PropertyAssertion extends Assertion {
-  constructor(context, string, node, lineIndex, term, propertyRelation) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, term, propertyRelation) {
+    super(context, string, node, breakPoint);
 
     this.term = term;
     this.propertyRelation = propertyRelation;
@@ -226,7 +226,7 @@ export default define(class PropertyAssertion extends Assertion {
 
     if (this.name === name) {
       instantiate((context) => {
-        const { string, lineIndex } = json,
+        const { string, breakPoint } = json,
               propertyAssertionNode = instantiatePropertyAssertion(string, context),
               node = propertyAssertionNode,  ///
               term = termFromPropertyAssertionNode(propertyAssertionNode, context),
@@ -234,7 +234,7 @@ export default define(class PropertyAssertion extends Assertion {
 
         context = null;
 
-        propertyAssertion = new PropertyAssertion(context, string, node, lineIndex, term, propertyRelation);
+        propertyAssertion = new PropertyAssertion(context, string, node, breakPoint, term, propertyRelation);
       }, context);
     }
 

package/src/element/assertion/signature.js

@@ -8,8 +8,8 @@ import { instantiateSignatureAssertion } from "../../process/instantiate";
 import { signatureFromSignatureAssertionNode, referenceFromSignatureAssertionNode, signatureAssertionFromStatementNode } from "../../utilities/element";
 
 export default define(class SignatureAssertion extends Assertion {
-  constructor(context, string, node, lineIndex, signature, reference) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, signature, reference) {
+    super(context, string, node, breakPoint);
 
     this.signature = signature;
     this.reference = reference;
@@ -211,7 +211,7 @@ export default define(class SignatureAssertion extends Assertion {
 
     if (this.name === name) {
       instantiate((context) => {
-        const { string, lineIndex } = json,
+        const { string, breakPoint } = json,
               definedAssertionNode = instantiateSignatureAssertion(string, context),
               node = definedAssertionNode,  ///
               signature = signatureFromSignatureAssertionNode(definedAssertionNode, context),
@@ -219,7 +219,7 @@ export default define(class SignatureAssertion extends Assertion {
 
         context = null;
 
-        signatureAssertion = new SignatureAssertion(context, string, node, lineIndex, signature, reference);
+        signatureAssertion = new SignatureAssertion(context, string, node, breakPoint, signature, reference);
       }, context);
     }
 

package/src/element/assertion/subproof.js

@@ -13,8 +13,8 @@ import { subproofAssertionFromStatementNode } from "../../utilities/element";
 const { last, front, backwardsEvery } = arrayUtilities;
 
 export default define(class SubproofAssertion extends Assertion {
-  constructor(context, string, node, lineIndex, statements) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, statements) {
+    super(context, string, node, breakPoint);
 
     this.statements = statements;
   }
@@ -300,14 +300,14 @@ export default define(class SubproofAssertion extends Assertion {
 
     if (this.name === name) {
       instantiate((context) => {
-        const { string, lineIndex } = json,
+        const { string, breakPoint } = json,
               subproofAssertionNode = instantiateSubproofAssertion(string, context),
               statements = statementsFromSubproofAssertionNode(subproofAssertionNode, context),
               node = subproofAssertionNode; ///
 
         context = null;
 
-        subproorAssertion = new SubproofAssertion(context, string, node, lineIndex, statements);
+        subproorAssertion = new SubproofAssertion(context, string, node, breakPoint, statements);
       }, context);
     }
 

package/src/element/assertion/type.js

@@ -11,8 +11,8 @@ import { variableAssignmentFromTypeAssertion } from "../../process/assign";
 import { termFromTypeAssertionNode, typeAssertionFromStatementNode } from "../../utilities/element";
 
 export default define(class TypeAssertion extends Assertion {
-  constructor(context, string, node, lineIndex, term, type) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, term, type) {
+    super(context, string, node, breakPoint);
 
     this.term = term;
     this.type = type;
@@ -221,12 +221,12 @@ export default define(class TypeAssertion extends Assertion {
     const typeJSON = typeToTypeJSON(this.type),
           name = this.getName(),
           string = this.getString(),
-          lineIndex = this.getLineIndex(),
+          breakPoint = this.getBreakPoint(),
           type = typeJSON,
           json = {
             name,
             string,
-            lineIndex,
+            breakPoint,
             type
           };
 
@@ -242,7 +242,7 @@ export default define(class TypeAssertion extends Assertion {
 
     if (this.name === name) {
       instantiate((context) => {
-        const { string, lineIndex } = json,
+        const { string, breakPoint } = json,
               typeAssertionNode = instantiateTypeAssertion(string, context),
               term = termFromTypeAssertionNode(typeAssertionNode, context),
               type = typeFromJSON(json, context),
@@ -250,7 +250,7 @@ export default define(class TypeAssertion extends Assertion {
 
         context = null;
 
-        typeAssertion = new TypeAssertion(context, string, node, lineIndex, term, type);
+        typeAssertion = new TypeAssertion(context, string, node, breakPoint, term, type);
       }, context);
     }
 

package/src/element/assertion.js

@@ -43,11 +43,11 @@ export default class Assertion extends Element {
   toJSON() {
     const name = this.getName(),
           string = this.getString(),
-          lineIndex = this.getLineIndex(),
+          breakPoint = this.getBreakPoint(),
           json = {
             name,
             string,
-            lineIndex
+            breakPoint
           };
 
     return json;

package/src/element/assumption/metaLevel.js

@@ -11,8 +11,8 @@ import { metaLevelAssumptionStringFromReferenceAndStatement } from "../../utilit
 import { join, ablate, attempt, descend, reconcile, serialise, unserialise, instantiate } from "../../utilities/context";
 
 export default define(class MetaLevelAssumption extends Element {
-  constructor(context, string, node, lineIndex, reference, statement) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, reference, statement) {
+    super(context, string, node, breakPoint);
 
     this.reference = reference;
     this.statement = statement;
@@ -286,11 +286,11 @@ export default define(class MetaLevelAssumption extends Element {
 
     return serialise((context) => {
       const string = this.getString(),
-            lineIndex = this.getLineIndex(),
+            breakPoint = this.getBreakPoint(),
             json = {
               context,
               string,
-              lineIndex
+              breakPoint
             };
 
       return json;
@@ -304,13 +304,13 @@ export default define(class MetaLevelAssumption extends Element {
 
     unserialise((json, context) => {
       instantiate((context) => {
-        const { string, lineIndex } = json,
+        const { string, breakPoint } = json,
               metaLevelAssumptionNode = instantiateMetaLevelAssumption(string, context),
               node = metaLevelAssumptionNode,  ///
               reference = referenceFromMetaLevelAssumptionNode(metaLevelAssumptionNode, context),
               statement = statementFromMetaLevelAssumptionNode(metaLevelAssumptionNode, context);
 
-        metaLevelAssumption = new MetaLevelAssumption(context, string, node, lineIndex, reference, statement);
+        metaLevelAssumption = new MetaLevelAssumption(context, string, node, breakPoint, reference, statement);
       }, context);
     }, json, context);
 

package/src/element/assumption.js

@@ -7,8 +7,8 @@ import {instantiate, reconcile} from "../utilities/context";
 import { instantiateAssumption } from "../process/instantiate";
 
 export default define(class Assumption extends Element {
-  constructor(context, string, node, lineIndex, reference, statement) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, reference, statement) {
+    super(context, string, node, breakPoint);
 
     this.reference = reference;
     this.statement = statement;
@@ -248,10 +248,10 @@ export default define(class Assumption extends Element {
 
   toJSON() {
     const string = this.getString(),
-          lineIndex = this.getLineIndex(),
+          breakPoint = this.getBreakPoint(),
           json = {
             string,
-            lineIndex
+            breakPoint
           };
 
     return json;
@@ -259,12 +259,12 @@ export default define(class Assumption extends Element {
 
   static fromJSON(json, context) {
     return instantiate((context) => {
-      const { string, lineIndex } = json,
+      const { string, breakPoint } = json,
             assumptionNode = instantiateAssumption(string, context),
             node = assumptionNode,  ///
             reference = referenceFromAssumptionNode(assumptionNode, context),
             statement = statementFromAssumptionNode(assumptionNode, context),
-            assumption = new Assumption(context, string, node, lineIndex, reference, statement);
+            assumption = new Assumption(context, string, node, breakPoint, reference, statement);
 
       return assumption;
     }, context);

package/src/element/combinator.js

@@ -10,8 +10,8 @@ import { validateStatementAsCombinator } from "../process/validate";
 import { attempt, serialise, unserialise, instantiate } from "../utilities/context";
 
 export default define(class Combinator extends Element {
-  constructor(context, string, node, lineIndex, statement) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, statement) {
+    super(context, string, node, breakPoint);
 
     this.statement = statement;
   }
@@ -106,11 +106,11 @@ export default define(class Combinator extends Element {
 
     return serialise((context) => {
       const string = this.getString(),
-            lineIndex = this.getLineIndex(),
+            breakPoint = this.getBreakPoint(),
             json = {
               context,
               string,
-              lineIndex
+              breakPoint
             };
 
       return json;
@@ -124,12 +124,12 @@ export default define(class Combinator extends Element {
 
     unserialise((json, context) => {
       instantiate((context) => {
-        const { string, lineIndex } = json,
+        const { string, breakPoint } = json,
               combinatorNode = instantiateCombinator(string, context),
               node = combinatorNode,  ///
               statement = statementFromCombinatorNode(combinatorNode, context);
 
-        combinator = new Combinator(context, string, node, lineIndex, statement);
+        combinator = new Combinator(context, string, node, breakPoint, statement);
       }, context);
     }, json, context);
 

package/src/element/conclusion.js

@@ -7,8 +7,8 @@ import { instantiateConclusion } from "../process/instantiate";
 import { declare, attempt, descend, serialise, unserialise, instantiate } from "../utilities/context";
 
 export default define(class Conclusion extends Element {
-  constructor(context, string, node, lineIndex, statement) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, statement) {
+    super(context, string, node, breakPoint);
 
     this.statement = statement;
   }
@@ -135,11 +135,11 @@ export default define(class Conclusion extends Element {
 
     return serialise((context) => {
       const string = this.getString(),
-            lineIndex = this.getLineIndex(),
+            breakPoint = this.getBreakPoint(),
             json = {
               context,
               string,
-              lineIndex
+              breakPoint
             };
 
       return json;
@@ -153,12 +153,12 @@ export default define(class Conclusion extends Element {
 
     unserialise((json, context) => {
       instantiate((context) => {
-        const { string, lineIndex } = json,
+        const { string, breakPoint } = json,
               conclusionNode = instantiateConclusion(string, context),
               node = conclusionNode,  ///
               statement = statementFromConclusionNode(conclusionNode, context);
 
-        conclusion = new Conclusion(context, string, node, lineIndex, statement);
+        conclusion = new Conclusion(context, string, node, breakPoint, statement);
       }, context);
     }, json, context);
 

package/src/element/constructor.js

@@ -12,8 +12,8 @@ import { provisionallyStringFromProvisional } from "../utilities/string";
 import { attempt, serialise, unserialise, instantiate } from "../utilities/context";
 
 export default define(class Constructor extends Element {
-  constructor(context, string, node, lineIndex, term, type) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, term, type) {
+    super(context, string, node, breakPoint);
 
     this.term = term;
     this.type = type;
@@ -155,12 +155,12 @@ export default define(class Constructor extends Element {
       const includeType = false,
             typeJSON = typeToTypeJSON(this.type),
             string = this.getString(includeType),
-            lineIndex = this.getLineIndex(),
+            breakPoint = this.getBreakPoint(),
             type = typeJSON,  ///
             json = {
               context,
               string,
-              lineIndex,
+              breakPoint,
               type
             };
 
@@ -175,13 +175,13 @@ export default define(class Constructor extends Element {
 
     unserialise((json, context) => {
       instantiate((context) => {
-        const { string, lineIndex } = json,
+        const { string, breakPoint } = json,
               constructorNode = instantiateConstructor(string, context),
               node = constructorNode, ///
               term = termFromConstructorNode(constructorNode, context),
               type = typeFromJSON(json, context);
 
-        constructor = new Constructor(context, string, node, lineIndex, term, type);
+        constructor = new Constructor(context, string, node, breakPoint, term, type);
       }, context);
     }, json, context);
 

package/src/element/declaration/combinator.js

@@ -5,8 +5,8 @@ import Declaration from "../declaration";
 import { define } from "../../elements";
 
 export default define(class CombinatorDeclaration extends Declaration {
-  constructor(context, string, node, lineIndex, combinator) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, combinator) {
+    super(context, string, node, breakPoint);
 
     this.combinator = combinator;
   }

package/src/element/declaration/complexType.js

@@ -10,8 +10,8 @@ import { baseTypeFromNothing } from "../../utilities/type";
 const { asyncEvery } = asynchronousUtilities;
 
 export default define(class ComplexTypeDeclaration extends Declaration {
-  constructor(context, string, node, lineIndex, type, superTypes, provisional, propertyDeclarations) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, type, superTypes, provisional, propertyDeclarations) {
+    super(context, string, node, breakPoint);
 
     this.type = type;
     this.superTypes = superTypes;

package/src/element/declaration/constructor.js

@@ -5,8 +5,8 @@ import Declaration from "../declaration";
 import { define } from "../../elements";
 
 export default define(class ConstructorDeclaration extends Declaration {
-  constructor(context, string, node, lineIndex, type, provisional, constructor) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, type, provisional, constructor) {
+    super(context, string, node, breakPoint);
 
     this.type = type;
     this.provisional = provisional;

package/src/element/declaration/metavariable.js

@@ -5,8 +5,8 @@ import Declaration from "../declaration";
 import { define } from "../../elements";
 
 export default define(class MetavariableDeclaration extends Declaration {
-  constructor(context, string, node, lineIndex, metaType, metavariable) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, metaType, metavariable) {
+    super(context, string, node, breakPoint);
 
     this.metaType = metaType;
     this.metavariable = metavariable;

package/src/element/declaration/property.js

@@ -5,8 +5,8 @@ import Declaration from "../declaration";
 import { define } from "../../elements";
 
 export default define(class PropertyDeclaration extends Declaration {
-  constructor(context, string, node, lineIndex, property, type) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, property, type) {
+    super(context, string, node, breakPoint);
 
     this.property = property;
     this.type = type;

package/src/element/declaration/simpleType.js

@@ -6,8 +6,8 @@ import { define } from "../../elements";
 import { baseTypeFromNothing } from "../../utilities/type";
 
 export default define(class SimpleTypeDeclaration extends Declaration {
-  constructor(context, string, node, lineIndex, type, superTypes, provisional) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, type, superTypes, provisional) {
+    super(context, string, node, breakPoint);
 
     this.type = type;
     this.superTypes = superTypes;

package/src/element/declaration/typePrefix.js

@@ -5,8 +5,8 @@ import Declaration from "../declaration";
 import { define } from "../../elements";
 
 export default define(class TypePrefixDeclaration extends Declaration {
-  constructor(context, string, node, lineIndex, typePrefix) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, typePrefix) {
+    super(context, string, node, breakPoint);
 
     this.typePrefix = typePrefix;
   }

package/src/element/declaration/variable.js

@@ -5,8 +5,8 @@ import Declaration from "../declaration";
 import { define } from "../../elements";
 
 export default define(class VariableDeclaration extends Declaration {
-  constructor(context, string, node, lineIndex, type, variable, provisional) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, type, variable, provisional) {
+    super(context, string, node, breakPoint);
 
     this.type = type;
     this.variable = variable;

package/src/element/deduction.js

@@ -7,8 +7,8 @@ import { instantiateDeduction } from "../process/instantiate";
 import { declare, attempt, descend, serialise, unserialise, instantiate } from "../utilities/context";
 
 export default define(class Deduction extends Element {
-  constructor(context, string, node, lineIndex, statement) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, statement) {
+    super(context, string, node, breakPoint);
 
     this.statement = statement;
   }
@@ -135,11 +135,11 @@ export default define(class Deduction extends Element {
 
     return serialise((context) => {
       const string = this.getString(),
-            lineIndex = this.getLineIndex(),
+            breakPoint = this.getBreakPoint(),
             json = {
               context,
               string,
-              lineIndex
+              breakPoint
             };
 
       return json;
@@ -153,12 +153,12 @@ export default define(class Deduction extends Element {
 
     unserialise((json, context) => {
       instantiate((context) => {
-        const { string, lineIndex } = json,
+        const { string, breakPoint } = json,
               deductionNode = instantiateDeduction(string, context),
               node = deductionNode,  ///
               statement = statementFromDeductionNode(deductionNode, context);
 
-        deduction = new Deduction(context, string, node, lineIndex, statement);
+        deduction = new Deduction(context, string, node, breakPoint, statement);
       }, context);
     }, json, context);
 

package/src/element/derivation.js

@@ -9,8 +9,8 @@ const { last } = arrayUtilities,
       { asyncEvery } = asynchronousUtilities;
 
 export default define(class Derivation extends Element {
-  constructor(context, string, node, lineIndex, subproofOrProofAssertions) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, subproofOrProofAssertions) {
+    super(context, string, node, breakPoint);
 
     this.subproofOrProofAssertions = subproofOrProofAssertions;
   }

package/src/element/equality.js

@@ -10,8 +10,8 @@ import { equalityFromStatementNode } from "../utilities/element";
 import { equalityAssignmentFromEquality, leftVariableAssignmentFromEquality, rightVariableAssignmentFromEquality } from "../process/assign";
 
 export default define(class Equality extends Element {
-  constructor(context, string, node, lineIndex, leftTerm, rightTerm) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, leftTerm, rightTerm) {
+    super(context, string, node, breakPoint);
 
     this.leftTerm = leftTerm;
     this.rightTerm = rightTerm;
@@ -265,10 +265,10 @@ export default define(class Equality extends Element {
 
   toJSON() {
     const string = this.getString(),
-          lineIndex = this.getLineIndex(),
+          breakPoint = this.getBreakPoint(),
           json = {
             string,
-            lineIndex
+            breakPoint
           };
 
     return json;
@@ -278,7 +278,7 @@ export default define(class Equality extends Element {
 
   static fromJSON(json, context) {
     return instantiate((context) => {
-      const { string, lineIndex } = json,
+      const { string, breakPoint } = json,
             equalityNode = instantiateEquality(string, context),
             node = equalityNode,  ///
             leftTerm = leftTermFromEqualityNode(equalityNode, context),
@@ -286,7 +286,7 @@ export default define(class Equality extends Element {
 
       context = null;
 
-      const equality = new Equality(context, string, node, lineIndex, leftTerm, rightTerm);
+      const equality = new Equality(context, string, node, breakPoint, leftTerm, rightTerm);
 
       return equality;
     }, context);

package/src/element/equivalence.js

@@ -13,8 +13,8 @@ import { equivalenceFromEquivalenceNode } from "../utilities/element";
 const { compress } = arrayUtilities;
 
 export default define(class Equivalence extends Element {
-  constructor(context, string, node, lineIndex, type, terms) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, type, terms) {
+    super(context, string, node, breakPoint);
 
     this.type = type;
     this.terms = terms;