occam-verify-cli 1.0.905 → 1.0.910

package/src/element/signature.js

@@ -3,12 +3,10 @@
 import { Element } from "occam-languages";
 import { arrayUtilities } from "necessary";
 
-import elements from "../elements";
-
 import { define } from "../elements";
 import { instantiateSignature } from "../process/instantiate";
 import { termsFromSignatureNode } from "../utilities/element";
-import { attempt, serialise, unserialise, instantiate } from "../utilities/context";
+import { attempt, reconcile, serialise, unserialise, instantiate } from "../utilities/context";
 
 const { match, compare, correlate } = arrayUtilities;
 
@@ -30,6 +28,27 @@ export default define(class Signature extends Element {
     return signatureNode;
   }
 
+  getLength() {
+    const termsLength = this.terms.length,
+          length = termsLength; ///
+
+    return length;
+  }
+
+  getTerm(index) {
+    const term = this.terms[index];
+
+    return term;
+  }
+
+  findValidSignature(context) {
+    const signatureNode = this.getSignatureNode(),
+          signature = context.findSignatureBySignatureNode(signatureNode),
+          validSignature = signature;  ///
+
+    return validSignature;
+  }
+
   verify(context) {
     let verifies = false;
 
@@ -50,12 +69,60 @@ export default define(class Signature extends Element {
     }, context);
 
     if (verifies) {
-      context.debug(`...verified the '${signatureString}' signature.`);
+      context.debug(`...validated the '${signatureString}' signature.`);
     }
 
     return verifies;
   }
 
+  validate(context) {
+    let signature = null;
+
+    const signatureString = this.getString();  ///
+
+    context.trace(`Validating the '${signatureString}' signature...`);
+
+    let validates = false;
+
+    const validSignature = this.findValidSignature(context);
+
+    if (validSignature) {
+      signature = validSignature;  ///
+
+      context.debug(`...the '${signatureString}' signature is already valid.`);
+    } else {
+      const specificContext = context;  ///
+
+      context = this.getContext();
+
+      attempt((context) => {
+        const termsValidate = this.validateTerms(context);
+
+        if (termsValidate !== null) {
+          validates = true;
+        }
+
+        if (validates) {
+          this.commit(context);
+        }
+      }, context);
+
+      context = specificContext;  ///
+
+      if (validates) {
+        signature = this; ///
+
+        context.addSignature(signature);
+      }
+    }
+
+    if (validates) {
+      context.debug(`...validated the '${signatureString}' signature.`);
+    }
+
+    return signature;
+  }
+
   validateTerms(context) {
     let termsValidate;
 
@@ -90,40 +157,54 @@ export default define(class Signature extends Element {
     return termsValidate
   }
 
-  compareSignature(signature, substitutions, generalContext, specificContext) {
-    const terms = signature.getTerms(),
-          termsA = this.terms,  ///
-          termsB = terms, ///
-          matches = match(termsA, termsB, (termA, termB) => {
-            const { Variable } = elements,
-                  term = termB, ///
-                  context = generalContext, ///
-                  variable = Variable.fromTerm(term, context);
-
-            if (variable !== null) {
-              const term = termA, ///
-                    termType = term.getType(),
-                    variableType = variable.getType(),
-                    termTypeEqualToOrSubTypeOfVariableType = termType.isEqualToOrSubTypeOf(variableType);
-
-              if (termTypeEqualToOrSubTypeOfVariableType) {
-                debugger
-
-                // synthetically((context) => {
-                //   const { TermSubstitution } = elements;
-                //
-                //   TermSubstitution.fromTermAndVariable(term, variable, context);
-
-                //  validates...
-                // });
-
-                return true;
-              }
-            }
-          }),
-          comparesToSignature = matches; ///
+  unifySignature(signature, context) {
+    let signatureUnifies = false;
+
+    const generalSignature = this,
+          specificSignature = signature,  ///
+          generalSignatureString = generalSignature.getString(),
+          specificSignatureString = specificSignature.getString();
+
+    context.trace(`Unifying the '${specificSignatureString}' signature with the '${generalSignatureString}' signature...`);
+
+    context = specificSignature.getContext();
+
+    const specificContext = context;  ///
+
+    context = this.getContext();
+
+    const generalContext = context; ///
+
+    context = specificContext;  ///
+
+    reconcile((specificContext) => {
+      const generalSignatureTerms = generalSignature.getTerms(),
+            specificSignatureTerms = specificSignature.getTerms(),
+            generalTerms = generalSignatureTerms,  ///
+            specificTerms = specificSignatureTerms; ///
+
+      signatureUnifies = match(generalTerms, specificTerms, (generalTerm, specificTerm) => {
+        let termUnifies;
+
+        reconcile((specificContext) => {
+          termUnifies = generalTerm.unifyTerm(specificTerm, generalContext, specificContext);
+
+          if (termUnifies) {
+            specificContext.commit();
+          }
+        }, specificContext);
+
+        if (termUnifies) {
+          return true;
+        }
+      });
+    }, specificContext);
+
+    if (signatureUnifies) {
+      context.debug(`...unified the '${specificSignatureString}' signature with the '${generalSignatureString}' signature.`);
+    }
 
-    return comparesToSignature;
+    return signatureUnifies;
   }
 
   compareSubstitutions(substitutions, context) {

package/src/element/statement.js

@@ -192,14 +192,18 @@ export default define(class Statement extends Element {
 
     context.trace(`Validating the '${statementString}' statement...`);
 
+    let validates;
+
     const validStatement = this.findValidStatment(context);
 
     if (validStatement !== null) {
+      validates = true;
+
       statement = validStatement; ///
 
       context.debug(`...the '${statementString}' statement is already valid.`);
     } else {
-      const validates = validateStatements.some((validateStatement) => {
+      validates = validateStatements.some((validateStatement) => {
         const statement = this, ///
               statementValidates = validateStatement(statement, context);
 
@@ -212,11 +216,13 @@ export default define(class Statement extends Element {
         statement = this; ///
 
         context.addStatement(statement);
-
-        context.debug(`...validated the '${statementString}' statement.`);
       }
     }
 
+    if (validates) {
+      context.debug(`...validated the '${statementString}' statement.`);
+    }
+
     return statement;
   }
 

package/src/element/substitution/frame.js

@@ -82,6 +82,8 @@ export default define(class FrameSubstitution extends Substitution {
     const validSubstitution = this.findValidSubstitution(context);
 
     if (validSubstitution) {
+      validates = true;
+
       frameSubstitution = validSubstitution;  ///
 
       context.debug(`...the '${frameSubstitutionString}' frame substitution is already valid.`);
@@ -104,15 +106,17 @@ export default define(class FrameSubstitution extends Substitution {
           this.commit(generalContext, specificContext);
         }
       }, generalContext, specificContext);
-    }
 
-    if (validates) {
-      const substitution = this;  ///
+      if (validates) {
+        const substitution = this;  ///
 
-      frameSubstitution = substitution; ///
+        frameSubstitution = substitution; ///
 
-      context.addSubstitution(substitution);
+        context.addSubstitution(substitution);
+      }
+    }
 
+    if (validates) {
       context.debug(`...validated the '${frameSubstitutionString}' frame substitution.`);
     }
 

package/src/element/substitution/reference.js

@@ -99,6 +99,8 @@ export default define(class ReferenceSubstitution extends Substitution {
     const validSubstitution = this.findValidSubstitution(context);
 
     if (validSubstitution) {
+      validates = true;
+
       referenceSubstitution = validSubstitution;  ///
 
       context.debug(`...the '${referenceSubstitutionString}' reference substitution is already valid.`);
@@ -121,15 +123,17 @@ export default define(class ReferenceSubstitution extends Substitution {
           this.commit(generalContext, specificContext);
         }
       }, generalContext, specificContext);
-    }
 
-    if (validates) {
-      const substitution = this;  ///
+      if (validates) {
+        const substitution = this;  ///
 
-      referenceSubstitution = substitution;  ///
+        referenceSubstitution = substitution;  ///
 
-      context.addSubstitution(substitution);
+        context.addSubstitution(substitution);
+      }
+    }
 
+    if (validates) {
       context.debug(`...validated the '${referenceSubstitutionString}' reference substitution.`);
     }
 

package/src/element/substitution/statement.js

@@ -95,6 +95,8 @@ export default define(class StatementSubstitution extends Substitution {
     const validSubstitution = this.findValidSubstitution(context);
 
     if (validSubstitution) {
+      validates = true;
+
       statementSubstitution = validSubstitution;  ///
 
       context.debug(`...the '${statementSubstitutionString}' statement substitution is already valid.`);
@@ -121,15 +123,17 @@ export default define(class StatementSubstitution extends Substitution {
           this.commit(generalContext, specificContext);
         }
       }, generalContext, specificContext);
-    }
 
-    if (validates) {
-      const substitution = this;  ///
+      if (validates) {
+        const substitution = this;  ///
 
-      statementSubstitution = substitution; ///
+        statementSubstitution = substitution; ///
 
-      context.addSubstitution(substitution);
+        context.addSubstitution(substitution);
+      }
+    }
 
+    if (validates) {
       context.debug(`...validated the '${statementSubstitutionString}' statement substitution.`);
     }
 

package/src/element/substitution/term.js

@@ -107,15 +107,17 @@ export default define(class TermSubstitution extends Substitution {
           this.commit(generalContext, specificContext);
         }
       }, generalContext, specificContext);
-    }
 
-    if (validates) {
-      const substitution = this;  ///
+      if (validates) {
+        const substitution = this;  ///
 
-      termSubstitution = substitution;  ///
+        termSubstitution = substitution;  ///
 
-      context.addSubstitution(substitution);
+        context.addSubstitution(substitution);
+      }
+    }
 
+    if (validates) {
       context.debug(`...validated the '${termSubstitutionString}' term substitution.`);
     }
 

package/src/element/term.js

@@ -8,6 +8,7 @@ import { instantiate } from "../utilities/context";
 import { validateTerms } from "../utilities/validation";
 import { instantiateTerm } from "../process/instantiate";
 import { variablesFromTerm } from "../utilities/equivalence";
+import { unifyTermIntrinsically } from "../process/unify";
 import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
 
 const { filter } = arrayUtilities;
@@ -172,21 +173,24 @@ export default define(class Term extends Element {
 
     context.trace(`Validating the '${termString}' term...`);
 
-    const validTerm = this.findValidTerm(context),
-          valid = (validTerm !== null);
+    let validates = false;
 
-    if (valid) {
-      term = validTerm; ///
+    const validTerm = this.findValidTerm(context);
 
-      context.debug(`...the '${termString}' term is already valid.`);
+    if (validTerm !== null) {
+      term = validTerm; ///
 
       const validatesForward = validateForwards(term);
 
-      if (!validatesForward) {
+      if (validatesForward) {
+        validates = true;
+
+        context.debug(`...the '${termString}' term is already valid.`);
+      } else {
         term = null;
       }
     } else {
-      const validates = validateTerms.some((validateTerm) => {  ///
+      validates = validateTerms.some((validateTerm) => {  ///
         const term = this,  ///
               termValidates = validateTerm(term, context, validateForwards);
 
@@ -199,11 +203,13 @@ export default define(class Term extends Element {
         term = this;  ///
 
         context.addTerm(term);
-
-        context.debug(`...validated the '${termString}' term.`);
       }
     }
 
+    if (validates) {
+      context.debug(`...validated the '${termString}' term.`);
+    }
+
     return term;
   }
 
@@ -241,6 +247,30 @@ export default define(class Term extends Element {
     return term;
   }
 
+  unifyTerm(term, generalContext, specificContext) {
+    let termUnifies = false;
+
+    const context = specificContext,  ///
+          generalTerm = this,
+          specificTerm = term,
+          generalTermString = generalTerm.getString(),
+          specifixTermString = specificTerm.getString();
+
+    context.trace(`Unifying the '${specifixTermString}' term with the '${generalTermString}' term...`);
+
+    const termUnifiesIntrinsically = unifyTermIntrinsically(generalTerm, specificTerm, generalContext, specificContext);
+
+    if (termUnifiesIntrinsically) {
+      termUnifies = true;
+    }
+
+    if (termUnifies) {
+      context.debug(`...unified the '${specifixTermString}' term with the '${generalTermString}' term.`);
+    }
+
+    return termUnifies;
+  }
+
   toJSON() {
     const typeJSON = typeToTypeJSON(this.type),
           string = this.getString(), ///

package/src/element/topLevelAssertion/axiom.js

@@ -23,32 +23,6 @@ export default define(class Axiom extends TopLevelAssertion {
     return satisfiable;
   }
 
-  compareSignature(signature, context) {
-    let comparesToSignature = false;
-
-    const satisfiable = this.isSatisfiable();
-
-    if (satisfiable) {
-      const signatureA = signature; ///
-
-      signature = this.getSignature()
-
-      const signatureB = signature, ///
-            specificContext = context;  ///
-
-      context = this.getContext();
-
-      const generalContext = context,  ///
-            signatureAComparesToSignatureB = signatureA.compareSignature(signatureB, generalContext, specificContext);
-
-      if (signatureAComparesToSignatureB) {
-        comparesToSignature = true;
-      }
-    }
-
-    return comparesToSignature;
-  }
-
   async verify(context) {
     let verifies;
 
@@ -242,6 +216,29 @@ export default define(class Axiom extends TopLevelAssertion {
     return lastStepUnifies;
   }
 
+  unifySignature(signature, context) {
+    let signatureUnifies;
+
+    const axiomString = this.getString(), ///
+          signatureString = signature.getString();
+
+    context.trace(`Unifying the '${signatureString}' signature with the '${axiomString}' axiom...`);
+
+    const specificSignature = signature;  ///
+
+    signature = this.getSignature();
+
+    const generalSignature = signature; ///
+
+    signatureUnifies = generalSignature.unifySignature(specificSignature, context);
+
+    if (signatureUnifies) {
+      context.debug(`...unified the '${signatureString}' signature with the '${axiomString}' axiom.`);
+    }
+
+    return signatureUnifies;
+  }
+
   unifyTopLevelAssertion(topLevelAssertion, context) {
     let topLevelAssertionUnifies = false;
 

package/src/element/variable.js

@@ -89,14 +89,14 @@ export default define(class Variable extends Element {
 
       this.type = type;
 
+      variable = this;
+
       validates = true;
     } else {
       context.debug(`The '${variableString}' variable is not present.`);
     }
 
     if (validates) {
-      variable = this;  ///
-
       context.debug(`...validated the '${variableString}' variable.`);
     }
 

package/src/process/unify.js

@@ -147,38 +147,6 @@ class StatementPass extends ZipPassBase {
   ];
 }
 
-class IntrinsicPass extends ZipPass {
-  static maps = [
-    {
-      generalNodeQuery: termVariableNodeQuery,
-      specificNodeQuery: termNodeQuery,
-      run: (generalTermVariableNode, specificTermNode, generalContext, specificContext) => {
-        let success = false;
-
-        const termNode = specificTermNode, ///
-              variableNode = generalTermVariableNode; ///
-
-        let context;
-
-        context = generalContext; ///
-
-        const variable = context.findVariableByVariableNode(variableNode);
-
-        context = specificContext;  ///
-
-        const term = context.findTermByTermNode(termNode),
-              termUnifies = variable.unifyTerm(term, generalContext, specificContext);
-
-        if (termUnifies) {
-          success = true;
-        }
-
-        return success;
-      }
-    }
-  ];
-}
-
 class CombinatorPass extends ZipPass {
   static maps = [
     {
@@ -402,12 +370,77 @@ class SubstitutionPass extends ZipPass {
   ];
 }
 
+class IntrinsicTermPass extends ZipPassBase {
+  static maps = [
+    {
+      generalNodeQuery: termVariableNodeQuery,
+      specificNodeQuery: termNodeQuery,
+      run: (generalTermVariableNode, specificTermNode, generalContext, specificContext) => {
+        let success = false;
+
+        const termNode = specificTermNode, ///
+              variableNode = generalTermVariableNode; ///
+
+        let context;
+
+        context = generalContext; ///
+
+        const variable = context.findVariableByVariableNode(variableNode);
+
+        context = specificContext;  ///
+
+        const term = context.findTermByTermNode(termNode),
+              termUnifies = variable.unifyTerm(term, generalContext, specificContext);
+
+        if (termUnifies) {
+          success = true;
+        }
+
+        return success;
+      }
+    }
+  ];
+}
+
+class IntrinsicMetavariablePass extends ZipPass {
+  static maps = [
+    {
+      generalNodeQuery: termVariableNodeQuery,
+      specificNodeQuery: termNodeQuery,
+      run: (generalTermVariableNode, specificTermNode, generalContext, specificContext) => {
+        let success = false;
+
+        const termNode = specificTermNode, ///
+              variableNode = generalTermVariableNode; ///
+
+        let context;
+
+        context = generalContext; ///
+
+        const variable = context.findVariableByVariableNode(variableNode);
+
+        context = specificContext;  ///
+
+        const term = context.findTermByTermNode(termNode),
+              termUnifies = variable.unifyTerm(term, generalContext, specificContext);
+
+        if (termUnifies) {
+          success = true;
+        }
+
+        return success;
+      }
+    }
+  ];
+}
+
 const statementPass = new StatementPass(),
-      intrinsicPass = new IntrinsicPass(),
       combinatorPass = new CombinatorPass(),
       constructorPass = new ConstructorPass(),
       metavariablePass = new MetavariablePass(),
-      substitutionPass = new SubstitutionPass();
+      substitutionPass = new SubstitutionPass(),
+      intrinsicTermPass = new IntrinsicTermPass(),
+      intrinsicMetavariablePass = new IntrinsicMetavariablePass();
 
 export function unifyStatement(generalStatement, specificStatement, generalContext, specificContext) {
   let statementUnifies = false;
@@ -485,6 +518,22 @@ export function unifyStatementWithCombinator(statement, combinator, generalConte
   return statementUnifiesWithCombinator;
 }
 
+export function unifyTermIntrinsically(generalTerm, specificTerm, generalContext, specificContext) {
+  let termUnifiesIntrinsically = false;
+
+  const generalTermNode = generalTerm.getNode(),
+        specificTermNode = specificTerm.getNode(),
+        generalNode = generalTermNode, ///
+        specificNode = specificTermNode, ///
+        success = intrinsicTermPass.run(generalNode, specificNode, generalContext, specificContext);
+
+  if (success) {
+    termUnifiesIntrinsically = true;
+  }
+
+  return termUnifiesIntrinsically;
+}
+
 export function unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, generalContext, specificContext) {
   let metavariableUnifiesIntrinsically = false;
 
@@ -492,7 +541,7 @@ export function unifyMetavariableIntrinsically(generalMetavariable, specificMeta
         specificMetavariableNode = specificMetavariable.getNode(),
         generalNode = generalMetavariableNode, ///
         specificNode = specificMetavariableNode, ///
-        success = intrinsicPass.run(generalNode, specificNode, generalContext, specificContext);
+        success = intrinsicMetavariablePass.run(generalNode, specificNode, generalContext, specificContext);
 
   if (success) {
     metavariableUnifiesIntrinsically = true;