occam-furtle 2.0.69 → 2.0.73

package/src/dom/parameters.js

@@ -7,9 +7,8 @@ import { domAssigned } from "../dom";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const parameterNodesQuery = nodesQuery("/parameters/parameter"),
-      someParametersNodeQuery = nodeQuery("/some/parameters"),
       arrayAssignmentParametersNodeQuery = nodeQuery("/arrayAssignment/parameters"),
-      objectAssignmentParametersNodeQuery = nodeQuery("/objectAssignment/parameters"),
+      anonymousProcedureParametersNodeQuery = nodeQuery("/anonymousProcedure/parameters"),
       procedureDeclarationParametersNodeQuery = nodeQuery("/procedureDeclaration/parameters");
 
 export default domAssigned(class Parameters {
@@ -38,8 +37,6 @@ export default domAssigned(class Parameters {
     return parameter;
   }
 
-  someParameter(callback) { return this.array.some(callback); }
-
   forEachParameter(callback) { this.array.forEach(callback); }
 
   matchValues(values, context) {
@@ -69,60 +66,8 @@ export default domAssigned(class Parameters {
     context.debug(`...matched the ${valuesString} values against the '${parametersString}' parameters.`);
   }
 
-  matchParameter(parameter, context) {
-    const parameterString = parameter.getString(),
-          parametersString = this.string; ///
-
-    context.trace(`Matching the '${parameterString}' parameter against the '${parametersString}' parameters...`);
-
-    const parameterA = parameter, ///
-          parameterMatches = this.someParameter((parameter) => {
-            if (parameter !== null) {
-              const parameterB = parameter, ///
-                    parameterBMatchesParameterA = parameterA.matchParameter(parameterB, context);
-
-              if (parameterBMatchesParameterA) {
-                return true;
-              }
-            }
-          });
-
-    if (!parameterMatches) {
-      const message = `The '${parameterString}' parameter does not match any of the '${parametersString}' parameters.`,
-            exception = Exception.fromMessage(message);
-
-      throw exception;
-    }
-
-    context.debug(`...matched the '${parameterString}' parameter against the '${parametersString}' parameters.`);
-  }
-
-  matchParameters(parameters, context) {
-    parameters.forEachParameter((parameter) => {
-      if (parameter !== null) {
-        this.matchParameter(parameter, context);
-      }
-    });
-  }
-
   static name = "Parameters";
 
-  static fromSomeNode(someNode, context) {
-    const { Parameter } = dom,
-          someParametersNode = someParametersNodeQuery(someNode),
-          parameterNode = someParametersNode, ///
-          parameterNodes = parameterNodesQuery(parameterNode),
-          array = parameterNodes.map((parameterNode) => {
-            const parameter = Parameter.fromParameterNode(parameterNode, context);
-
-            return parameter;
-          }),
-          string = stringFromArray(array, context),
-          parameters = new Parameters(string, array);
-
-    return parameters;
-  }
-
   static fromStringAndArray(string, array) {
     const parameters = new Parameters(string, array);
 
@@ -141,13 +86,17 @@ export default domAssigned(class Parameters {
     return parameters;
   }
 
-  static fromObjectAssignmentNode(objectAssignmentNode, context) {
-    const objectAssignmentParametersNode = objectAssignmentParametersNodeQuery(objectAssignmentNode),
-          parametersNode = objectAssignmentParametersNode,  ///
-          node = parametersNode,  ///
-          string = context.nodeAsString(node),
-          parameterNodes = parameterNodesQuery(parametersNode),
-          array = arrayFromParameterNodes(parameterNodes, context),
+  static fromAnonymousProcedureNode(anonymousProcedureNode, context) {
+    const { Parameter } = dom,
+          anonymousProcedureParametersNode = anonymousProcedureParametersNodeQuery(anonymousProcedureNode),
+          parameterNode = anonymousProcedureParametersNode, ///
+          parameterNodes = parameterNodesQuery(parameterNode),
+          array = parameterNodes.map((parameterNode) => {
+            const parameter = Parameter.fromParameterNode(parameterNode, context);
+
+            return parameter;
+          }),
+          string = stringFromArray(array, context),
           parameters = new Parameters(string, array);
 
     return parameters;

package/src/dom/procedure/anonymous.js

@@ -3,18 +3,19 @@
 import dom from "../../dom";
 import Exception from "../../exception";
 
+import { nodeQuery } from "../../utilities/query";
 import { domAssigned } from "../../dom";
-import { nodeQuery, nodesQuery } from "../../utilities/query";
 import { variablesFromValuesAndParameters } from "../procedure";
 
-const nonsenseNodesQuery = nodesQuery("/some/anonymousProcedure/returnBlock/nonsense"),
-      parametersNodeQuery = nodeQuery("/some/anonymousProcedure/parameters");
+const parametersNodeQuery = nodeQuery("/anonymousProcedure/parameters"),
+      typeTerminalNodeQuery = nodeQuery("/anonymousProcedure/@type"),
+      somAnonymousProcedureNodeQuery = nodeQuery("/some/anonymousProcedure");
 
 export default domAssigned(class AnonymousProcedure {
-  constructor(string, parameters, nonsensical, returnBlock) {
+  constructor(string, type, parameters, returnBlock) {
     this.string = string;
+    this.type - type;
     this.parameters = parameters;
-    this.nonsensical = nonsensical;
     this.returnBlock = returnBlock;
   }
 
@@ -22,12 +23,12 @@ export default domAssigned(class AnonymousProcedure {
     return this.string;
   }
 
-  getParameters() {
-    return this.paramters;
+  getType() {
+    return this.type;
   }
 
-  isNonsensical() {
-    return this.nonsensical;
+  getParameters() {
+    return this.paramters;
   }
 
   getReturnBlock() {
@@ -35,54 +36,67 @@ export default domAssigned(class AnonymousProcedure {
   }
 
   call(values, context) {
-    debugger
-
     const anonymousProcedureString = this.string; ///
 
     context.trace(`Calling the '${anonymousProcedureString}' anonymous procedure...`);
 
-    if (this.nonsensical) {
-      const message = `The '${anonymousProcedureString}' anonymous procedure is nonsensical.`,
-            exception = Exception.fromMessage(message);
-
-      throw exception;
-    }
-
     this.parameters.matchValues(values, context);
 
     const variables = variablesFromValuesAndParameters(values, this.parameters, context);
 
-    this.returnBlock.evaluate(variables, context);
+    const value = this.returnBlock.evaluate(variables, context),
+          valueType = value.getType();
+
+    if (this.type !== valueType) {
+      const valueString = value.asString(context),
+            message = `The ${valueString} value's '${valueType}' type and the '${anonymousProcedureString}' anonymous procedure's '${this.type}' type  do not match.`,
+            exception = Exception.fromMessage(message);
+
+      throw exception;
+    }
 
     context.debug(`...called the '${anonymousProcedureString}' anonymous procedure.`);
+
+    return value;
   }
 
   static name = "AnonymousProcedure";
 
   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;
+    const someAnonymousProcedureNode = somAnonymousProcedureNodeQuery(someNode),
+          anonymousProcedureNode = someAnonymousProcedureNode,  ///
+          anonymousProcedure = anonymousProcedureFromAnonymousProcedureNode(anonymousProcedureNode, context);
+
+    return anonymousProcedure;
   }
 });
 
-function stringFromSomeNode(someNode, context) {
-  const parametersNode = parametersNodeQuery(someNode),
-        parametersString = context.nodeAsString(parametersNode),
-        string = `(${parametersString}) { ... }`;
+function anonymousProcedureFromAnonymousProcedureNode(anonymousProcedureNode, context) {
+  const { Parameters, ReturnBlock, AnonymousProcedure } = dom,
+        string = stringFromAnonymousProcedureNode(anonymousProcedureNode, context),
+        type = typeFromProcedureAnonymousProcedureNode(anonymousProcedureNode, context),
+        parameters = Parameters.fromAnonymousProcedureNode(anonymousProcedureNode, context),
+        returnBlock = ReturnBlock.fromAnonymousProcedureNode(anonymousProcedureNode, context),
+        anonymousProcedure = new AnonymousProcedure(string, type, parameters, returnBlock);
 
-  return string;
+  return anonymousProcedure;
+}
+
+function typeFromProcedureAnonymousProcedureNode(anonymousProcedureNode, context) {
+  const typeTerminalNode = typeTerminalNodeQuery(anonymousProcedureNode),
+        typeTerminalNodeContent = typeTerminalNode.getContent(),
+        type = typeTerminalNodeContent; ///
+
+  return type;
 }
 
-function nonsensicalFromSomeNode(someNode, context) {
-  const nonsenseNodes = nonsenseNodesQuery(someNode),
-        nonsenseNodesLength = nonsenseNodes.length,
-        nonsensical = (nonsenseNodesLength > 0);
+function stringFromAnonymousProcedureNode(anonymousProcedureNode, context) {
+  const parametersNode = parametersNodeQuery(anonymousProcedureNode),
+        typeTerminalNode = typeTerminalNodeQuery(anonymousProcedureNode),
+        parametersString = context.nodeAsString(parametersNode),
+        typeNode = typeTerminalNode,  ///
+        typeString = context.nodeAsString(typeNode),
+        string = `${typeString} (${parametersString}) { ... }`;
 
-  return nonsensical;
+  return string;
 }

package/src/dom/procedure.js

@@ -3,22 +3,20 @@
 import dom from "../dom";
 import Exception from "../exception";
 
+import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 import { BOOLEAN_TYPE } from "../types";
-import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const labelNodeQuery = nodeQuery("/procedureDeclaration/label"),
-      nonsenseNodesQuery = nodesQuery("/procedureDeclaration/returnBlock/nonsense"),
       parametersNodeQuery = nodeQuery("/procedureDeclaration/parameters"),
       typeTerminalNodeQuery = nodeQuery("/procedureDeclaration/@type");
 
 export default domAssigned(class Procedure {
-  constructor(string, type, label, parameters, nonsensical, returnBlock) {
+  constructor(string, type, label, parameters, returnBlock) {
     this.string = string;
     this.type = type;
     this.label = label;
     this.parameters = parameters;
-    this.nonsensical = nonsensical;
     this.returnBlock = returnBlock;
   }
 
@@ -38,10 +36,6 @@ export default domAssigned(class Procedure {
     return this.parameters;
   }
 
-  isNonsensical() {
-    return this.nonsensical;
-  }
-
   getReturnBlock() {
     return this.returnBlock;
   }
@@ -64,13 +58,6 @@ export default domAssigned(class Procedure {
 
     context.trace(`Calling the '${procedureString}' procedure...`);
 
-    if (this.nonsensical) {
-      const message = `The '${procedureString}' procedure is nonsensical.`,
-            exception = Exception.fromMessage(message);
-
-      throw exception;
-    }
-
     this.parameters.matchValues(values, context);
 
     const variables = variablesFromValuesAndParameters(values, this.parameters, context),
@@ -100,9 +87,8 @@ export default domAssigned(class Procedure {
           type = typeFromProcedureDeclarationNode(procedureDeclarationNode, context),
           label = Label.fromProcedureDeclarationNode(procedureDeclarationNode, context),
           parameters = Parameters.fromProcedureDeclarationNode(procedureDeclarationNode, context),
-          nonsensical = nonsensicalFromProcedureDeclarationNode(procedureDeclarationNode, context),
           returnBlock = ReturnBlock.fromProcedureDeclarationNode(procedureDeclarationNode, context),
-          procedureDeclaration = new Procedure(string, type, label, parameters, nonsensical, returnBlock);
+          procedureDeclaration = new Procedure(string, type, label, parameters, returnBlock);
 
     return procedureDeclaration;
   }
@@ -145,11 +131,3 @@ function stringFromProcedureDeclarationNode(procedureDeclarationNode, context) {
 
   return string;
 }
-
-function nonsensicalFromProcedureDeclarationNode(procedureDeclarationNode, context) {
-  const nonsenseNodes = nonsenseNodesQuery(procedureDeclarationNode),
-        nonsenseNodesLength = nonsenseNodes.length,
-        nonsensical = (nonsenseNodesLength > 0);
-
-  return nonsensical;
-}

package/src/dom/returnStatement.js

@@ -5,7 +5,7 @@ import dom from "../dom";
 import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 
-const returnStatementNodeQuery = nodeQuery("/procedureDeclaration/returnBlock/returnStatement");
+const returnStatementNodeQuery = nodeQuery("/returnBlock/returnStatement");
 
 export default domAssigned(class ReturnStatement {
   constructor(string, value) {
@@ -37,19 +37,13 @@ export default domAssigned(class ReturnStatement {
 
   static name = "ReturnStatement";
 
-  static fromProcedureDeclarationNode(procedureDeclarationNode, context) {
-    let returnStatement = null;
-
-    const returnStatementNode = returnStatementNodeQuery(procedureDeclarationNode);
-
-    if (returnStatementNode !== null) {
-      const { Value } = dom,
-            node = returnStatementNode, ///
-            string = context.nodeAsString(node),
-            value = Value.fromReturnStatementNode(returnStatementNode, context);
-
-      returnStatement = new ReturnStatement(string, value);
-    }
+  static fromReturnBlockNode(returnBlockNode, context) {
+    const { Value } = dom,
+          returnStatementNode = returnStatementNodeQuery(returnBlockNode),
+          node = returnStatementNode, ///
+          string = context.nodeAsString(node),
+          value = Value.fromReturnStatementNode(returnStatementNode, context),
+          returnStatement = new ReturnStatement(string, value);
 
     return returnStatement;
   }

package/src/dom/some.js

@@ -4,8 +4,8 @@ import dom from "../dom";
 import Exception from "../exception";
 
 import { nodeQuery } from "../utilities/query";
-import { NODES_TYPE } from "../types";
 import { domAssigned } from "../dom";
+import { NODES_TYPE, BOOLEAN_TYPE } from "../types";
 
 const variableNodeQuery = nodeQuery("/some/variable"),
       valueSomeNodeQuery = nodeQuery("/value/some"),
@@ -31,11 +31,9 @@ export default domAssigned(class Some {
   }
 
   evaluate(context) {
-    debugger
-
     const someString = this.getString();
 
-    context.trace(`Evaluating the '${someString}' some loop...`);
+    context.trace(`Evaluating the '${someString}' some...`);
 
     const value = this.variable.evaluate(context),
           valueType = value.getType();
@@ -51,14 +49,32 @@ export default domAssigned(class Some {
     const nodes = value.getNodes();
 
     nodes.some((node) => {
-      const { Value, Values } = dom,
-            value = Value.fromNode(node, context),
-            values = Values.fromValue(value, context);
+      let value;
+
+      const { Value, Values } = dom;
+
+      value = Value.fromNode(node, context);
+
+      const values = Values.fromValue(value, context);
+
+      value = this.anonymousProcedure.call(values, context);
+
+      const valueType = value.getType();
+
+      if (valueType !== BOOLEAN_TYPE) {
+        const valueString = value.asString(context),
+              message = `The ${valueString} value's type is '${valueType}' when it should be of type '${BOOLEAN_TYPE}'.`,
+              exception = Exception.fromMessage(message);
+
+        throw exception;
+      }
+
+      const boolean = value.getBoolean();
 
-      this.anonymousProcedure.call(values, context);
+      return boolean;
     });
 
-    context.trace(`...evaluated the '${someString}' some loop.`);
+    context.trace(`...evaluated the '${someString}' some.`);
   }
 
   static name = "Some";

package/src/dom/step.js

@@ -5,12 +5,11 @@ import dom from "../dom";
 import { domAssigned } from "../dom";
 
 export default domAssigned(class Step {
-  constructor(string, arrayAssignment, objectAssigment, conditionalBlocks, variableAssignment, variablesDeclaration) {
+  constructor(string, arrayAssignment, objectAssigment, conditionalBlocks, variablesDeclaration) {
     this.string = string;
     this.arrayAssignment = arrayAssignment;
     this.objectAssigment = objectAssigment;
     this.conditionalBlocks = conditionalBlocks;
-    this.variableAssignment = variableAssignment;
     this.variablesDeclaration = variablesDeclaration;
   }
 
@@ -30,16 +29,11 @@ export default domAssigned(class Step {
     return this.conditionalBlocks;
   }
 
-  getVariableAssignment() {
-    return this.variableAssignment;
-  }
-
   getVariablesDeclaration() {
     return this.variablesDeclaration;
   }
 
   evaluate(context) {
-
     if (false) {
       ///
     } else if (this.arrayAssignment !== null) {
@@ -48,8 +42,6 @@ export default domAssigned(class Step {
       this.objectAssigment.evaluate(context);
     } else if (this.conditionalBlocks !== null) {
       this.conditionalBlocks.evaluate(context);
-    } else if (this.variableAssignment !== null) {
-      this.variableAssignment.evaluate(context);
     } else if (this.variablesDeclaration !== null) {
       this.variablesDeclaration.evaluate(context);
     }
@@ -58,15 +50,14 @@ export default domAssigned(class Step {
   static name = "Step";
 
   static fromStepNode(stepNode, context) {
-    const { ArrayAssignment, ObjectAssigment, ConditionalBlocks, VariableAssignment, VariablesDeclaration } = dom,
+    const { ArrayAssignment, ObjectAssigment, ConditionalBlocks, VariablesDeclaration } = dom,
           node = stepNode,  ///
           string = context.nodeAsString(node),
           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, arrayAssignment, objectAssigment, conditionalBlocks, variableAssignment, variablesDeclaration);
+          step = new Step(string, arrayAssignment, objectAssigment, conditionalBlocks, variablesDeclaration);
 
     return step;
   }

package/src/dom/value.js

@@ -19,7 +19,7 @@ const ternaryValueNodeQuery = nodeQuery("/ternary/value"),
       primitiveTerminalNodeQuery = nodeQuery("/value/@primitive"),
       returnStatementValueNodeQuery = nodeQuery("/returnStatement/value"),
       stringLiteralTerminalNodeQuery = nodeQuery("/value/@string-literal"),
-      conditionalBlocksCValueNodeQuery = nodeQuery("/conditionalBlocks/vvalue");
+      conditionalBlocksCValueNodeQuery = nodeQuery("/conditionalBlocks/value");
 
 export default domAssigned(class Value {
   constructor(node, nodes, number, string, boolean, some, ternary, variable, nodeQuery, nodesQuery, comparison, negatedValue, bitwiseValue, bracketedValue, procedureCall) {

package/src/dom/variable.js

@@ -12,8 +12,7 @@ const someVariableNodeQuery = nodeQuery("/some/variable"),
       nodesQueryVariableNodeQuery = nodeQuery("/nodesQuery/variable"),
       variableNameTerminalNodeQuery = nodeQuery("/variable/@name"),
       arrayAssignmentVariableNodeQuery = nodeQuery("/arrayAssignment/variable"),
-      objectAssignmentVariableNodeQuery = nodeQuery("/objectAssignment/variable"),
-      variableAssignmentVariableNodeQuery = nodeQuery("/variableAssignment/variable");
+      objectAssignmentVariableNodeQuery = nodeQuery("/objectAssignment/variable");
 
 export default domAssigned(class Variable {
   constructor(string, type, name, value, assignment) {
@@ -218,16 +217,14 @@ export default domAssigned(class Variable {
     return variable;
   }
 
-  static fromVariableAssignmentNode(variableAssignmentNode, context) {
-    const { Assignment } = dom,
-          variableAssignmentVariableNode = variableAssignmentVariableNodeQuery(variableAssignmentNode),
-          variableNode = variableAssignmentVariableNode, ///
-          node = variableNode,  ///
-          string = context.nodeAsString(node),
-          type = null,
-          name = nameFromVariableNode(variableNode),
+  static fromNamedParameterAndAssignment(namedParameter, assignment, context) {
+    const asName = namedParameter.getAsName(),
+          name = (asName !== null) ?
+                   asName : ///
+                    namedParameter.getName(),
+          type = namedParameter.getType(),
           value = null,
-          assignment = Assignment.fromVariableAssignmentNode(variableAssignmentNode, context),
+          string = name,  ///
           variable = new Variable(string, type, name, value, assignment);
 
     return variable;

package/src/index.js

@@ -21,13 +21,14 @@ import ReturnBlock from "./dom/block/return";
 import NegatedValue from "./dom/value/negated";
 import BitwiseValue from "./dom/value/bitwise";
 import ProcedureCall from "./dom/procedureCall";
+import NamedParameter from "./dom/parameter/named";
 import BracketedValue from "./dom/value/bracketed";
 import ArrayAssigment from "./dom/assignment/array";
 import ReturnStatement from "./dom/returnStatement";
+import NamedParameters from "./dom/parameters/named";
 import ObjectAssignment from "./dom/assignment/object";
 import ConditionalBlocks from "./dom/conditionalBlocks";
 import AnonymousProcedure from "./dom/procedure/anonymous";
-import VariableAssignment from "./dom/assignment/variable";
 import ProcedureDeclaration from "./dom/declaration/procedure";
 import VariablesDeclaration from "./dom/declaration/variables";
 

package/src/nodeProperties.js

@@ -0,0 +1,84 @@
+"use strict";
+
+import Exception from "./exception";
+import NodeProperty from "./nodeProperty";
+
+import { stringFromArray } from "./dom/parameters";
+import { NODES_TYPE, STRING_TYPE, BOOLEAN_TYPE } from "./types";
+import { CONTENT_PARAMETER_NAME, TERMINAL_PARAMETER_NAME, CHILD_NODES_PARAMETER_NAME } from "./parameterNames";
+
+const types = [
+        STRING_TYPE,
+        BOOLEAN_TYPE,
+        NODES_TYPE,
+      ],
+      names = [
+        CONTENT_PARAMETER_NAME,
+        TERMINAL_PARAMETER_NAME,
+        CHILD_NODES_PARAMETER_NAME
+      ];
+
+class NodeProperties {
+  constructor(string, array) {
+    this.string = string;
+    this.array = array;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getArray() {
+    return this.array;
+  }
+
+  someNodeProperty(callback) { return this.array.some(callback); }
+
+  matchNamedParameter(namedParameter, context) {
+    const nodePropertiesString = this.string, ///
+          namedParameterString = namedParameter.getString();
+
+    context.trace(`Matching the '${namedParameterString}' named parameter against the '${nodePropertiesString}' node properties...`);
+
+    const namedParameterMatches = this.someNodeProperty((nodeProperty) => {
+      const namedParameterMatchesNodeProperty = nodeProperty.matchNamedParameter(namedParameter, context);
+
+      if (namedParameterMatchesNodeProperty) {
+        return true;
+      }
+    });
+
+    if (!namedParameterMatches) {
+      const message = `The '${namedParameterString}' named parameter does not match any of the '${nodePropertiesString}' node properties.`,
+            exception = Exception.fromMessage(message);
+
+      throw exception;
+    }
+
+    context.debug(`...matched the '${namedParameterString}' named parameter against the '${nodePropertiesString}' node properties.`);
+  }
+
+  matchNamedParameters(namedParameters, context) {
+    namedParameters.forEachNamedParameter((namedParameter) => {
+      this.matchNamedParameter(namedParameter, context);
+    });
+  }
+
+  static fromNothing() {
+    const context = null,
+          array = names.map((name, index) => {
+            const type = types[index],
+                  nodeProperty = NodeProperty.fromNameAndType(name, type, context);
+
+            return nodeProperty;
+          }),
+          string = stringFromArray(array, context),
+          nodeProperties = new NodeProperties(string, array);
+
+    return nodeProperties;
+  }
+}
+
+const nodeProperties = NodeProperties.fromNothing();
+
+export default nodeProperties;

package/src/nodeProperty.js

@@ -0,0 +1,56 @@
+"use strict";
+
+export default class NodeProperty {
+  constructor(string, type, name) {
+    this.string = string;
+    this.type = type;
+    this.name = name;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getType() {
+    return this.type;
+  }
+
+  getName() {
+    return this.name;
+  }
+
+  matchNamedParameter(namedParameter, context) {
+    let namedParameterMatches;
+
+    const nodePropertyString = this.string, ///
+          namedParameterString = namedParameter.getString();
+
+    context.trace(`Matching the '${nodePropertyString}' node property against the '${namedParameterString}' named parameter...`);
+
+    const name = namedParameter.getName(),
+          type = namedParameter.getType();
+
+    namedParameterMatches = ((this.name === name) && (this.type === type));
+
+    if (namedParameterMatches) {
+      context.debug(`...matched the '${nodePropertyString}' node property against the '${namedParameterString}' named parameter.`);
+    }
+
+    return namedParameterMatches;
+  }
+
+  static name = "Parameter";
+
+  static fromNameAndType(name, type, context) {
+    const string = stringFromNameAndType(name, type, context),
+          nodeProperty = new NodeProperty(string, type, name);
+
+    return nodeProperty;
+  }
+};
+
+function stringFromNameAndType(name, type) {
+  const string = `${type} ${name}`;
+
+  return string;
+}