occam-furtle 3.0.461 → 3.0.464

package/src/element/binding.js

@@ -27,9 +27,9 @@ export default define(class Binding extends Element {
     return this.elided;
   }
 
-  compareTerm(term, context) {
+  compareTerm(term, context, back, forward) {
     if (this.elided) {
-      return;
+      return forward();
     }
 
     const termString = term.getString(),
@@ -45,10 +45,12 @@ export default define(class Binding extends Element {
             message = `The '${termString}' term's '${termType}' type is not equal to the '${bindingString}' binding's '${typeString}' type.`,
             exception = Exception.fromMessage(message);
 
-      throw exception;
+      return back(exception);
     }
 
     context.debug(`...comparing the '${termString}' term against the '${bindingString}' binding.`);
+
+    return forward();
   }
 
   static name = "Binding";

package/src/element/bindings/named.js

@@ -1,11 +1,13 @@
 "use strict";
 
-import { Element } from "occam-languages";
+import { Element, continuationUtilities } from "occam-languages";
 
 import Exception from "../../exception";
 
 import { define } from "../../elements";
 
+const { some, forEach } = continuationUtilities;
+
 export default define(class NamedBindings extends Element {
   constructor(context, string, node, breakPoint, array) {
     super(context, string, node, breakPoint);
@@ -29,11 +31,15 @@ export default define(class NamedBindings extends Element {
     return namedBinding;
   }
 
-  someNamedBinding(callback) { return this.array.some(callback); }
+  someNamedBinding(callback, back, forward) {
+    return some(this.array, callback, back, forward);
+  }
 
-  forEachNamedBinding(callback) { this.array.forEach(callback); }
+  forEachNamedBinding(callback, back, forward) {
+    return forEach(this.array, callback, back, forward);
+  }
 
-  compareTerms(terms, context) {
+  compareTerms(terms, context, back, forward) {
     const termsString = terms.getString(),
           namedBindingsString = this.getString(); ///
 
@@ -46,54 +52,60 @@ export default define(class NamedBindings extends Element {
       const message = `The '${termsString}' terms and '${namedBindingsString}' named bindings are not of the same length.`,
             exception = Exception.fromMessage(message);
 
-      throw exception;
+      return back(exception);
     }
 
-    this.forEachNamedBinding((namedBinding, index) => {
-      if (namedBinding !== null) {
-        const term = terms.getTerm(index);
-
-        namedBinding.compareTerm(term, context);
+    return this.forEachNamedBinding((namedBinding, back, forward, index) => {
+      if (namedBinding === null) {
+        return forward();
       }
-    });
 
-    context.debug(`...compared the '${termsString}' terms with the '${namedBindingsString}' named bindings.`);
+      const term = terms.getTerm(index);
+
+      return namedBinding.compareTerm(term, context, back, forward);
+    }, back, () => {
+      context.debug(`...compared the '${termsString}' terms with the '${namedBindingsString}' named bindings.`);
+
+      return forward();
+    });
   }
 
-  compareNamedBinding(namedBinding, context) {
+  compareNamedBinding(namedBinding, context, back, forward) {
     const namedBindingString = namedBinding.getString(),
           namedBindingsString = this.getString(); ///
 
     context.trace(`Comparing the '${namedBindingString}' namedBinding with the '${namedBindingsString}' named bindings...`);
 
-    const namedBindingA = namedBinding, ///
-          namedBindingCompares = this.someNamedBinding((namedBinding) => {
-            if (namedBinding !== null) {
-              const namedBindingB = namedBinding, ///
-                    namedBindingBComparesToNamedBindingA = namedBindingA.compareNamedBinding(namedBindingB, context);
+    const namedBindingA = namedBinding; ///
 
-              if (namedBindingBComparesToNamedBindingA) {
-                return true;
-              }
-            }
-          });
+    return this.someNamedBinding((namedBinding) => {
+      if (namedBinding !== null) {
+        const namedBindingB = namedBinding; ///
 
-    if (!namedBindingCompares) {
-      const message = `The '${namedBindingString}' namedBinding does not compare to any of the '${namedBindingsString}' named bindings.`,
-            exception = Exception.fromMessage(message);
+        return namedBindingA.compareNamedBinding(namedBindingB, context, back, forward);
+      }
+    }, back, (namedBindingCompares) => {
+      if (!namedBindingCompares) {
+        const message = `The '${namedBindingString}' namedBinding does not compare to any of the '${namedBindingsString}' named bindings.`,
+              exception = Exception.fromMessage(message);
 
-      throw exception;
-    }
+        return back(exception);
+      }
+
+      context.debug(`...compared the '${namedBindingString}' namedBinding with the '${namedBindingsString}' named bindings.`);
 
-    context.debug(`...compared the '${namedBindingString}' namedBinding with the '${namedBindingsString}' named bindings.`);
+      return forward();
+    });
   }
 
-  compareNamedBindings(namedBindings, context) {
-    namedBindings.forEachNamedBinding((namedBinding) => {
-      if (namedBinding !== null) {
-        this.compareNamedBinding(namedBinding, context);
+  compareNamedBindings(namedBindings, context, back, forward) {
+    return namedBindings.forEachNamedBinding((namedBinding, back, forward) => {
+      if (namedBinding === null) {
+        return forward();
       }
-    });
+
+      return this.compareNamedBinding(namedBinding, context, back, forward);
+    }, back, forward);
   }
 
   static name = "NamedBindings";

package/src/element/bindings.js

@@ -1,11 +1,13 @@
 "use strict";
 
-import { Element } from "occam-languages";
+import { Element, continuationUtilities } from "occam-languages";
 
 import Exception from "../exception";
 
 import { define } from "../elements";
 
+const { forEach } = continuationUtilities;
+
 export default define(class Bindings extends Element {
   constructor(context, string, node, breakPoint, array) {
     super(context, string, node, breakPoint);
@@ -29,9 +31,11 @@ export default define(class Bindings extends Element {
     return binding;
   }
 
-  forEachBinding(callback) { this.array.forEach(callback); }
+  forEachBinding(callback, back, forward) {
+    return forEach(this.array, callback, back, forward);
+  }
 
-  compareTerms(terms, context) {
+  compareTerms(terms, context, back, forward) {
     const termsString = terms.getString(),
           bindingsString = this.getString(); ///
 
@@ -44,18 +48,22 @@ export default define(class Bindings extends Element {
       const message = `The '${termsString}' expressions and '${bindingsString}' bindings are not of the same length.`,
             exception = Exception.fromMessage(message);
 
-      throw exception;
+      return back(exception);
     }
 
-    this.forEachBinding((binding, index) => {
-      if (binding !== null) {
-        const term = terms.getTerm(index);
-
-        binding.compareTerm(term, context);
+    return this.forEachBinding((binding, back, forward, index) => {
+      if (binding === null) {
+        return forward();
       }
-    });
 
-    context.debug(`...compared the '${termsString}' terms against the '${bindingsString}' bindings.`);
+      const term = terms.getTerm(index);
+
+      return binding.compareTerm(term, context, back, forward);
+    }, back, () => {
+      context.debug(`...compared the '${termsString}' terms against the '${bindingsString}' bindings.`);
+
+      forward();
+    });
   }
 
   static name = "Bindings";

package/src/element/contains.js

@@ -24,7 +24,7 @@ export default define(class Contains extends Element {
     return this.substring;
   }
 
-  evaluate(context) {
+  evaluate(context, back, forward) {
     let value;
 
     const containsString = this.getString();  ///
@@ -41,7 +41,7 @@ export default define(class Contains extends Element {
             message = `The '${valueString}' value's '${valueType}' type should be '${STRING_TYPE_NAME}'.`,
             exception = Exception.fromMessage(message);
 
-      throw exception;
+      return back(exception);
     }
 
     const string = value.getString(),
@@ -53,7 +53,7 @@ export default define(class Contains extends Element {
 
     context.debug(`...evaluated the '${containsString}' function as '${valueString}'.`);
 
-    return value;
+    return forward(value);
   }
 
   static name = "Contains";

package/src/element/endsWith.js

@@ -24,7 +24,7 @@ export default define(class EndsWith extends Element {
     return this.substring;
   }
 
-  evaluate(context) {
+  evaluate(context, back, forward) {
     let value;
 
     const endsWithString = this.getString();  ///
@@ -41,7 +41,7 @@ export default define(class EndsWith extends Element {
             message = `The '${valueString}' value's '${valueType}' type should be '${STRING_TYPE_NAME}'.`,
             exception = Exception.fromMessage(message);
 
-      throw exception;
+      return back(exception);
     }
 
     const string = value.getString(),
@@ -53,7 +53,7 @@ export default define(class EndsWith extends Element {
 
     context.debug(`...evaluated the '${endsWithString}' function as '${valueString}'.`);
 
-    return value;
+    return forward(value);
   }
 
   static name = "EndsWith";

package/src/element/every.js

@@ -43,7 +43,7 @@ export default define(class Every extends Element {
             message = `The '${valueString}' value's '${valueType}' type should be '${LIST_TYPE_NAME}'.`,
             exception = Exception.fromMessage(message);
 
-      throw exception;
+      return back(exception);
     }
 
     const nodes = value.getNodes();
@@ -62,14 +62,14 @@ export default define(class Every extends Element {
                 message = `The '${valueString}' value's type is '${valueType}' when it should be of type '${BOOLEAN_TYPE_NAME}'.`,
                 exception = Exception.fromMessage(message);
 
-          throw exception;
+          return back(exception);
         }
 
         const boolean = value.getBoolean();
 
         return forward(boolean);
       });
-    }, (boolean) => {
+    }, back, (boolean) => {
       const value = valueFromBoolean(boolean, context),
             valueString = value.getString();
 

package/src/element/expression.js

@@ -126,59 +126,41 @@ export default define(class Expression extends Element {
   }
 
   evaluate(context, back, forward) {
-    let value = null;
-
     if (false) {
       ///
     } else if (this.term !== null) {
-      value = this.term.evaluate(context);
+      return this.term.evaluate(context, back, forward);
     } else if (this.nodeQuery !== null) {
-      value = this.nodeQuery.evaluate(context);
+      return this.nodeQuery.evaluate(context, back, forward);
     } else if (this.nodesQuery !== null) {
-      value = this.nodesQuery.evaluate(context);
+      return this.nodesQuery.evaluate(context, back, forward);
     } else if (this.lengthOf !== null) {
-      value = this.lengthOf.evaluate(context);
+      return this.lengthOf.evaluate(context, back, forward);
     } else if (this.toInteger !== null) {
-      value = this.toInteger.evaluate(context);
+      return this.toInteger.evaluate(context, back, forward);
     } else if (this.tryInteger !== null) {
-      value = this.tryInteger.evaluate(context);
+      return this.tryInteger.evaluate(context, back, forward);
     } else if (this.contains !== null) {
-      value = this.contains.evaluate(context);
+      return this.contains.evaluate(context, back, forward);
     } else if (this.endsWith !== null) {
-      value = this.endsWith.evaluate(context);
+      return this.endsWith.evaluate(context, back, forward);
     } else if (this.startsWith !== null) {
-      value = this.startsWith.evaluate(context);
-    }
-
-    if (value !== null) {
-      return forward(value);
-    }
-
-    if (this.some !== null) {
+      return this.startsWith.evaluate(context, back, forward);
+    } else if (this.some !== null) {
       return this.some.evaluate(context, back, forward);
-    }
-
-    if (this.every !== null) {
-       return this.every.evaluate(context, back, forward);
-    }
-
-    if (this.reduce !== null) {
+    } else if (this.every !== null) {
+     return this.every.evaluate(context, back, forward);
+    } else if (this.reduce !== null) {
       return this.reduce.evaluate(context, back, forward);
-    }
-
-    if (this.ternary !== null) {
+    } else if (this.ternary !== null) {
       return this.ternary.evaluate(context, back, forward);
-    }
-
-    if (this.returnBlock !== null) {
+    } else if (this.procedureCall !== null) {
+      return this.procedureCall.evaluate(context, back, forward);
+    } else if (this.returnBlock !== null) {
       const variables = [];
 
       return this.returnBlock.evaluate(variables, context, back, forward);
     }
-
-    if (this.procedureCall !== null) {
-      return this.procedureCall.evaluate(context, back, forward);
-    }
   }
 
   static name = "Expression";

package/src/element/lengthOf.js

@@ -19,7 +19,7 @@ export default define(class LengthOf extends Element {
     return this.variable;
   }
 
-  evaluate(context) {
+  evaluate(context, back, forward) {
     let value;
 
     const lengthOfString = this.getString();  ///
@@ -36,7 +36,7 @@ export default define(class LengthOf extends Element {
             message = `The '${valueString}' value's '${valueType}' type should be '${LIST_TYPE_NAME}'.`,
             exception = Exception.fromMessage(message);
 
-      throw exception;
+      return back(exception);
     }
 
     const primitiveValue = value.getPrimitiveValue(),
@@ -49,7 +49,7 @@ export default define(class LengthOf extends Element {
 
     context.debug(`...evaluated the '${lengthOfString}' function as '${valueString}'.`);
 
-    return value;
+    return forward(value);
   }
 
   static name = "LengthOf";

package/src/element/nodeQuery.js

@@ -28,7 +28,7 @@ export default define(class NodeQuery extends Element {
     return this.query;
   }
 
-  evaluate(context) {
+  evaluate(context, back, forward) {
     let value;
 
     const nodeQueryString = this.getString();  ///
@@ -39,7 +39,7 @@ export default define(class NodeQuery extends Element {
       const message = `Cannot evaluate the '${nodeQueryString}' function because its expression is malformed.`,
             exception = Exception.fromMessage(message);
 
-      throw exception;
+      return back(exception);
     }
 
     value = this.variable.evaluate(context);
@@ -52,7 +52,7 @@ export default define(class NodeQuery extends Element {
             message = `The '${valueString}' value's '${valueType}' type should be '${NOMINAL_VALUE_TYPE_NAME}'.`,
             exception = Exception.fromMessage(message);
 
-      throw exception;
+      return back(exception);
     }
 
     let node;
@@ -67,7 +67,7 @@ export default define(class NodeQuery extends Element {
             message = `The '${valueString}' value's node is null.`,
             exception = Exception.fromMessage(message);
 
-      throw exception;
+      return back(exception);
     }
 
     const nodes = this.query.execute(node),
@@ -89,14 +89,14 @@ export default define(class NodeQuery extends Element {
       const message = `The length of the returned nodes is ${nodesLength} when it should be 0 or 1.`,
             exception = Exception.fromMessage(message);
 
-      throw exception;
+      return back(exception);
     }
 
     const valueString = value.getString();
 
     context.debug(`...evaluated the '${nodeQueryString}' function as '${valueString}'.`);
 
-    return value;
+    return forward(value);
   }
 
   static name = "NodeQuery";

package/src/element/nodesQuery.js

@@ -24,7 +24,7 @@ export default define(class NodesQuery extends Element {
     return this.query;
   }
 
-  evaluate(context) {
+  evaluate(context, back, forward) {
     let value;
 
     const nodesQueryString = this.getString();  ///
@@ -35,7 +35,7 @@ export default define(class NodesQuery extends Element {
       const message = `Cannot evaluate the '${nodesQueryString}' function because its expression is malformed.`,
             exception = Exception.fromMessage(message);
 
-      throw exception;
+      return back(exception);
     }
 
     value = this.variable.evaluate(context);
@@ -48,7 +48,7 @@ export default define(class NodesQuery extends Element {
             message = `The '${valueString}' value's '${valueType}' type should be '${NOMINAL_VALUE_TYPE_NAME}'.`,
             exception = Exception.fromMessage(message);
 
-      throw exception;
+      return back(exception);
     }
 
     let node;
@@ -63,7 +63,7 @@ export default define(class NodesQuery extends Element {
             message = `The '${valueString}' value's node is null.`,
             exception = Exception.fromMessage(message);
 
-      throw exception;
+      return back(exception);
     }
 
     const nodes = this.query.execute(node);
@@ -74,7 +74,7 @@ export default define(class NodesQuery extends Element {
 
     context.debug(`...evaluated the '${nodesQueryString}' function as '${valueString}'.`);
 
-    return value;
+    return forward(value);
   }
 
   static name = "NodesQuery";

package/src/element/parameter.js

@@ -22,7 +22,7 @@ export default define(class Parameter extends Element {
     return this.name;
   }
 
-  compareValue(value, context) {
+  compareValue(value, context, back, forward) {
     const valueString = value.getString(),
           parameterString = this.getString();  ///
 
@@ -36,10 +36,12 @@ export default define(class Parameter extends Element {
             message = `The '${valueString}' value's '${valueType}' type is not equal to the '${parameterString}' parameter's '${typeString}' type.`,
             exception = Exception.fromMessage(message);
 
-      throw exception;
+      return back(exception);
     }
 
     context.debug(`...comparing the '${valueString}' value against the '${parameterString}' parameter.`);
+
+    return forward();
   }
 
   static name = "Parameter";

package/src/element/parameters.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import { Element, breakPointUtilities } from "occam-languages";
+import { Element, breakPointUtilities, continuationUtilities } from "occam-languages";
 
 import Exception from "../exception";
 
@@ -9,7 +9,8 @@ import { instantiate } from "../utilities/context";
 import { instantiateParameters } from "../process/instantiate";
 import { parametersArrayFromParametersNode } from "../utilities/element";
 
-const { breakPointToBreakPointJSON } = breakPointUtilities;
+const { forEach } = continuationUtilities,
+      { breakPointToBreakPointJSON } = breakPointUtilities;
 
 export default define(class Parameters extends Element {
   constructor(context, string, node, breakPoint, array) {
@@ -34,9 +35,11 @@ export default define(class Parameters extends Element {
     return parameter;
   }
 
-  forEachParameter(callback) { this.array.forEach(callback); }
+  forEachParameter(callback, back, forward) {
+    return forEach(this.array, callback, back, forward);
+  }
 
-  compareValues(values, context) {
+  compareValues(values, context, back, forward) {
     const valuesString = values.getString(),
           parametersString = this.getString(); ///
 
@@ -49,18 +52,22 @@ export default define(class Parameters extends Element {
       const message = `The '${valuesString}' expressions and '${parametersString}' parameters are not of the same length.`,
             exception = Exception.fromMessage(message);
 
-      throw exception;
+      return back(exception);
     }
 
-    this.forEachParameter((parameter, index) => {
-      if (parameter !== null) {
-        const value = values.getValue(index);
-
-        parameter.compareValue(value, context);
+    return this.forEachParameter((parameter, back, forward, index) => {
+      if (parameter === null) {
+        return forward();
       }
-    });
 
-    context.debug(`...compared the '${valuesString}' values against the '${parametersString}' parameters.`);
+      const value = values.getValue(index);
+
+      return parameter.compareValue(value, context, back, forward);
+    }, back, () => {
+      context.debug(`...compared the '${valuesString}' values against the '${parametersString}' parameters.`);
+
+      return forward();
+    });
   }
 
   toJSON() {

package/src/element/primitive.js

@@ -26,12 +26,12 @@ export default define(class Primitive extends Element {
     return this.value;
   }
 
-  evaluate(context) {
+  evaluate(context, back, forward) {
     const { Term } = elements,
           primitive = this,
           term = Term.fromPrimitive(primitive, context);
 
-    return term;
+    return forward(term);
   }
 
   isEqualTo(primitive) {

package/src/element/procedure.js

@@ -83,28 +83,28 @@ export default define(class Procedure extends Element {
 
     context.trace(`Calling the '${procedureString}' function...`);
 
-    this.parameters.compareValues(values, context);
+    return this.parameters.compareValues(values, context, back, () => {
+      this.guaranteeReturnBlock();
 
-    this.guaranteeReturnBlock();
+      const variables = variablesFromValuesAndParameters(values, this.parameters, context);
 
-    const variables = variablesFromValuesAndParameters(values, this.parameters, context);
+      return this.returnBlock.evaluate(variables, context, back, (value) => {
+        const valueType = value.getType(),
+              typeEqualToValueType = this.type.isEqualTo(valueType);
 
-    return this.returnBlock.evaluate(variables, context, back, (value) => {
-      const valueType = value.getType(),
-            typeEqualToValueType = this.type.isEqualTo(valueType);
+        if (!typeEqualToValueType) {
+          const valueString = value.getString(),
+                typeString = this.type.getString(),
+                message = `The '${valueString}' value's '${typeString}' type is not equal to the '${procedureString}' function's '${typeString}' type.`,
+                exception = Exception.fromMessage(message);
 
-      if (!typeEqualToValueType) {
-        const valueString = value.getString(),
-              typeString = this.type.getString(),
-              message = `The '${valueString}' value's '${typeString}' type is not equal to the '${procedureString}' function's '${typeString}' type.`,
-              exception = Exception.fromMessage(message);
+          return back(exception);
+        }
 
-        throw exception;
-      }
+        context.debug(`...called the '${procedureString}' function.`);
 
-      context.debug(`...called the '${procedureString}' function.`);
-
-      return forward(value);
+        return forward(value);
+      });
     });
   });