occam-verify-cli 1.0.696 → 1.0.703

package/src/element/type.js

@@ -4,8 +4,11 @@ import { Element } from "occam-languages";
 import { arrayUtilities } from "necessary";
 
 import { define } from "../elements";
+import { literally } from "../utilities/context";
+import { instantiateType } from "../process/instantiate";
 import { baseTypeFromNothing } from "../utilities/type";
-import { nameToNameJSON, superTypesToSuperTypesJSON, propertiesToPropertiesJSON, provisionalToProvisionalJSON } from "../utilities/json";
+import { nameFromTypeNode, prefixNameFromTypeNode } from "../utilities/element";
+import { superTypesFromJSON, provisionalFromJSON, propertiesFromJSON, provisionalToProvisionalJSON, superTypesToSuperTypesJSON, propertiesToPropertiesJSON } from "../utilities/json";
 
 const { push, first } = arrayUtilities;
 
@@ -292,23 +295,17 @@ export default define(class Type extends Element {
   }
 
   toJSON() {
-    const nameJSON = nameToNameJSON(this.name),
-          prefixNameJSON = nameToNameJSON(this.prefixName),
+    const superTypesJSON = superTypesToSuperTypesJSON(this.superTypes),
           propertiesJSON = propertiesToPropertiesJSON(this.properties),
-          superTypesJSON = superTypesToSuperTypesJSON(this.superTypes),
-          provisionalJSON = provisionalToProvisionalJSON(this.provisional),
-          name = nameJSON,  ///
-          prefixName = prefixNameJSON,  ///
-          properties = propertiesJSON,  ///
+          provisinoalJSOM = provisionalToProvisionalJSON(this.provisional),
           superTypes = superTypesJSON,  ///
-          provisional = provisionalJSON,  ///
+          properties = propertiesJSON,  ///
+          provisional = provisinoalJSOM,  ///
           string = this.getString(),
           json = {
             string,
-            name,
-            prefixName,
-            properties,
             superTypes,
+            properties,
             provisional
           };
 
@@ -318,7 +315,24 @@ export default define(class Type extends Element {
   static name = "Type";
 
   static fromJSON(json, context) {
-    debugger
+    const type = literally((context) => {
+      const { string } = json,
+            typeNode = instantiateType(string, context),
+            node = typeNode, ///
+            name = nameFromTypeNode(typeNode, context),
+            prefixName = prefixNameFromTypeNode(typeNode, context),
+            superTypes = superTypesFromJSON(json, context),
+            properties = propertiesFromJSON(json, context),
+            provisional = provisionalFromJSON(json);
+
+      context = null; ///
+
+      const type = new Type(context, string, node, name, prefixName, superTypes, properties, provisional);
+
+      return type;
+    }, context);
+
+    return type;
   }
 
   static fromName(name, context) {
@@ -327,8 +341,11 @@ export default define(class Type extends Element {
           prefixName = null,
           superTypes = [],
           properties = [],
-          provisional = false,
-          type = new Type(context, string, node, name, prefixName, superTypes, properties, provisional);
+          provisional = false;
+
+    context = null;
+
+    const type = new Type(context, string, node, name, prefixName, superTypes, properties, provisional);
 
     return type;
   }

package/src/element/typePrefix.js

@@ -3,7 +3,9 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import {nameToNameJSON} from "../utilities/json";
+import { literally } from "../utilities/context";
+import { instantiateTypePrefix } from "../process/instantiate";
+import { nameFromTypePrefixNode } from "../utilities/element";
 
 export default define(class TypePrefix extends Element {
   constructor(context, string, node, name) {
@@ -30,12 +32,9 @@ export default define(class TypePrefix extends Element {
   }
 
   toJSON() {
-    const nameJSON = nameToNameJSON(this.name),
-          name = nameJSON,  ///
-          string = this.getString(),
+    const string = this.getString(),
           json = {
-            string,
-            name
+            string
           };
 
     return json;
@@ -44,6 +43,19 @@ export default define(class TypePrefix extends Element {
   static name = "TypePrefix";
 
   static fromJSON(json, context) {
-    debugger
+    const typePrefix = literally((context) => {
+      const { string } = json,
+            typePrefixNode = instantiateTypePrefix(string, context),
+            node = typePrefixNode, ///
+            name = nameFromTypePrefixNode(typePrefixNode, context);
+
+      context = null; ///
+
+      const typePrefix = new TypePrefix(context, string, node, name);
+
+      return typePrefix;
+    }, context);
+
+    return typePrefix;
   }
 });

package/src/element/variable.js

@@ -7,20 +7,15 @@ import elements from "../elements";
 import { define } from "../elements";
 import { literally } from "../utilities/context";
 import { instantiateVariable } from "../process/instantiate";
-import { typeFromJSON,
-         typeToTypeJSON,
-         identifierFromJSON,
-         propertyRelationsFromJSON,
-         identifierToIdentifierJSON,
-         propertyRelationsToPropertyRelationsJSON } from "../utilities/json";
+import { identifierFromVarialbeNode } from "../utilities/element";
+import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
 
 export default define(class Variable extends Element {
-  constructor(context, string, node, type, identifier, propertyRelations) {
+  constructor(context, string, node, type, identifier) {
     super(context, string, node);
 
     this.type = type;
     this.identifier = identifier;
-    this.propertyRelations = propertyRelations;
   }
 
   getIdentifier() {
@@ -31,10 +26,6 @@ export default define(class Variable extends Element {
     return this.type;
   }
 
-  getPropertyRelations() {
-    return this.propertyRelations;
-  }
-
   setType(type) {
     this.type = type;
   }
@@ -196,17 +187,11 @@ export default define(class Variable extends Element {
 
   toJSON() {
     const typeJSON = typeToTypeJSON(this.type),
-          identifierJSON = identifierToIdentifierJSON(this.identifier),
-          propertyRelationsJSON = propertyRelationsToPropertyRelationsJSON(this.propertyRelations),
           type = typeJSON,  ///
-          identifier = identifierJSON,  ///
-          propertyRelations = propertyRelationsJSON,  ///
           string = this.getString(), ///
           json = {
             string,
-            type,
-            identifier,
-            propertyRelations
+            type
           };
 
     return json;
@@ -220,9 +205,11 @@ export default define(class Variable extends Element {
             variableNode = instantiateVariable(string, context),
             node = variableNode,  ///
             type = typeFromJSON(json, context),
-            identifier = identifierFromJSON(json, context),
-            propertyRelations = propertyRelationsFromJSON(json, context),
-            variable = new Variable(context, string, node, type, identifier, propertyRelations);
+            identifier = identifierFromVarialbeNode(variableNode, context);
+
+      context = null;
+
+      const variable = new Variable(context, string, node, type, identifier);
 
       return variable;
     }, context);

package/src/process/instantiate.js

@@ -2,66 +2,117 @@
 
 import { ruleFromRuleName } from "../utilities/bnf";
 import { TERM_RULE_NAME,
+         TYPE_RULE_NAME,
          FRAME_RULE_NAME,
          LABEL_RULE_NAME,
          PREMISE_RULE_NAME,
          VARIABLE_RULE_NAME,
+         EQUALITY_RULE_NAME,
+         PROPERTY_RULE_NAME,
+         JUDGEMENT_RULE_NAME,
+         DEDUCTION_RULE_NAME,
          PARAMETER_RULE_NAME,
          STATEMENT_RULE_NAME,
          REFERENCE_RULE_NAME,
          COMBINATOR_RULE_NAME,
          CONCLUSION_RULE_NAME,
+         HYPOTHESIS_RULE_NAME,
+         ASSUMPTION_RULE_NAME,
+         TYPE_PREFIX_RULE_NAME,
+         SUPPOSITION_RULE_NAME,
          CONSTRUCTOR_RULE_NAME,
          EQUIVALENCE_RULE_NAME,
          METAVARIABLE_RULE_NAME,
          PROCEDURE_CALL_RULE_NAME,
+         PROPERTY_RELATION_RULE_NAME,
          DEFINED_ASSERTION_RULE_NAME,
          TERM_SUBSTITUTION_RULE_NAME,
          SUBPROOF_ASSERTION_RULE_NAME,
          FRAME_SUBSTITUTION_RULE_NAME,
          PROCEDURE_REFERENCE_RULE_NAME,
          CONTAINED_ASSERTION_RULE_NAME,
+         SATISFIES_ASSERTION_RULE_NAME,
          STATEMENT_SUBSTITUTION_RULE_NAME,
          REFERENCE_SUBSTITUTION_RULE_NAME } from "../ruleNames";
 
 const termPlaceholderRule = ruleFromRuleName(TERM_RULE_NAME),
+      typePlaceholderRule = ruleFromRuleName(TYPE_RULE_NAME),
       framePlaceholderRule = ruleFromRuleName(FRAME_RULE_NAME),
       labelPlaceholderRule = ruleFromRuleName(LABEL_RULE_NAME),
       premisePlaceholderRule = ruleFromRuleName(PREMISE_RULE_NAME),
       variablePlaceholderRule = ruleFromRuleName(VARIABLE_RULE_NAME),
+      equalityPlaceholderRule = ruleFromRuleName(EQUALITY_RULE_NAME),
+      propertyPlaceholderRule = ruleFromRuleName(PROPERTY_RULE_NAME),
+      judgementlaceholderRule = ruleFromRuleName(JUDGEMENT_RULE_NAME),
+      deductionPlaceholderRule = ruleFromRuleName(DEDUCTION_RULE_NAME),
       parameterPlaceholderRule = ruleFromRuleName(PARAMETER_RULE_NAME),
       statementPlaceholderRule = ruleFromRuleName(STATEMENT_RULE_NAME),
       referencePlaceholderRule = ruleFromRuleName(REFERENCE_RULE_NAME),
       combinatorPlaceholderRule = ruleFromRuleName(COMBINATOR_RULE_NAME),
       conclusionPlaceholderRule = ruleFromRuleName(CONCLUSION_RULE_NAME),
+      hypothesisPlaceholderRule = ruleFromRuleName(HYPOTHESIS_RULE_NAME),
+      assumptionPlaceholderRule = ruleFromRuleName(ASSUMPTION_RULE_NAME),
+      typePrefixPlaceholderRule = ruleFromRuleName(TYPE_PREFIX_RULE_NAME),
+      suppositionPlaceholderRule = ruleFromRuleName(SUPPOSITION_RULE_NAME),
       constructorPlaceholderRule = ruleFromRuleName(CONSTRUCTOR_RULE_NAME),
       equivalencePlaceholderRule = ruleFromRuleName(EQUIVALENCE_RULE_NAME),
       metavariablePlaceholderRule = ruleFromRuleName(METAVARIABLE_RULE_NAME),
       procedureCalllaceholderRule = ruleFromRuleName(PROCEDURE_CALL_RULE_NAME),
+      propertyRelationlaceholderRule = ruleFromRuleName(PROPERTY_RELATION_RULE_NAME),
       definedAssertionPlaceholderRule = ruleFromRuleName(DEFINED_ASSERTION_RULE_NAME),
       termSubstitutionPlaceholderRule = ruleFromRuleName(TERM_SUBSTITUTION_RULE_NAME),
       subproofAssertionlaceholderRule = ruleFromRuleName(SUBPROOF_ASSERTION_RULE_NAME),
       frameSubstitutionPlaceholderRule = ruleFromRuleName(FRAME_SUBSTITUTION_RULE_NAME),
       procedureReferencelaceholderRule = ruleFromRuleName(PROCEDURE_REFERENCE_RULE_NAME),
       containedAssertionPlaceholderRule = ruleFromRuleName(CONTAINED_ASSERTION_RULE_NAME),
+      satisfiesAssertionPlaceholderRule = ruleFromRuleName(SATISFIES_ASSERTION_RULE_NAME),
       statementSubstitutionPlaceholderRule = ruleFromRuleName(STATEMENT_SUBSTITUTION_RULE_NAME),
       referenceSubstitutionPlaceholderRule = ruleFromRuleName(REFERENCE_SUBSTITUTION_RULE_NAME);
 
-export function instantiateTerm(string, context) { return instantiate(termPlaceholderRule, string, context); }
+export function instantiatePremise(string, context) {
+  string = `${string}
+`;  ///
 
-export function instantiateFrame(string, context) { return instantiate(framePlaceholderRule, string, context); }
+  return instantiate(premisePlaceholderRule, string, context);
+}
 
-export function instantiateLabel(string, context) { return instantiate(labelPlaceholderRule, string, context); }
+export function instantiateDeduction(string, context) {
+  string = `${string}
+`;  ///
 
-export function instantiatePremise(string, context) {
+  return instantiate(deductionPlaceholderRule, string, context);
+}
+
+export function instantiateConclusion(string, context) {
   string = `${string}
 `;  ///
 
-  return instantiate(premisePlaceholderRule, string, context);
+  return instantiate(conclusionPlaceholderRule, string, context);
 }
 
+export function instantiateSupposition(string, context) {
+  string = `${string}
+`;  ///
+
+  return instantiate(suppositionPlaceholderRule, string, context);
+}
+
+export function instantiateTerm(string, context) { return instantiate(termPlaceholderRule, string, context); }
+
+export function instantiateType(string, context) { return instantiate(typePlaceholderRule, string, context); }
+
+export function instantiateFrame(string, context) { return instantiate(framePlaceholderRule, string, context); }
+
+export function instantiateLabel(string, context) { return instantiate(labelPlaceholderRule, string, context); }
+
 export function instantiateVariable(string, context) { return instantiate(variablePlaceholderRule, string, context); }
 
+export function instantiateEquality(string, context) { return instantiate(equalityPlaceholderRule, string, context); }
+
+export function instantiateProperty(string, context) { return instantiate(propertyPlaceholderRule, string, context); }
+
+export function instantiateJudgement(string, context) { return instantiate(judgementlaceholderRule, string, context); }
+
 export function instantiateParameter(string, context) { return instantiate(parameterPlaceholderRule, string, context); }
 
 export function instantiateStatement(string, context) { return instantiate(statementPlaceholderRule, string, context); }
@@ -70,12 +121,11 @@ export function instantiateReference(string, context) { return instantiate(refer
 
 export function instantiateCombinator(string, context) { return instantiate(combinatorPlaceholderRule, string, context); }
 
-export function instantiateConclusion(string, context) {
-  string = `${string}
-`;  ///
+export function instantiateHypothesis(string, context) { return instantiate(hypothesisPlaceholderRule, string, context); }
 
-  return instantiate(conclusionPlaceholderRule, string, context);
-}
+export function instantiateAssumption(string, context) { return instantiate(assumptionPlaceholderRule, string, context); }
+
+export function instantiateTypePrefix(string, context) { return instantiate(typePrefixPlaceholderRule, string, context); }
 
 export function instantiateConstructor(string, context) { return instantiate(constructorPlaceholderRule, string, context); }
 
@@ -85,6 +135,8 @@ export function instantiateMetavariable(string, context) { return instantiate(me
 
 export function instantiateProcedureCall(string, context) { return instantiate(procedureCalllaceholderRule, string, context); }
 
+export function instantiatePropertyRelation(string, context) { return instantiate(propertyRelationlaceholderRule, string, context); }
+
 export function instantiateDefinedAssertion(string, context) { return instantiate(definedAssertionPlaceholderRule, string, context); }
 
 export function instantiateTermSubstitution(string, context) { return instantiate(termSubstitutionPlaceholderRule, string, context); }
@@ -97,6 +149,8 @@ export function instantiateProcedureReference(string, context) { return instanti
 
 export function instantiateContainedAssertion(string, context) { return instantiate(containedAssertionPlaceholderRule, string, context); }
 
+export function instantiateSatisfiesAssertion(string, context) { return instantiate(satisfiesAssertionPlaceholderRule, string, context); }
+
 export function instantiateStatementSubstitution(string, context) { return instantiate(statementSubstitutionPlaceholderRule, string, context); }
 
 export function instantiateReferenceSubstitution(string, context) { return instantiate(referenceSubstitutionPlaceholderRule, string, context); }

package/src/utilities/element.js

@@ -370,6 +370,19 @@ export function parameterFromParameterNode(parameterNode, context) {
   return parameter;
 }
 
+export function signatureFromJSignatureNode(signatureNode, context) {
+  const { Signature } = elements,
+        node = signatureNode,
+        string = context.nodeAsString(node),
+        terms = termsFromSignatureNode(signatureNode, context);
+
+  context = null;
+
+  const signature = new Signature(context, string, node, terms);
+
+  return signature;
+}
+
 export function hypothesisFromHypothesisNode(hypotheseNode, context) {
   const { Hypothsis } = elements,
         node = hypotheseNode, ///
@@ -600,12 +613,12 @@ export function propertyRelationFromPropertyRelationNode(propertyRelationNode, c
   const { PropertyRelation } = elements,
         node = propertyRelationNode,  ///
         string = context.nodeAsString(node),
-        property = propertyFromPropertyRelationNode(propertyRelationNode, context),
-        term = termFromPropertyRelationNode(propertyRelationNode, context);
+        term = termFromPropertyRelationNode(propertyRelationNode, context),
+        property = propertyFromPropertyRelationNode(propertyRelationNode, context);
 
   context = null;
 
-  const propertyRelation = new PropertyRelation(context, string, node, property, term);
+  const propertyRelation = new PropertyRelation(context, string, node, term, property);
 
   return propertyRelation;
 }
@@ -870,6 +883,12 @@ export function lemmaFromSectionNode(sectionNode, context) {
   return lemma;
 }
 
+export function nameFromPropertyNode(propertyNode, context) {
+  const name = propertyNode.getName();
+
+  return name;
+}
+
 export function statementFromStepNode(stepNode, context) {
   let statement = null;
 
@@ -894,6 +913,19 @@ export function referenceFromStepNode(stepNode, context) {
   return reference;
 }
 
+export function nameFromParaneterNode(parameterNode, context) {
+  const name = parameterNode.getName();
+
+  return name;
+}
+
+export function nameFromTypePrefixNode(typePrefixNode, context) {
+  const typePrefixName = typePrefixNode.getTypePrefixName(),
+        name = typePrefixName;  ///
+
+  return name;
+}
+
 export function superTypesFromTypeNode(typeNode, context) {
   const superTypes = null;
 
@@ -908,7 +940,7 @@ export function propertiesFromTypeNode(typeNode, context) {
 
 export function prefixNameFromTypeNode(typeNode, context) {
   const typePrefixName = typeNode.getTypePrefixName(),
-    prefixName = typePrefixName;  ///
+        prefixName = typePrefixName;  ///
 
   return prefixName;
 }
@@ -946,6 +978,12 @@ export function termsFromSignatureNode(signatureNode, context) {
   return terms;
 }
 
+export function provisionalFromTypeNode(typeNode, context) {
+  const provisional = null;
+
+  return provisional;
+}
+
 export function derivationFromProofNode(proofNode, context) {
   const derivationNode = proofNode.getDerivationNode(),
         derivation = derivationFromDerivationNode(derivationNode, context);
@@ -953,12 +991,6 @@ export function derivationFromProofNode(proofNode, context) {
   return derivation;
 }
 
-export function provisionalFromTypeNode(typeNode, context) {
-  const provisional = null;
-
-  return provisional;
-}
-
 export function termFromConstructorNode(ocnstructorNode, context) {
   const termNode = ocnstructorNode.getTermNode(),
         term = termFromTermNode(termNode, context);
@@ -999,6 +1031,13 @@ export function termsFromEquivalenceNode(equivalenceNode, context) {
   return terms;
 }
 
+export function nameFromMetavariableNode(metavariableNode, context) {
+  const metavaraibleName = metavariableNode.getMetavariableName(),
+        name = metavaraibleName;  ///
+
+  return name;
+}
+
 export function metavariableFromFrameNode(frameNode, context) {
   let metavariable = null;
 
@@ -1121,6 +1160,12 @@ export function assumptionFromJudgementNode(judgementNode, context) {
   return assumption;
 }
 
+export function identifierFromParameterNode(parameterNode, context) {
+  const identifier = parameterNode.getIdentifier();
+
+  return identifier;
+}
+
 export function referenceFromAssumptionNode(assumptionNode, context) {
   const metavariableNode = assumptionNode.getMetavariableNode(),
         reference = referenceFromMetavariableNode(metavariableNode, context);
@@ -1260,6 +1305,18 @@ export function referenceFromMetavariableNode(metavariableNode, context) {
   }, context);
 }
 
+export function termFromJDefinedAssertionNode(definedAssertionNode, context) {
+  let term = null;
+
+  const termNode = definedAssertionNode.getTermNode();
+
+  if (termNode !== null) {
+    term = termFromTermNode(termNode, context);
+  }
+
+  return term
+}
+
 export function frameFromDefinedAssertionNode(definedAssertionNode, context) {
   let frame = null;
 
@@ -1303,6 +1360,18 @@ export function typeAssertionFromStatementNode(statementNode, context) {
   return typeAssertion;
 }
 
+export function frameFromJDefinedAssertionNode(definedAssertionNode, context) {
+  let frame = null;
+
+  const frameNode = definedAssertionNode.getFrameNode();
+
+  if (frameNode !== null) {
+    frame = frameFromFrameNode(frameNode, context);
+  }
+
+  return frame
+}
+
 export function proofFromTopLevelAssertionNode(topLevelAsssertionNode, context) {
   let proof = null;
 
@@ -1385,6 +1454,12 @@ export function procedureCallFromSuppositionNode(suppositionNode, context) {
   return procedureCall;
 }
 
+export function negatedFromJDefinedAssertionNode(definedAssertionNode, context) {
+  const negated = definedAssertionNode.isNegated();
+
+  return negated
+}
+
 export function propertyFromPropertyRelationNode(propertyRelationNode, context) {
   const propertyNode = propertyRelationNode.getTermNode(),
         property = propertyFromPropertyNode(propertyNode, context);
@@ -1416,6 +1491,12 @@ export function termSubstitutionFromStatementNode(statementNode, context) {
   return termSubstitution;
 }
 
+export function negatedFromContainedAssertionNode(containedAssertionNode, context) {
+  const negated = containedAssertionNode.isNegated();
+
+  return negated;
+}
+
 export function typeFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {
   const typeNode = simpleTypeDeclarationNode.getTypeNode(),
         type = typeFromTypeNode(typeNode, context);
@@ -1571,6 +1652,20 @@ export function hypothesesFromTopLevelAssertionNode(topLevelAsssertionNode, cont
   return ypotheses;
 }
 
+export function signatureFromJSatisfiesAssertionNode(sasisfiesAssertionNode, context) {
+  const signatureNode = sasisfiesAssertionNode.getSignatureNode(),
+        signature = signatureFromJSignatureNode(signatureNode, context);
+
+  return signature;
+}
+
+export function referenceFromJSatisfiesAssertionNode(sasisfiesAssertionNode, context) {
+  const referenceNode = sasisfiesAssertionNode.getReferenceNode(),
+        reference = referenceFromReferenceNode(referenceNode, context);
+
+  return reference;
+}
+
 export function targetFrameFromFrameSubstitutionNode(frameSubstitutionNode, context) {
   const targetFrameNode = frameSubstitutionNode.getTargetFrameNode(),
         targetFrame = frameFromFrameNode(targetFrameNode, context);

package/src/utilities/json.js

@@ -170,6 +170,12 @@ export function conclusionFromJSON(json, context) {
   return conclusion;
 }
 
+export function provisionalFromJSON(json, context) {
+  const { provisional } = json;
+
+  return provisional;
+}
+
 export function metavariableFromJSON(json, context) {
   let { metavariable } = json;
 
@@ -198,6 +204,12 @@ export function procedureCallFromJSON(json, context) {
   return procedureCall;
 }
 
+export function nominalTypeNameFromJSON(json, context) {
+  const { nominalTypeName } = json;
+
+  return nominalTypeName;
+}
+
 export function procedureReferenceFromJSON(json, context) {
   let { procedureReference } = json;
 
@@ -277,7 +289,7 @@ export function framesFromJSON(json, context) {
 
   frames = framesJSON.map((frameJSON) => {
     const json = frameJSON,  ///
-      frame = Frame.fromJSON(json, context);
+          frame = Frame.fromJSON(json, context);
 
     return frame;
   });
@@ -798,6 +810,12 @@ export function procedureCallToProcedureCallJSON(procedureCall) {
   return procedureCallJSON;
 }
 
+export function nominalTypeNameToNominalTypeNameJSON(nominalTypeName) {
+  const nominalTypeNameJSON = nominalTypeName;  ///
+
+  return nominalTypeNameJSON;
+}
+
 export function procedureReferenceToProcedureReferenceJSON(procedureReference) {
   const procedureReferenceJSON = procedureReference.toJSON();