occam-nominal 1.0.430 → 1.0.432

package/src/element/equality.js

@@ -78,20 +78,6 @@ export default define(class Equality extends Element {
     return equalTo;
   }
 
-  isReflexive() {
-    let reflexive = false;
-
-    if (!this.negated) {
-      const leftTermEqualToRightTerm = this.leftTerm.isEqualTo(this.rightTerm);
-
-      if (leftTermEqualToRightTerm) {
-        reflexive = true;
-      }
-    }
-
-    return reflexive;
-  }
-
   findEquality(context) {
     const equalityNode = this.getEqualityNode(),
           equality = context.findEqualityByEqualityNode(equalityNode);
@@ -248,14 +234,14 @@ export default define(class Equality extends Element {
       return;
     }
 
-    const equality = this,  ///
-          negated = this.isNegated(),
-          reflexive = this.isReflexive();
+    const negated = this.isNegated();
 
-    if (negated || reflexive) {
+    if (negated) {
       return;
     }
 
+    const equality = this;  ///
+
     const equalityAssignment = equalityAssignmentFromEquality(equality, context);
 
     context.addAssignment(equalityAssignment);

package/src/element/equivalence.js

@@ -5,12 +5,12 @@ import { arrayUtilities } from "necessary";
 
 import { define } from "../elements";
 import { instantiate } from "../utilities/context";
+import { stripBracketsFromTerm } from "../utilities/brackets";
 import { instantiateEquivalence } from "../process/instantiate";
-import { stripBracketsFromTermNode } from "../utilities/brackets";
 import { equivalenceStringFromTerms } from "../utilities/string";
 import { equivalenceFromEquivalenceNode } from "../utilities/element";
 
-const { compress } = arrayUtilities;
+const { first, second, compress } = arrayUtilities;
 
 export default define(class Equivalence extends Element {
   constructor(context, string, node, breakPoint, terms) {
@@ -87,9 +87,9 @@ export default define(class Equivalence extends Element {
 
   isDisjointFrom(equivalence) {
     const disjointFrom = equivalence.everyTerm((term) => {
-      const comparesToTerm = this.compareTerm(term);
+      const termEquates = this.equateTerm(term);
 
-      if (!comparesToTerm) {
+      if (!termEquates) {
         return true;
       }
     });
@@ -113,63 +113,42 @@ export default define(class Equivalence extends Element {
     return implicitlyGrounded;
   }
 
-  matchTermNode(termNode) {
-    termNode = stripBracketsFromTermNode(termNode); ///
+  equateTerm(term) {
+    const termA = term, ///
+          termEquates = this.someTerm((term) => {
+            const termB = term, ///
+                  termAEqualToTermB = termA.isEqualTo(termB);
 
-    const termNodeMatches = this.someTerm((term) => {
-      const termNodeMatches = term.matchTermNode(termNode);
+            if (termAEqualToTermB) {
+              return true;
+            }
+          });
 
-      if (termNodeMatches) {
+    return termEquates;
+  }
+
+  equateTerms(terms) {
+    const termsEquate = terms.every((term) => {
+      const termEquates = this.equateTerm(term);
+
+      if (termEquates) {
         return true;
       }
     });
 
-    return termNodeMatches;
+    return termsEquate;
   }
 
-  matchTermNodes(termNodes) {
-    const termNodesMatch = termNodes.every((termNode) => {
-      const termNodeMatches = this.matchTermNode(termNode);
+  matchTermNode(termNode) {
+    const termNodeMatches = this.terms.some((term) => {
+      const termNodeMatches = term.matchTermNode(termNode);
 
       if (termNodeMatches) {
         return true;
       }
     });
 
-    return termNodesMatch;
-  }
-
-  someTerm(callback) { return this.terms.some(callback); }
-
-  everyTerm(callback) { return this.terms.every(callback); }
-
-  compareTerm(term) {
-    const termA = term, ///
-          comparesToTerm = this.someTerm((term) => {
-            const termB = term, ///
-                  termAEqualToTermB = termA.isEqualTo(termB);
-
-            if (termAEqualToTermB) {
-              return true;
-            }
-          });
-
-    return comparesToTerm;
-  }
-
-  someOtherTerm(term, callback) {
-    const termA = term, ///
-          terms = this.terms.filter((term) => {
-            const termB = term, ///
-                  termAEqualToTermB = termA.isEqualTo(termB);
-
-            if (!termAEqualToTermB) {
-              return true;
-            }
-          }),
-          result = terms.some(callback);
-
-    return result;
+    return termNodeMatches;
   }
 
   combineTerms(terms) {
@@ -209,14 +188,54 @@ export default define(class Equivalence extends Element {
     return equivalence;
   }
 
+  someOtherTerm(term, callback) {
+    const termA = term, ///
+          terms = this.terms.filter((term) => {
+            const termB = term, ///
+                  termAEqualToTermB = termA.isEqualTo(termB);
+
+            if (!termAEqualToTermB) {
+              return true;
+            }
+          }),
+          result = terms.some(callback);
+
+    return result;
+  }
+
+  someTerm(callback) { return this.terms.some(callback); }
+
+  everyTerm(callback) { return this.terms.every(callback); }
+
   static name = "Equivalence";
 
   static fromEquality(equality, context) {
     let equivalence;
 
+    let terms;
+
+    terms = equality.getTerms();
+
+    terms = terms.map((term) => { ///
+      term = stripBracketsFromTerm(term, context);
+
+      return term;
+    });
+
+    const firstTerm = first(terms),
+          secondTerm = second(terms),
+          firstTermEqualToSecondTerm = firstTerm.isEqualTo(secondTerm);
+
+    if (firstTermEqualToSecondTerm) {
+      const term = firstTerm; ///
+
+      terms = [
+        term
+      ];
+    }
+
     instantiate((context) => {
-      const terms = equality.getTerms(),
-            equivalenceString = equivalenceStringFromTerms(terms),
+      const equivalenceString = equivalenceStringFromTerms(terms),
             string = equivalenceString,  ///
             equivalenceNode = instantiateEquivalence(string, context);
 

package/src/element/fact/step.js

@@ -216,7 +216,7 @@ export default define(class Step extends Fact {
 
       context.trace(`Validating the '${stepString}' step's '${signatureAssertionString}' signature assertion...`);
 
-      derive((state) => {
+      declare((state) => {
         signatureAssertionValidates = this.signatureAssertion.validate(state, context, (signatureAssertion, contwext) => {
           let validates;
 

package/src/element/signature.js

@@ -1,15 +1,15 @@
 "use strict";
 
-import { arrayUtilities } from "necessary";
-import { Element, breakPointUtilities } from "occam-languages";
+import { Element, breakPointUtilities, continuationUtilities } from "occam-languages";
 
 import { define } from "../elements";
 import { declare } from "../utilities/state";
 import { all, every } from "../utilities/continuation";
+import { termsStringFromTerms } from "../utilities/string";
 import { instantiateSignature } from "../process/instantiate";
 import { attempt, reconcile, serialise, unserialise, instantiate } from "../utilities/context";
 
-const { match } = arrayUtilities,
+const { asynchronousEvery } = continuationUtilities,
       { breakPointFromJSON, breakPointToBreakPointJSON } = breakPointUtilities;
 
 export default define(class Signature extends Element {
@@ -173,49 +173,50 @@ export default define(class Signature extends Element {
   }
 
   unifyTerms(terms, context, continuation) {
-    let termsUnify;
+    let termsUnify = false;
 
-    debugger
+    const quoted = true,
+          termsString = termsStringFromTerms(terms, quoted),
+          signatureString = this.getString();
 
-    const generalSignature = this,  ///
-          specificSignature = signature,  ///
-          generalSignatureString = generalSignature.getString(),
-          specificSignatureString = specificSignature.getString();
+    context.trace(`Unifying the ${termsString} terms with the '${signatureString}' signature...`);
 
-    context.trace(`Unifying the '${specificSignatureString}' signature with the '${generalSignatureString}' signature...`);
+    const generalTerms = this.terms,  ///
+          specificTerms = terms,  //
+          generalTermsLength = generalTerms.length,
+          specificTermsLength = specificTerms.length;
 
-    const generalSignatureTerms = generalSignature.getTerms(),
-          specificSignatureTerms = specificSignature.getTerms(),
-          generalSignatureContext = generalSignature.getContext(),
-          specificSignatureContext = specificSignature.getContext(),
-          generalTerms = generalSignatureTerms,  ///
-          specificTerms = specificSignatureTerms, ///
-          generalContext = generalSignatureContext, ///
-          specificContext = specificSignatureContext;  ///
+    if (generalTermsLength !== specificTermsLength) {
+      return continuation(termsUnify);
+    }
 
-    debugger
+    const specificContext = context; ///
 
-    termsUnify = reconcile((specificContext) => {
-      match(generalTerms, specificTerms, (generalTerm, specificTerm) => {
-        let termUnifies;
+    context = this.getContext();
 
-        termUnifies = generalTerm.unifyTerm(specificTerm, generalContext, specificContext);
+    const generalContext = context; ///
 
-        if (termUnifies) {
-          return true;
-        }
-      });
+    let index = -1;
 
-      if (termsUnify) {
-        specificContext.commit(context);
-      }
-    }, specificContext);
+    return reconcile((specificContext) => {
+      return asynchronousEvery(generalTerms, (generalTerm, continuation) => {
+        index++;
 
-    if (termsUnify) {
-      context.debug(`...unified the '${specificSignatureString}' signature with the '${generalSignatureString}' signature.`);
-    }
+        const specificTerm = specificTerms[index];
 
-    return termsUnify;
+        generalTerm.unifyTerm(specificTerm, generalContext, specificContext, continuation);
+      }, (termsUnify) => {
+        if (termsUnify) {
+          specificContext.commit();
+        }
+
+        if (termsUnify) {
+          context.debug(`...unified the ${termsString} terms with the '${signatureString}' signature.`);
+        }
+
+        return continuation(termsUnify);
+      });
+    }, specificContext);
   }
 
   toJSON() {

package/src/element/term.js

@@ -346,11 +346,9 @@ export default define(class Term extends Element {
   //   return term;
   // }
 
-  unifyTerm(term, generalContext, specificContext) {
+  unifyTerm(term, generalContext, specificContext, continuation) {
     let termUnifies = false;
 
-    debugger
-
     const context = specificContext,  ///
           generalTerm = this, ///
           specificTerm = term,
@@ -359,17 +357,17 @@ export default define(class Term extends Element {
 
     context.trace(`Unifying the '${specifixTermString}' term with the '${generalTermString}' term...`);
 
-    const termUnifiesIntrinsically = unifyTermIntrinsically(generalTerm, specificTerm, generalContext, specificContext);
-
-    if (termUnifiesIntrinsically) {
-      termUnifies = true;
-    }
+    return unifyTermIntrinsically(generalTerm, specificTerm, generalContext, specificContext, (termUnifiesIntrinsically) => {
+      if (termUnifiesIntrinsically) {
+        termUnifies = true;
+      }
 
-    if (termUnifies) {
-      context.debug(`...unified the '${specifixTermString}' term with the '${generalTermString}' term.`);
-    }
+      if (termUnifies) {
+        context.debug(`...unified the '${specifixTermString}' term with the '${generalTermString}' term.`);
+      }
 
-    return termUnifies;
+      return continuation(termUnifies);
+    });
   }
 
   toJSON() {

package/src/process/equate.js

@@ -4,7 +4,8 @@ import { queryUtilities } from "occam-query";
 
 import ZipPass from "../pass/zip";
 
-import { findEquivalenceByTermNodes } from "../utilities/equivalences";
+import { stripBracketsFromTermNode } from "../utilities/brackets";
+import { findEquivalenceByTermNode } from "../utilities/equivalences";
 
 const { nodeQuery } = queryUtilities;
 
@@ -18,25 +19,48 @@ class EquationalPass extends ZipPass {
       run: (leftTermNode, rightTermNode, context) => {
         let success = false;
 
+        leftTermNode = stripBracketsFromTermNode(leftTermNode); ///
+        rightTermNode = stripBracketsFromTermNode(rightTermNode); ///
+
         if (!success) {
-          const depth = Infinity,
-                leftTermNodeMatchesRightTermNode = leftTermNode.match(rightTermNode, depth);
+          const equivalences = context.getEquivalences(),
+                leftEquivalence = findEquivalenceByTermNode(equivalences, leftTermNode),
+                rightEquivalence = findEquivalenceByTermNode(equivalences, rightTermNode);
 
-          if (leftTermNodeMatchesRightTermNode) {
-            success = true;
+          if (!success) {
+            if ((leftEquivalence !== null) && (rightEquivalence !== null) && (leftEquivalence === rightEquivalence)) {
+              success = true;
+            }
           }
-        }
 
-        if (!success) {
-          const equivalences = context.getEquivalences(),
-                termNodes = [
-                  leftTermNode,
-                  rightTermNode
-                ],
-                equivalence = findEquivalenceByTermNodes(equivalences, termNodes);
-
-          if (equivalence !== null) {
-            success = true;
+          if (!success) {
+            if (leftEquivalence !== null) {
+              success = leftEquivalence.someOtherTerm(leftTerm, (otherTerm) => {
+                const leftTerm = otherTerm, ///
+                      leftTermNode = leftTerm.getNode(),
+                      rightTermNode = rightTerm.getNode(),
+                      descended = descend(leftTermNode, rightTermNode, context);
+
+                if (descended) {
+                  return true;
+                }
+              });
+            }
+          }
+
+          if (!success) {
+            if (rightEquivalence !== null) {
+              success = rightEquivalence.someOtherTerm(rightTerm, (otherTerm) => {
+                const rightTerm = otherTerm, ///
+                      leftTermNode = leftTerm.getNode(),
+                      rightTermNode = rightTerm.getNode(),
+                      descended = descend(leftTermNode, rightTermNode, context);
+
+                if (descended) {
+                  return true;
+                }
+              });
+            }
           }
         }
 
@@ -45,13 +69,7 @@ class EquationalPass extends ZipPass {
                 leftTermNodeMatchesRightTermNode = leftTermNode.match(rightTermNode, depth);
 
           if (leftTermNodeMatchesRightTermNode) {
-            const leftNonTerminalNode = leftTermNode, ///
-                  rightNonTerminalNode = rightTermNode, ///
-                  leftNonTerminalNodeChildNodes = leftNonTerminalNode.getChildNodes(),
-                  rightNonTerminalNodeChildNodes = rightNonTerminalNode.getChildNodes(),
-                  leftChildNodes = leftNonTerminalNodeChildNodes, ///
-                  rightChildNodes = rightNonTerminalNodeChildNodes, ///
-                  descended = equationalPass.descend(leftChildNodes, rightChildNodes, context);
+            const descended = descend(leftTermNode, rightTermNode, context);
 
             if (descended) {
               success = true;
@@ -68,7 +86,12 @@ class EquationalPass extends ZipPass {
 const equationalPass = new EquationalPass();
 
 export function equateTerms(leftTerm, rightTerm, context) {
-  let termsEquate;
+  let termsEquate = false;
+
+  const leftTermString = leftTerm.getString(),
+        rightTermString = rightTerm.getString();
+
+  context.trace(`Equating the '${leftTermString}' and '${rightTermString}' terms...`);
 
   const leftTermNode = leftTerm.getNode(),
         rightTermNode = rightTerm.getNode(),
@@ -76,13 +99,24 @@ export function equateTerms(leftTerm, rightTerm, context) {
         specificNode = rightTermNode, ///
         success = equationalPass.run(generalNode, specificNode, context);
 
-  termsEquate = success; ///
+  if (success) {
+    termsEquate = true;
+  }
+
+  if (termsEquate) {
+    context.debug(`...equated the '${leftTermString}' and '${rightTermString}' terms.`);
+  }
 
   return termsEquate;
 }
 
 export function equateStatements(leftStatement, rightStatement, context) {
-  let statementsEquate;
+  let statementsEquate = false;
+
+  const leftStatementString = leftStatement.getString(),
+        rightStatementString = rightStatement.getString();
+
+  context.trace(`Equating the '${leftStatementString}' and '${rightStatementString}' statements...`);
 
   const leftStatementNode = leftStatement.getNode(),
         rightStatementNode = rightStatement.getNode(),
@@ -90,7 +124,25 @@ export function equateStatements(leftStatement, rightStatement, context) {
         specificNode = rightStatementNode, ///
         success = equationalPass.run(generalNode, specificNode, context);
 
-  statementsEquate = success; ///
+  if (success) {
+    statementsEquate = true;
+  }
+
+  if (statementsEquate) {
+    context.debug(`...equated the '${leftStatementString}' and '${rightStatementString}' statements.`);
+  }
 
   return statementsEquate;
 }
+
+function descend(leftTermNode, rightTermNode, context) {
+  const leftNonTerminalNode = leftTermNode, ///
+        rightNonTerminalNode = rightTermNode, ///
+        leftNonTerminalNodeChildNodes = leftNonTerminalNode.getChildNodes(),
+        rightNonTerminalNodeChildNodes = rightNonTerminalNode.getChildNodes(),
+        leftChildNodes = leftNonTerminalNodeChildNodes, ///
+        rightChildNodes = rightNonTerminalNodeChildNodes, ///
+        descended = equationalPass.descend(leftChildNodes, rightChildNodes, context);
+
+  return descended;
+}

package/src/process/unification.js

@@ -127,8 +127,6 @@ function unifyStepWithSignatureAssertion(step, context, continuation) {
   context.trace(`Unifying the '${stepString}' step with the '${signatureAssertionString}' signature assertion...`);
 
   return signatureAssertion.unifyStepAndFactOrSubproofs(step, factOrSubproofs, context, (stepAndFactOrSubproofsUnify) => {
-    let stepUnifiesWithSignatureAssertion = false;
-
     if (stepAndFactOrSubproofsUnify) {
       stepUnifiesWithSignatureAssertion = true;
     }