occam-nominal 1.0.427 → 1.0.430

package/src/element/signature.js

@@ -1,16 +1,15 @@
 "use strict";
 
 import { arrayUtilities } from "necessary";
-import { Element, breakPointUtilities, continuationUtilities } from "occam-languages";
+import { Element, breakPointUtilities } from "occam-languages";
 
 import { define } from "../elements";
+import { declare } from "../utilities/state";
+import { all, every } from "../utilities/continuation";
 import { instantiateSignature } from "../process/instantiate";
-import { signatureFromSignatureNode } from "../utilities/element";
-import { ablate, attempt, reconcile, serialise, unserialise, instantiate } from "../utilities/context";
-import {all} from "../utilities/continuation";
+import { attempt, reconcile, serialise, unserialise, instantiate } from "../utilities/context";
 
 const { match } = arrayUtilities,
-      { asynchronousEvery } = continuationUtilities,
       { breakPointFromJSON, breakPointToBreakPointJSON } = breakPointUtilities;
 
 export default define(class Signature extends Element {
@@ -60,44 +59,33 @@ export default define(class Signature extends Element {
     return signatureNodeMatches;
   }
 
-  findSignature(context) {
-    const signatureNode = this.getSignatureNode(),
-          signature = context.findSignatureBySignatureNode(signatureNode);
-
-    return signature;
-  }
-
-  verify(context) {
+  verify(context, continuation) {
     let verifies = false;
 
-    const signatureString = this.getString();  ///
+    const signatureString = this.getString(); ///
 
     context.trace(`Verifying the '${signatureString}' signature...`);
 
-    debugger
+    declare((state) => {
+      const validates = this.validate(state, context, (conclusion, context) => true);
 
-    const termsValidate = this.validateTerms(context);
-
-    if (termsValidate !== null) {
-      verifies = true;
-    }
-
-    if (verifies) {
-      this.commit(context);
-    }
+      if (validates) {
+        verifies = true;
+      }
+    });
 
     if (verifies) {
-      context.debug(`...validated the '${signatureString}' signature.`);
+      context.debug(`...verified the '${signatureString}' signature.`);
     }
 
-    return verifies;
+    return continuation(verifies, context);
   }
 
   validate(state, context, continuation) {
     let validates;
 
     const specificContext = context,  ///
-          signatureString = this.getString(); ///
+          signatureString = this.getString();
 
     context.trace(`Validating the '${signatureString}' signature...`);
 
@@ -130,32 +118,52 @@ export default define(class Signature extends Element {
     return validates;
   }
 
-  validateTerms(context) {
+  validateTerm(term, terms, state, context, continuation) {
+    let termValidates;
+
+    const termString = term.getString(),
+          signatureString = this.getString();  ///
+
+    context.trace(`Validating the '${signatureString}' signature's '${termString}' term...`);
+
+    termValidates = term.validate(state, context, (term, context) => {
+      let validates;
+
+      terms.push(term);
+
+      validates = continuation(terms, state, context);
+
+      return validates;
+    });
+
+    if (termValidates) {
+      context.debug(`...validated the '${signatureString}' signature's '${termString}' term.`);
+    }
+
+    return termValidates;
+  }
+
+  validateTerms(state, context, continuation) {
     let termsValidate;
 
     const signatureString = this.getString();  ///
 
     context.trace(`Validating the '${signatureString}' signature's terms...`);
 
-    const terms = [];
+    const terms = [],
+          validateTerm = this.validateTerm.bind(this);
 
-    termsValidate = asynchronousEvery(this.terms, (term) => {
-      term = term.validate(state, context, (term, context) => { ///
-        const validatesForwards = true;
+    termsValidate = every(this.terms, validateTerm, terms, state, context, (terms, state, context) => {
+      let termsValidate;
 
-        return validatesForwards;
-      });
-
-      if (term !== null) {
-        terms.push(term);
+      termsValidate = continuation(state, context);
 
-        return true;
+      if (termsValidate) {
+        this.terms = terms;
       }
-    });
 
-    if (termsValidate) {
-      this.terms = terms;
-    }
+      return termsValidate;
+    });
 
     if (termsValidate){
       context.debug(`...validated the '${signatureString}' signature's terms.`);
@@ -164,8 +172,10 @@ export default define(class Signature extends Element {
     return termsValidate
   }
 
-  unifySignature(signature, context) {
-    let signatureUnifies;
+  unifyTerms(terms, context, continuation) {
+    let termsUnify;
+
+    debugger
 
     const generalSignature = this,  ///
           specificSignature = signature,  ///
@@ -185,7 +195,7 @@ export default define(class Signature extends Element {
 
     debugger
 
-    signatureUnifies = reconcile((specificContext) => {
+    termsUnify = reconcile((specificContext) => {
       match(generalTerms, specificTerms, (generalTerm, specificTerm) => {
         let termUnifies;
 
@@ -196,16 +206,16 @@ export default define(class Signature extends Element {
         }
       });
 
-      if (signatureUnifies) {
+      if (termsUnify) {
         specificContext.commit(context);
       }
     }, specificContext);
 
-    if (signatureUnifies) {
+    if (termsUnify) {
       context.debug(`...unified the '${specificSignatureString}' signature with the '${generalSignatureString}' signature.`);
     }
 
-    return signatureUnifies;
+    return termsUnify;
   }
 
   toJSON() {
@@ -251,21 +261,6 @@ export default define(class Signature extends Element {
 
     return signature;
   }
-
-  static fromSignatureString(signatureString, context) {
-    let signature;
-
-    ablate((context) => {
-      instantiate((context) => {
-        const string = signatureString,  ///
-              signatureNode = instantiateSignature(string, context);
-
-        signature = signatureFromSignatureNode(signatureNode, context);
-      }, context);
-    }, context);
-
-    return signature;
-  }
 });
 
 function termsFromSignatureNode(signatureNode, context) {

package/src/node/assertion/signature.js

@@ -2,14 +2,14 @@
 
 import AssertionNode from "../../node/assertion";
 
-import { SIGNATURE_RULE_NAME, METAVARIABLE_RULE_NAME } from "../../ruleNames";
+import { TERM_RULE_NAME, METAVARIABLE_RULE_NAME } from "../../ruleNames";
 
 export default class SignatureAssertionNode extends AssertionNode {
-  getSignatureNode() {
-    const ruleName = SIGNATURE_RULE_NAME,
-          signatureNode = this.getNodeByRuleName(ruleName);
+  getTermNodes() {
+    const ruleName = TERM_RULE_NAME,
+          termNodes = this.getNodesByRuleName(ruleName);
 
-    return signatureNode;
+    return termNodes;
   }
 
   getMetavariableNode() {

package/src/node/header.js

@@ -2,7 +2,7 @@
 
 import { NonTerminalNode } from "occam-languages";
 
-import { SIGNATURE_RULE_NAME, PARENTHESISED_LABEL_RULE_NAME, PARENTHESISED_LABELS_RULE_NAME } from "../ruleNames";
+import { PARENTHESISED_LABEL_RULE_NAME, PARENTHESISED_LABELS_RULE_NAME } from "../ruleNames";
 
 export default class HeaderNode extends NonTerminalNode {
   getLabelNodes() {
@@ -30,8 +30,7 @@ export default class HeaderNode extends NonTerminalNode {
   }
 
   getSignatureNode() {
-    const ruleName = SIGNATURE_RULE_NAME,
-          signatureNode = this.getNodeByRuleName(ruleName);
+    const signatureNode = null;
 
     return signatureNode;
   }

package/src/utilities/continuation.js

@@ -1,28 +1,5 @@
 "use strict";
 
-export function any(array, callback, ...initialArguments) {
-  let success = false;
-
-  const continuation = initialArguments.pop(),
-        length = array.length;
-
-  let count = 0;
-
-  for (let index = 0; index < length; index++) {
-    const element = array[index];
-
-    success = callback(element, ...initialArguments, continuation);
-
-    if (success) {
-      count++;
-    }
-  }
-
-  success = (count >= 1);
-
-  return success;
-}
-
 export function one(array, callback, ...initialArguments) {
   let success = false;
 

package/src/utilities/element.js

@@ -778,12 +778,12 @@ export function signatureAssertionFromSignatureAssertionNode(signatureAssertionN
         node = signatureAssertionNode,  ///
         string = context.nodeAsString(node),
         breakPoint = null,
-        signature = signatureFromSignatureAssertionNode(signatureAssertionNode, context),
+        terms = termsFromSignatureAssertionNode(signatureAssertionNode, context),
         reference = referenceFromSignatureAssertionNode(signatureAssertionNode, context);
 
   context = null;
 
-  const signatureAssertion = new SignatureAssertion(context, string, node, breakPoint, signature, reference);
+  const signatureAssertion = new SignatureAssertion(context, string, node, breakPoint, terms, reference);
 
   return signatureAssertion;
 }
@@ -1208,10 +1208,7 @@ export function signatureFromClaimNode(claimNode, context) {
   const signatureNode = claimNode.getSignatureNode();
 
   if (signatureNode !== null) {
-    const { Signature } = elements,
-      signatureString = context.nodeAsString(signatureNode);
-
-    signature = Signature.fromSignatureString(signatureString, context);
+    signature = signatureFromSignatureNode(signatureNode, context);
   }
 
   return signature;
@@ -1810,6 +1807,13 @@ export function parametersFromProcedureCallNode(procedureCallNode, context) {
   return parameters;
 }
 
+export function termsFromSignatureAssertionNode(signatureAssertionNode, context) {
+  const termNodes = signatureAssertionNode.getTermNodes(),
+        terms = termsFromTermNodes(termNodes, context);
+
+  return terms;
+}
+
 export function typeFromPropertyDeclarationNode(propertyDeclarationNode, context) {
   const typeNode = propertyDeclarationNode.getTypeNode(),
         type = typeFromTypeNode(typeNode, context);
@@ -2018,15 +2022,6 @@ export function statementFromContainedAssertionNode(containedAssertionNode, cont
   return statement;
 }
 
-export function signatureFromSignatureAssertionNode(signatureAssertionNode, context) {
-  const { Signature } = elements,
-        signatureNode = signatureAssertionNode.getSignatureNode(),
-        signatureString = context.nodeAsString(signatureNode),
-        signature = Signature.fromSignatureString(signatureString, context);
-
-  return signature;
-}
-
 export function referenceFromSignatureAssertionNode(signatureAssertionNode, context) {
   const metavariableNode = signatureAssertionNode.getMetavariableNode(),
         reference = referenceFromMetavariableNode(metavariableNode, context);