occam-furtle 2.0.64 → 2.0.65

package/src/_occam-grammars/furtle/bnf.js

@@ -22,8 +22,6 @@ objectAssignment       ::=  "{" parameters "}" "=" variable ";" ;
 
 arrayAssignment        ::=  "[" parameters "]" "=" variable ";" ;
                                                       
-someLoop               ::=  "Some"<NO_WHITESPACE>"(" variable "," anonymousProcedure ")" ";" ;
-
 
 
 anonymousProcedure     ::=  "(" parameters? ")" returnBlock ;
@@ -71,8 +69,6 @@ step                   ::=  variablesDeclaration
                           
                          |  arrayAssignment
                           
-                         |  someLoop
-                          
                          ;  
   
   
@@ -83,6 +79,8 @@ assignment             ::=  "=" value ;
 
 value                  ::=  procedureCall
  
+                         |  comparison
+
                          |  nodesQuery
                           
                          |  nodeQuery
@@ -91,6 +89,8 @@ value                  ::=  procedureCall
                           
                          |  ternary
                           
+                         |  some
+
                          |  [null]
 
                          |  [number]
@@ -113,6 +113,8 @@ variable               ::=  [name] ;
 
 ternary                ::=  "If" "(" condition ")" value "Else" value ;
 
+some                   ::=  "Some"<NO_WHITESPACE>"(" variable "," anonymousProcedure ")" ";" ;
+
 
 
 parameters             ::=  parameter ( "," parameter )* ;

package/src/dom/block.js

@@ -6,8 +6,7 @@ import BlockContext from "../context/block";
 import { domAssigned } from "../dom";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
-const stepNodesQuery = nodesQuery("/block/step"),
-      forEachLoopBlockNodeQuery = nodeQuery("/forEachLoop/anonymousProcedure/block");
+const stepNodesQuery = nodesQuery("/block/step");
 
 export default domAssigned(class Block {
   constructor(string, steps) {
@@ -55,18 +54,6 @@ export default domAssigned(class Block {
 
     return block;
   }
-
-  static fromForEachLoopNode(forEachLoopNode, context) {
-    const forEachLoopBockNode = forEachLoopBlockNodeQuery(forEachLoopNode),
-          blockNode = forEachLoopBockNode,  ///
-          stepNodes = stepNodesQuery(blockNode),
-          node = blockNode, ///
-          string = context.nodeAsString(node),
-          steps = stepsFromStepNodes(stepNodes, context),
-          block = new Block(string, steps);
-
-    return block;
-  }
 });
 
 function stepsFromStepNodes(stepNodes, context) {

package/src/dom/comparison.js

@@ -10,7 +10,8 @@ import { domAssigned } from "../dom";
 const terminalNodeQuery = nodeQuery("/comparison/@*"),
       leftValueNodeQuery = nodeQuery("/comparison/value[0]"),
       rightValueNodeQuery = nodeQuery("/comparison/value[1]"),
-      comparisonNodeQuery = nodeQuery("/condition/comparison");
+      valueComparisonNodeQuery = nodeQuery("/value/comparison"),
+      conditionComparisonNodeQuery = nodeQuery("/condition/comparison");
 
 export default domAssigned(class Comparison {
   constructor(string, negated, leftValue, rightValue) {
@@ -76,22 +77,29 @@ export default domAssigned(class Comparison {
 
   static name = "Comparison";
 
+  static fromValueNode(valudNode, context) {
+    let comparison = null;
+
+    const valueComparisonNode = valueComparisonNodeQuery(valudNode);
+
+    if (valueComparisonNode !== null) {
+      const comparisonNode = valueComparisonNode; ///
+
+      comparison = comparisonFromComparisonNode(comparisonNode, context);
+    }
+
+    return comparison;
+  }
+
   static fromConditionNode(conditionNode, context) {
     let comparison = null;
 
-    const comparisonNode = comparisonNodeQuery(conditionNode);
+    const conditionComparisonNode = conditionComparisonNodeQuery(conditionNode);
 
-    if (comparisonNode !== null) {
-      const { Value } = dom,
-            node = comparisonNode,  ///
-            string = context.nodeAsString(node),
-            leftValueNode = leftValueNodeQuery(comparisonNode),
-            rightValueNode = rightValueNodeQuery(comparisonNode),
-            negated = negatedFromComparisonNode(comparisonNode, context),
-            leftValue = Value.fromValueNode(leftValueNode, context),
-            rightValue = Value.fromValueNode(rightValueNode, context);
+    if (conditionComparisonNode !== null) {
+      const comparisonNode = conditionComparisonNode; ///
 
-      comparison = new Comparison(string, negated, leftValue, rightValue);
+      comparison = comparisonFromComparisonNode(comparisonNode, context);
     }
 
     return comparison;
@@ -104,4 +112,18 @@ function negatedFromComparisonNode(comparisonNode) {
         negated = (terminalNodeContent !== EQUAL_TO);
 
   return negated;
-}
+}
+
+function comparisonFromComparisonNode(comparisonNode, context) {
+  const { Value, Comparison } = dom,
+        node = comparisonNode,  ///
+        string = context.nodeAsString(node),
+        leftValueNode = leftValueNodeQuery(comparisonNode),
+        rightValueNode = rightValueNodeQuery(comparisonNode),
+        negated = negatedFromComparisonNode(comparisonNode, context),
+        leftValue = Value.fromValueNode(leftValueNode, context),
+        rightValue = Value.fromValueNode(rightValueNode, context),
+        comparison = new Comparison(string, negated, leftValue, rightValue);
+
+  return comparison;
+}

package/src/dom/parameters.js

@@ -6,8 +6,8 @@ import Exception from "../exception";
 import { domAssigned } from "../dom";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
-const parametersNodeQuery = nodeQuery("/forEachLoop/anonymousProcedure/parameters"),
-      parameterNodesQuery = nodesQuery("/parameters/parameter"),
+const parameterNodesQuery = nodesQuery("/parameters/parameter"),
+      someParametersNodeQuery = nodeQuery("/some/parameters"),
       arrayAssignmentParametersNodeQuery = nodeQuery("/arrayAssignment/parameters"),
       objectAssignmentParametersNodeQuery = nodeQuery("/objectAssignment/parameters"),
       procedureDeclarationParametersNodeQuery = nodeQuery("/procedureDeclaration/parameters");
@@ -107,16 +107,11 @@ export default domAssigned(class Parameters {
 
   static name = "Parameters";
 
-  static fromStringAndArray(string, array) {
-    const parameters = new Parameters(string, array);
-
-    return parameters;
-  }
-
-  static fromForEachLoopNode(forEachLoopNode, context) {
+  static fromSomeNode(someNode, context) {
     const { Parameter } = dom,
-          parametersNode = parametersNodeQuery(forEachLoopNode),
-          parameterNodes = parameterNodesQuery(parametersNode),
+          someParametersNode = someParametersNodeQuery(someNode),
+          parameterNode = someParametersNode, ///
+          parameterNodes = parameterNodesQuery(parameterNode),
           array = parameterNodes.map((parameterNode) => {
             const parameter = Parameter.fromParameterNode(parameterNode, context);
 
@@ -128,6 +123,12 @@ export default domAssigned(class Parameters {
     return parameters;
   }
 
+  static fromStringAndArray(string, array) {
+    const parameters = new Parameters(string, array);
+
+    return parameters;
+  }
+
   static fromArrayAssignmentNode(arrayAssignmentNode, context) {
     const arrayAssignmentParametersNode = arrayAssignmentParametersNodeQuery(arrayAssignmentNode),
           parametersNode = arrayAssignmentParametersNode,  ///

package/src/dom/procedure/anonymous.js

@@ -7,15 +7,15 @@ import { domAssigned } from "../../dom";
 import { nodeQuery, nodesQuery } from "../../utilities/query";
 import { variablesFromValuesAndParameters } from "../procedure";
 
-const nonsenseNodesQuery = nodesQuery("/forEachLoop/anonymousProcedure/block/nonsense"),
-      parametersNodeQuery = nodeQuery("/forEachLoop/anonymousProcedure/parameters");
+const nonsenseNodesQuery = nodesQuery("/some/anonymousProcedure/returnBlock/nonsense"),
+      parametersNodeQuery = nodeQuery("/some/anonymousProcedure/parameters");
 
 export default domAssigned(class AnonymousProcedure {
-  constructor(string, parameters, nonsensical, block) {
+  constructor(string, parameters, nonsensical, returnBlock) {
     this.string = string;
     this.parameters = parameters;
     this.nonsensical = nonsensical;
-    this.block = block;
+    this.returnBlock = returnBlock;
   }
 
   getString() {
@@ -30,11 +30,13 @@ export default domAssigned(class AnonymousProcedure {
     return this.nonsensical;
   }
 
-  getBlock() {
-    return this.block;
+  getReturnBlock() {
+    return this.returnBlock;
   }
 
   call(values, context) {
+    debugger
+
     const anonymousProcedureString = this.string; ///
 
     context.trace(`Calling the '${anonymousProcedureString}' anonymous procedure...`);
@@ -50,35 +52,35 @@ export default domAssigned(class AnonymousProcedure {
 
     const variables = variablesFromValuesAndParameters(values, this.parameters, context);
 
-    this.block.evaluate(variables, context);
+    this.returnBlock.evaluate(variables, context);
 
     context.debug(`...called the '${anonymousProcedureString}' anonymous procedure.`);
   }
 
   static name = "AnonymousProcedure";
 
-  static fromForEachLoopNode(forEachLoopNode, context) {
-    const { Block, Parameters } = dom,
-          string = stringFromForEachLoopNode(forEachLoopNode, context),
-          parameters = Parameters.fromForEachLoopNode(forEachLoopNode, context),
-          nonsensical = nonsensicalFromForEachLoopNode(forEachLoopNode, context),
-          block = Block.fromForEachLoopNode(forEachLoopNode, context),
-          anonymousProcedureDeclaration = new AnonymousProcedure(string, parameters, nonsensical, block);
+  static fromSomeNode(someNode, context) {
+    const { ReturnBlock, Parameters } = dom,
+          string = stringFromSomeNode(someNode, context),
+          parameters = Parameters.fromSomeNode(someNode, context),
+          nonsensical = nonsensicalFromSomeNode(someNode, context),
+          returnBlock = ReturnBlock.fromSomeNode(someNode, context),
+          anonymousProcedureDeclaration = new AnonymousProcedure(string, parameters, nonsensical, returnBlock);
 
     return anonymousProcedureDeclaration;
   }
 });
 
-function stringFromForEachLoopNode(forEachLoopNode, context) {
-  const parametersNode = parametersNodeQuery(forEachLoopNode),
+function stringFromSomeNode(someNode, context) {
+  const parametersNode = parametersNodeQuery(someNode),
         parametersString = context.nodeAsString(parametersNode),
         string = `(${parametersString}) { ... }`;
 
   return string;
 }
 
-function nonsensicalFromForEachLoopNode(forEachLoopNode, context) {
-  const nonsenseNodes = nonsenseNodesQuery(forEachLoopNode),
+function nonsensicalFromSomeNode(someNode, context) {
+  const nonsenseNodes = nonsenseNodesQuery(someNode),
         nonsenseNodesLength = nonsenseNodes.length,
         nonsensical = (nonsenseNodesLength > 0);
 

package/src/dom/{forEachLoop.js → some.js}

@@ -7,11 +7,11 @@ import { nodeQuery } from "../utilities/query";
 import { NODES_TYPE } from "../types";
 import { domAssigned } from "../dom";
 
-const variableNodeQuery = nodeQuery("/forEachLoop/variable"),
-      parametersNodeQuery = nodeQuery("/forEachLoop/anonymousProcedure/parameters"),
-      forEachLoopNodeQuery = nodeQuery("/step/forEachLoop");
+const variableNodeQuery = nodeQuery("/some/variable"),
+      valueSomeNodeQuery = nodeQuery("/value/some"),
+      parametersNodeQuery = nodeQuery("/some/anonymousProcedure/parameters");
 
-export default domAssigned(class ForEachLoop {
+export default domAssigned(class Some {
   constructor(string, variable, anonymousProcedure) {
     this.string = string;
     this.variable = variable;
@@ -31,9 +31,11 @@ export default domAssigned(class ForEachLoop {
   }
 
   evaluate(context) {
-    const forEachLoopString = this.getString();
+    debugger
 
-    context.trace(`Evaluating the '${forEachLoopString}' for-each loop...`);
+    const someString = this.getString();
+
+    context.trace(`Evaluating the '${someString}' some loop...`);
 
     const value = this.variable.evaluate(context),
           valueType = value.getType();
@@ -48,7 +50,7 @@ export default domAssigned(class ForEachLoop {
 
     const nodes = value.getNodes();
 
-    nodes.forEach((node) => {
+    nodes.some((node) => {
       const { Value, Values } = dom,
             value = Value.fromNode(node, context),
             values = Values.fromValue(value, context);
@@ -56,35 +58,36 @@ export default domAssigned(class ForEachLoop {
       this.anonymousProcedure.call(values, context);
     });
 
-    context.trace(`...evaluated the '${forEachLoopString}' for-each loop.`);
+    context.trace(`...evaluated the '${someString}' some loop.`);
   }
 
-  static name = "ForEachLoop";
+  static name = "Some";
 
-  static fromStepNode(stepNode, context) {
-    let forEachLoop = null;
+  static fromValueNode(valueNode, context) {
+    let some = null;
 
-    const forEachLoopNode = forEachLoopNodeQuery(stepNode);
+    const valueSomeNode = valueSomeNodeQuery(valueNode);
 
-    if (forEachLoopNode !== null) {
+    if (valueSomeNode !== null) {
       const { Variable, AnonymousProcedure } = dom,
-            string = stringFromForEachLoopNode(forEachLoopNode, context),
-            variable = Variable.fromForEachLoopNode(forEachLoopNode, context),
-            anonymousProcedure = AnonymousProcedure.fromForEachLoopNode(forEachLoopNode, context);
+            someNode = valueSomeNode, ///
+            string = stringFromSomeNode(someNode, context),
+            variable = Variable.fromSomeNode(someNode, context),
+            anonymousProcedure = AnonymousProcedure.fromSomeNode(someNode, context);
 
-      forEachLoop = new ForEachLoop(string, variable, anonymousProcedure);
+      some = new Some(string, variable, anonymousProcedure);
     }
 
-    return forEachLoop;
+    return some;
   }
 });
 
-function stringFromForEachLoopNode(forEachLoopNode, context) {
-  const variableNode = variableNodeQuery(forEachLoopNode),
-        parametersNode = parametersNodeQuery(forEachLoopNode),
+function stringFromSomeNode(someNode, context) {
+  const variableNode = variableNodeQuery(someNode),
+        parametersNode = parametersNodeQuery(someNode),
         variableString = context.nodeAsString(variableNode),
         parametersString = context.nodeAsString(parametersNode),
-        string = `ForEach(${variableString}, (${parametersString}) { ... })`;
+        string = `Some(${variableString}, (${parametersString}) { ... })`;
 
   return string;
 }

package/src/dom/step.js

@@ -5,9 +5,8 @@ import dom from "../dom";
 import { domAssigned } from "../dom";
 
 export default domAssigned(class Step {
-  constructor(string, forEachLoop, arrayAssignment, objectAssigment, conditionalBlocks, variableAssignment, variablesDeclaration) {
+  constructor(string, arrayAssignment, objectAssigment, conditionalBlocks, variableAssignment, variablesDeclaration) {
     this.string = string;
-    this.forEachLoop = forEachLoop;
     this.arrayAssignment = arrayAssignment;
     this.objectAssigment = objectAssigment;
     this.conditionalBlocks = conditionalBlocks;
@@ -19,10 +18,6 @@ export default domAssigned(class Step {
     return this.string;
   }
 
-  getForEachLoop() {
-    return this.forEachLoop;
-  }
-
   getArrayAssignment() {
     return this.arrayAssignment;
   }
@@ -47,8 +42,6 @@ export default domAssigned(class Step {
 
     if (false) {
       ///
-    } else if (this.forEachLoop !== null) {
-      this.forEachLoop.evaluate(context);
     } else if (this.arrayAssignment !== null) {
       this.arrayAssignment.evaluate(context);
     } else if (this.objectAssigment !== null) {
@@ -65,16 +58,15 @@ export default domAssigned(class Step {
   static name = "Step";
 
   static fromStepNode(stepNode, context) {
-    const { ForEachLoop, ArrayAssignment, ObjectAssigment, ConditionalBlocks, VariableAssignment, VariablesDeclaration } = dom,
+    const { ArrayAssignment, ObjectAssigment, ConditionalBlocks, VariableAssignment, VariablesDeclaration } = dom,
           node = stepNode,  ///
           string = context.nodeAsString(node),
-          forEachLoop = ForEachLoop.fromStepNode(stepNode, context),
           arrayAssignment = ArrayAssignment.fromStepNode(stepNode, context),
           objectAssigment = ObjectAssigment.fromStepNode(stepNode, context),
           conditionalBlocks = ConditionalBlocks.fromStepNode(stepNode, context),
           variableAssignment = VariableAssignment.fromStepNode(stepNode, context),
           variablesDeclaration = VariablesDeclaration.fromStepNode(stepNode, context),
-          step = new Step(string, forEachLoop, arrayAssignment, objectAssigment, conditionalBlocks, variableAssignment, variablesDeclaration);
+          step = new Step(string, arrayAssignment, objectAssigment, conditionalBlocks, variableAssignment, variablesDeclaration);
 
     return step;
   }

package/src/dom/value.js

@@ -20,16 +20,18 @@ const numberTerminalNodeQuery = nodeQuery("/value/@number"),
       stringLiteralTerminalNodeQuery = nodeQuery("/value/@string-literal");
 
 export default domAssigned(class Value {
-  constructor(node, nodes, number, string, boolean, ternary, variable, nodeQuery, nodesQuery, procedureCall) {
+  constructor(node, nodes, number, string, boolean, some, ternary, variable, nodeQuery, nodesQuery, comparison, procedureCall) {
     this.node = node;
     this.nodes = nodes;
     this.number = number;
     this.string = string;
     this.boolean = boolean;
+    this.some = some;
     this.ternary = ternary;
     this.variable = variable;
     this.nodeQuery = nodeQuery;
     this.nodesQuery = nodesQuery;
+    this.comparison = comparison;
     this.procedureCall = procedureCall;
   }
 
@@ -53,6 +55,10 @@ export default domAssigned(class Value {
     return this.boolean;
   }
 
+  getSome() {
+    return this.some;
+  }
+
   getTernary() {
     return this.ternay;
   }
@@ -69,6 +75,10 @@ export default domAssigned(class Value {
     return this.nodesQuery;
   }
 
+  getComparison() {
+    return this.comparison;
+  }
+
   getProcedureCall() {
     return this.procedureCall;
   }
@@ -88,6 +98,8 @@ export default domAssigned(class Value {
       type = STRING_TYPE;
     } else if (this.boolean !== null) {
       type = BOOLEAN_TYPE;
+    } else if (this.some !== null) {
+      type = this.some.getType();
     } else if (this.ternary !== null) {
       type = this.ternary.getType();
     } else if (this.variable !== null) {
@@ -96,6 +108,8 @@ export default domAssigned(class Value {
       type = this.nodeQuery.getType();
     } else if (this.nodesQuery !== null) {
       type = this.nodesQuery.getType();
+    } else if (this.comparison !== null) {
+      type = this.comparison.getType();
     } else if (this.procedureCall !== null) {
       type = this.procedureCall.getType();
     }
@@ -118,6 +132,8 @@ export default domAssigned(class Value {
       string = stringAsString(this.string, context)
     } else if (this.boolean !== null) {
       string = booleanAsString(this.boolean, context)
+    } else if (this.some !== null) {
+      string = this.some.asString(context);
     } else if (this.ternary !== null) {
       string = this.ternary.asString(context);
     } else if (this.variable !== null) {
@@ -126,6 +142,8 @@ export default domAssigned(class Value {
       string = this.nodeQuery.asString(context);
     } else if (this.nodesQuery !== null) {
       string = this.nodesQuery.asString(context);
+    } else if (this.comparison !== null) {
+      string = this.comparison.asString(context);
     } else if (this.procedureCall !== null) {
       string = this.procedureCall.asString(context);
     }
@@ -144,6 +162,8 @@ export default domAssigned(class Value {
                (this.string !== null) ||
                (this.boolean !== null)) {
       value = this;
+    } else if (this.some !== null) {
+      value = this.some.evaluate(context);
     } else if (this.ternary !== null) {
       value = this.ternary.evaluate(context);
     } else if (this.variable !== null) {
@@ -152,6 +172,8 @@ export default domAssigned(class Value {
       value = this.nodeQuery.evaluate(context);
     } else if (this.nodesQuery !== null) {
       value = this.nodesQuery.evaluate(context);
+    } else if (this.comparison !== null) {
+      value = this.comparison.evaluate(context);
     } else if (this.procedureCall !== null) {
       value = this.procedureCall.evaluate(context);
     }
@@ -218,12 +240,14 @@ export default domAssigned(class Value {
           number = null,
           string = null,
           boolean = null,
+          some = null,
           ternary = null,
           variable = null,
           nodeQuery = null,
           nodesQuery = null,
+          comparison = null,
           procedureCall = null,
-          value = new Value(node, nodes, number, string, boolean, ternary, variable, nodeQuery, nodesQuery, procedureCall);
+          value = new Value(node, nodes, number, string, boolean, some, ternary, variable, nodeQuery, nodesQuery, comparison, procedureCall);
 
     return value;
   }
@@ -234,11 +258,13 @@ export default domAssigned(class Value {
           string = null,
           boolean = null,
           ternary = null,
+          some = null,
           variable = null,
           nodeQuery = null,
           nodesQuery = null,
+          comparison = null,
           procedureCall = null,
-          value = new Value(node, nodes, number, string, boolean, ternary, variable, nodeQuery, nodesQuery, procedureCall);
+          value = new Value(node, nodes, number, string, boolean, some, ternary, variable, nodeQuery, nodesQuery, comparison, procedureCall);
 
     return value;
   }
@@ -248,12 +274,14 @@ export default domAssigned(class Value {
           nodes = null,
           number = null,
           boolean = null,
+          some = null,
           ternary = null,
           variable = null,
           nodeQuery = null,
           nodesQuery = null,
+          comparison = null,
           procedureCall = null,
-          value = new Value(node, nodes, number, string, boolean, ternary, variable, nodeQuery, nodesQuery, procedureCall);
+          value = new Value(node, nodes, number, string, boolean, some, ternary, variable, nodeQuery, nodesQuery, comparison, procedureCall);
 
     return value;
   }
@@ -263,12 +291,14 @@ export default domAssigned(class Value {
           nodes = null,
           number = null,
           string = null,
+          some = null,
           ternary = null,
           variable = null,
           nodeQuery = null,
           nodesQuery = null,
+          comparison = null,
           procedureCall = null,
-          value = new Value(node, nodes, number, string, boolean, ternary, variable, nodeQuery, nodesQuery, procedureCall);
+          value = new Value(node, nodes, number, string, boolean, some, ternary, variable, nodeQuery, nodesQuery, comparison, procedureCall);
 
     return value;
   }
@@ -395,7 +425,7 @@ function booleanAsString(boolean, context) {
 }
 
 function valueFromValueNode(valueNode, context) {
-  const { Value, Ternary, Variable, NodeQuery, NodesQuery, ProcedureCall } = dom,
+  const { Value, Ternary, Variable, NodeQuery, NodesQuery, Comparison, ProcedureCall } = dom,
         node = nodeFromValueNode(valueNode, context),
         nodes = nodesFromValueNode(valueNode, context),
         number = numberFromValueNode(valueNode, context),
@@ -405,8 +435,9 @@ function valueFromValueNode(valueNode, context) {
         variable = Variable.fromValueNode(valueNode, context),
         nodeQuery = NodeQuery.fromValueNode(valueNode, context),
         nodesQuery = NodesQuery.fromValueNode(valueNode, context),
+        comparison = Comparison.fromValueNode(valueNode, context),
         procedureCall = ProcedureCall.fromValueNode(valueNode, context),
-        value = new Value(node, nodes, number, string, boolean, ternary, variable, nodeQuery, nodesQuery, procedureCall);
+        value = new Value(node, nodes, number, string, boolean, ternary, variable, nodeQuery, nodesQuery, comparison, procedureCall);
 
   return value;
 }

package/src/dom/variable.js

@@ -6,10 +6,10 @@ import Exception from "../exception";
 import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 
-const valueVariableNodeQuery = nodeQuery("/value/variable"),
+const someVariableNodeQuery = nodeQuery("/some/variable"),
+      valueVariableNodeQuery = nodeQuery("/value/variable"),
       nodeQueryVariableNodeQuery = nodeQuery("/nodeQuery/variable"),
       nodesQueryVariableNodeQuery = nodeQuery("/nodesQuery/variable"),
-      forEachLoopVariableNodeQuery = nodeQuery("/forEachLoop/variable"),
       variableNameTerminalNodeQuery = nodeQuery("/variable/@name"),
       arrayAssignmentVariableNodeQuery = nodeQuery("/arrayAssignment/variable"),
       objectAssignmentVariableNodeQuery = nodeQuery("/objectAssignment/variable"),
@@ -133,6 +133,14 @@ export default domAssigned(class Variable {
 
   static name = "Variable";
 
+  static fromSomeNode(someLoopNode, context) {
+    const someVariableNode = someVariableNodeQuery(someLoopNode),
+          variableNode = someVariableNode, ///
+          variable = variableFromVariableNode(variableNode, context);
+
+    return variable;
+  }
+
   static fromValueNode(valueNode, context) {
     let variable = null;
 
@@ -163,14 +171,6 @@ export default domAssigned(class Variable {
     return variable;
   }
 
-  static fromForEachLoopNode(forEachLoopLoopNode, context) {
-    const forEachLoopVariableNode = forEachLoopVariableNodeQuery(forEachLoopLoopNode),
-          variableNode = forEachLoopVariableNode, ///
-          variable = variableFromVariableNode(variableNode, context);
-
-    return variable;
-  }
-
   static fromValueAndParameter(value, parameter, context) {
     const type = parameter.getType(),
           name = parameter.getName(),

package/src/index.js

@@ -1,6 +1,7 @@
 "use strict";
 
 import Step from "./dom/step";
+import Some from "./dom/some";
 import Label from "./dom/label";
 import Block from "./dom/block";
 import Error from "./dom/error";
@@ -18,7 +19,6 @@ import NodesQuery from "./dom/query/nodes";
 import Comparison from "./dom/comparison";
 import Assignment from "./dom/assignment";
 import ReturnBlock from "./dom/block/return";
-import ForEachLoop from "./dom/forEachLoop";
 import ProcedureCall from "./dom/procedureCall";
 import ArrayAssigment from "./dom/assignment/array";
 import ReturnStatement from "./dom/returnStatement";