occam-verify-cli 1.0.383 → 1.0.386

package/lib/ontology/premise.js

@@ -0,0 +1,271 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _ontology = /*#__PURE__*/ _interop_require_wildcard(require("../ontology"));
+var _assignments = require("../utilities/assignments");
+var _context = require("../utilities/context");
+var _json = require("../utilities/json");
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+var _Premise;
+var _default = (0, _ontology.define)((_Premise = /*#__PURE__*/ function() {
+    function Premise(node, string, statement, procedureCall) {
+        _class_call_check(this, Premise);
+        this.node = node;
+        this.string = string;
+        this.statement = statement;
+        this.procedureCall = procedureCall;
+    }
+    _create_class(Premise, [
+        {
+            key: "getNode",
+            value: function getNode() {
+                return this.node;
+            }
+        },
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getStatement",
+            value: function getStatement() {
+                return this.statement;
+            }
+        },
+        {
+            key: "getProcedureCall",
+            value: function getProcedureCall() {
+                return this.procedureCall;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(context) {
+                var verifies = false;
+                var premiseString = this.string; ///
+                context.trace("Verifying the '".concat(premiseString, "' premise..."), this.node);
+                if (false) {
+                ///
+                } else if (this.statement !== null) {
+                    var stated = true, assignments = [], statementVerifies = this.statement.verify(assignments, stated, context);
+                    if (statementVerifies) {
+                        var assignmentsAssigned = (0, _assignments.assignAssignments)(assignments, context);
+                        if (assignmentsAssigned) {
+                            var Step = _ontology.default.Step, step = Step.fromStatement(this.statement, context), stepOrSubproof = step; ///
+                            context.addStepOrSubproof(stepOrSubproof);
+                            verifies = true;
+                        }
+                    }
+                } else if (this.procedureCall !== null) {
+                    var stated1 = true, assignments1 = null, procedureCallVerifies = this.procedureCall.verify(assignments1, stated1, context);
+                    if (procedureCallVerifies) {
+                        verifies = true;
+                    }
+                } else {
+                    context.debug("Unable to verify the '".concat(premiseString, "' premise because it is nonsense."), this.node);
+                }
+                if (verifies) {
+                    context.debug("...verified the '".concat(premiseString, "' premise."), this.node);
+                }
+                return verifies;
+            }
+        },
+        {
+            key: "unifyIndependently",
+            value: function unifyIndependently(substitutions, context) {
+                var unifiesIndependently;
+                if (this.statement !== null) {
+                    var statementResolvedIndependently = this.statement.unifyIndependently(substitutions, context);
+                    unifiesIndependently = statementResolvedIndependently; ///
+                }
+                if (this.procedureCall !== null) {
+                    var procedureCallResolvedIndependently = this.procedureCall.unifyIndependently(substitutions, context);
+                    unifiesIndependently = procedureCallResolvedIndependently; ///
+                }
+                return unifiesIndependently;
+            }
+        },
+        {
+            key: "unifyStepOrSubproof",
+            value: function unifyStepOrSubproof(stepOrSubproof, substitutions, generalContext, specificContext) {
+                var stepOrSubproofUnifies = false;
+                var stepOrSubProofStep = stepOrSubproof.isStep(), subproof = stepOrSubProofStep ? null : stepOrSubproof, step = stepOrSubProofStep ? stepOrSubproof : null;
+                substitutions.snapshot();
+                if (subproof !== null) {
+                    var subproofUnifies = this.unifySubproof(subproof, substitutions, generalContext, specificContext);
+                    stepOrSubproofUnifies = subproofUnifies; ///
+                }
+                if (step !== null) {
+                    var statementUnifies = this.unifyStep(step, substitutions, generalContext, specificContext);
+                    stepOrSubproofUnifies = statementUnifies; ///
+                }
+                if (stepOrSubproofUnifies) {
+                    substitutions.resolve(generalContext, specificContext);
+                }
+                stepOrSubproofUnifies ? substitutions.continue() : substitutions.rollback(specificContext);
+                return stepOrSubproofUnifies;
+            }
+        },
+        {
+            key: "unifyStep",
+            value: function unifyStep(step, substitutions, generalContext, specificContext) {
+                var stepUnifies = false;
+                var statement = step.getStatement(), statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
+                if (statementUnifies) {
+                    stepUnifies = true;
+                }
+                return stepUnifies;
+            }
+        },
+        {
+            key: "unifySubproof",
+            value: function unifySubproof(subproof, substitutions, generalContext, specificContext) {
+                var subproofUnifies = false;
+                var premise = this, subproofString = subproof.getString(), premiseStatement = premise.getStatement(), premiseStatementString = premiseStatement.getString();
+                specificContext.trace("Unifying the '".concat(subproofString, "' subproof with the premise's '").concat(premiseStatementString, "' statement..."));
+                if (this.statement !== null) {
+                    var context = generalContext, subproofAssertion = (0, _context.subproofAssertionFromStatement)(this.statement, context);
+                    if (subproofAssertion !== null) {
+                        subproofUnifies = subproofAssertion.unifySubproof(subproof, substitutions, generalContext, specificContext);
+                    }
+                }
+                if (subproofUnifies) {
+                    specificContext.debug("...unified the '".concat(subproofString, "' subproof with the premise's '").concat(premiseStatementString, "' statement."));
+                }
+                return subproofUnifies;
+            }
+        },
+        {
+            key: "unifyStatement",
+            value: function unifyStatement(statement, substitutions, generalContext, specificContext) {
+                var statementUnifies;
+                var premise = this, premiseString = premise.getString(), statementString = statement.getString();
+                specificContext.trace("Unifying the '".concat(statementString, "' statement with the '").concat(premiseString, "' premise..."));
+                if (this.statement !== null) {
+                    statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
+                }
+                if (statementUnifies) {
+                    specificContext.debug("...unified the '".concat(statementString, "' statement with the '").concat(premiseString, "' premise."));
+                }
+                return statementUnifies;
+            }
+        },
+        {
+            key: "toJSON",
+            value: function toJSON() {
+                var statementJSON = (0, _json.statementToStatementJSON)(this.statement), procedureCallJSON = (0, _json.procedureCallToProcedureCallJSON)(this.procedureCall), statement = statementJSON, procedureCall = procedureCallJSON, json = {
+                    statement: statement,
+                    procedureCall: procedureCall
+                };
+                return json;
+            }
+        }
+    ], [
+        {
+            key: "fromJSON",
+            value: function fromJSON(json, context) {
+                var statement = (0, _json.statementFromJSON)(json, context), procedureCall = (0, _json.procedureCallFromJSON)(json, context);
+                var string;
+                if (statement !== null) {
+                    string = statement.getString();
+                }
+                if (procedureCall !== null) {
+                    string = procedureCall.getString();
+                }
+                var node = null, premise = new Premise(node, string, statement, procedureCall);
+                return premise;
+            }
+        },
+        {
+            key: "fromPremiseNode",
+            value: function fromPremiseNode(premiseNode, context) {
+                var Statement = _ontology.default.Statement, ProcedureCall = _ontology.default.ProcedureCall, node = premiseNode, string = context.nodeAsString(node), statement = Statement.fromPremiseNode(premiseNode, context), procedureCall = ProcedureCall.fromPremiseNode(premiseNode, context), premise = new Premise(node, string, statement, procedureCall);
+                return premise;
+            }
+        }
+    ]);
+    return Premise;
+}(), _define_property(_Premise, "name", "Premise"), _Premise));
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/ontology/premise.js"],"sourcesContent":["\"use strict\";\n\nimport ontology from \"../ontology\";\n\nimport { define } from \"../ontology\";\nimport { assignAssignments } from \"../utilities/assignments\";\nimport { subproofAssertionFromStatement } from \"../utilities/context\";\nimport { statementFromJSON, procedureCallFromJSON, statementToStatementJSON, procedureCallToProcedureCallJSON } from \"../utilities/json\";\n\nexport default define(class Premise {\n  constructor(node, string, statement, procedureCall) {\n    this.node = node;\n    this.string = string;\n    this.statement = statement;\n    this.procedureCall = procedureCall;\n  }\n\n  getNode() {\n    return this.node;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getStatement() {\n    return this.statement;\n  }\n\n  getProcedureCall() {\n    return this.procedureCall;\n  }\n\n  verify(context) {\n    let verifies = false;\n\n    const premiseString = this.string; ///\n\n    context.trace(`Verifying the '${premiseString}' premise...`, this.node);\n\n    if (false) {\n      ///\n    } else if (this.statement !== null) {\n      const stated = true,\n            assignments = [],\n            statementVerifies = this.statement.verify(assignments, stated, context);\n\n      if (statementVerifies) {\n        const assignmentsAssigned = assignAssignments(assignments, context);\n\n        if (assignmentsAssigned) {\n          const { Step } = ontology,\n                step = Step.fromStatement(this.statement, context),\n                stepOrSubproof = step;  ///\n\n          context.addStepOrSubproof(stepOrSubproof);\n\n          verifies = true;\n        }\n      }\n    } else if (this.procedureCall !== null) {\n      const stated = true,\n            assignments = null,\n            procedureCallVerifies = this.procedureCall.verify(assignments, stated, context);\n\n      if (procedureCallVerifies) {\n        verifies = true;\n      }\n    } else {\n      context.debug(`Unable to verify the '${premiseString}' premise because it is nonsense.`, this.node);\n    }\n\n    if (verifies) {\n      context.debug(`...verified the '${premiseString}' premise.`, this.node);\n    }\n\n    return verifies;\n  }\n\n  unifyIndependently(substitutions, context) {\n    let unifiesIndependently;\n\n    if (this.statement !== null) {\n      const statementResolvedIndependently = this.statement.unifyIndependently(substitutions, context);\n\n      unifiesIndependently = statementResolvedIndependently;  ///\n    }\n\n    if (this.procedureCall !== null) {\n      const procedureCallResolvedIndependently = this.procedureCall.unifyIndependently(substitutions, context);\n\n      unifiesIndependently = procedureCallResolvedIndependently;  ///\n    }\n\n    return unifiesIndependently;\n  }\n\n  unifyStepOrSubproof(stepOrSubproof, substitutions, generalContext, specificContext) {\n    let stepOrSubproofUnifies = false;\n\n    const stepOrSubProofStep = stepOrSubproof.isStep(),\n          subproof = stepOrSubProofStep ?\n                       null :\n                         stepOrSubproof,\n          step = stepOrSubProofStep ?\n                        stepOrSubproof :\n                          null;\n\n    substitutions.snapshot();\n\n    if (subproof !== null) {\n      const subproofUnifies = this.unifySubproof(subproof, substitutions, generalContext, specificContext);\n\n      stepOrSubproofUnifies = subproofUnifies; ///\n    }\n\n    if (step !== null) {\n      const statementUnifies = this.unifyStep(step, substitutions, generalContext, specificContext);\n\n      stepOrSubproofUnifies = statementUnifies;  ///\n    }\n\n    if (stepOrSubproofUnifies) {\n      substitutions.resolve(generalContext, specificContext);\n    }\n\n    stepOrSubproofUnifies ?\n      substitutions.continue() :\n        substitutions.rollback(specificContext);\n\n    return stepOrSubproofUnifies;\n  }\n\n  unifyStep(step, substitutions, generalContext, specificContext) {\n    let stepUnifies = false;\n\n    const statement = step.getStatement(),\n          statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);\n\n    if (statementUnifies) {\n      stepUnifies = true;\n    }\n\n    return stepUnifies;\n  }\n\n  unifySubproof(subproof, substitutions, generalContext, specificContext) {\n    let subproofUnifies = false;\n\n    const premise = this, ///\n          subproofString = subproof.getString(),\n          premiseStatement = premise.getStatement(),\n          premiseStatementString = premiseStatement.getString();\n\n    specificContext.trace(`Unifying the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement...`);\n\n    if (this.statement !== null) {\n      const context = generalContext,\n            subproofAssertion = subproofAssertionFromStatement(this.statement, context);\n\n      if (subproofAssertion !== null) {\n        subproofUnifies = subproofAssertion.unifySubproof(subproof, substitutions, generalContext, specificContext);\n      }\n    }\n\n    if (subproofUnifies) {\n      specificContext.debug(`...unified the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement.`);\n    }\n\n    return subproofUnifies;\n  }\n\n  unifyStatement(statement, substitutions, generalContext, specificContext) {\n    let statementUnifies;\n\n    const premise = this, ///\n          premiseString = premise.getString(),\n          statementString = statement.getString();\n\n    specificContext.trace(`Unifying the '${statementString}' statement with the '${premiseString}' premise...`);\n\n    if (this.statement !== null) {\n      statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);\n    }\n\n    if (statementUnifies) {\n      specificContext.debug(`...unified the '${statementString}' statement with the '${premiseString}' premise.`);\n    }\n\n    return statementUnifies;\n  }\n\n  toJSON() {\n    const statementJSON = statementToStatementJSON(this.statement),\n          procedureCallJSON = procedureCallToProcedureCallJSON(this.procedureCall),\n          statement = statementJSON,  ///\n          procedureCall = procedureCallJSON,  ///\n          json = {\n            statement,\n            procedureCall\n          };\n\n    return json;\n  }\n\n  static name = \"Premise\";\n\n  static fromJSON(json, context) {\n    const statement = statementFromJSON(json, context),\n          procedureCall = procedureCallFromJSON(json, context);\n\n    let string;\n\n    if (statement !== null) {\n      string = statement.getString();\n    }\n\n    if (procedureCall !== null) {\n      string = procedureCall.getString();\n    }\n\n    const node = null,\n          premise = new Premise(node, string, statement, procedureCall);\n\n    return premise;\n  }\n\n  static fromPremiseNode(premiseNode, context) {\n    const { Statement, ProcedureCall } = ontology,\n          node = premiseNode, ///\n          string = context.nodeAsString(node),\n          statement = Statement.fromPremiseNode(premiseNode, context),\n          procedureCall = ProcedureCall.fromPremiseNode(premiseNode, context),\n          premise = new Premise(node, string, statement, procedureCall);\n\n    return premise\n  }\n});\n"],"names":["define","Premise","node","string","statement","procedureCall","getNode","getString","getStatement","getProcedureCall","verify","context","verifies","premiseString","trace","stated","assignments","statementVerifies","assignmentsAssigned","assignAssignments","Step","ontology","step","fromStatement","stepOrSubproof","addStepOrSubproof","procedureCallVerifies","debug","unifyIndependently","substitutions","unifiesIndependently","statementResolvedIndependently","procedureCallResolvedIndependently","unifyStepOrSubproof","generalContext","specificContext","stepOrSubproofUnifies","stepOrSubProofStep","isStep","subproof","snapshot","subproofUnifies","unifySubproof","statementUnifies","unifyStep","resolve","continue","rollback","stepUnifies","unifyStatement","premise","subproofString","premiseStatement","premiseStatementString","subproofAssertion","subproofAssertionFromStatement","statementString","toJSON","statementJSON","statementToStatementJSON","procedureCallJSON","procedureCallToProcedureCallJSON","json","fromJSON","statementFromJSON","procedureCallFromJSON","fromPremiseNode","premiseNode","Statement","ProcedureCall","nodeAsString","name"],"mappings":"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"}

package/lib/ontology/procedureCall.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+var _occamfurtle = require("occam-furtle");
+var _ontology = /*#__PURE__*/ _interop_require_wildcard(require("../ontology"));
+var _json = require("../utilities/json");
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+var _ProcedureCall;
+var _default = (0, _ontology.define)((_ProcedureCall = /*#__PURE__*/ function() {
+    function ProcedureCall(node, string, procedureReference, parameters) {
+        _class_call_check(this, ProcedureCall);
+        this.node = node;
+        this.string = string;
+        this.procedureReference = procedureReference;
+        this.parameters = parameters;
+    }
+    _create_class(ProcedureCall, [
+        {
+            key: "getNode",
+            value: function getNode() {
+                return this.node;
+            }
+        },
+        {
+            key: "getString",
+            value: function getString() {
+                return this.string;
+            }
+        },
+        {
+            key: "getProcedureReference",
+            value: function getProcedureReference() {
+                return this.procedureReference;
+            }
+        },
+        {
+            key: "getParameters",
+            value: function getParameters() {
+                return this.parameters;
+            }
+        },
+        {
+            key: "getName",
+            value: function getName() {
+                return this.procedureReference.getName();
+            }
+        },
+        {
+            key: "findNodes",
+            value: function findNodes(substitutions) {
+                var nodes = this.parameters.map(function(parameter) {
+                    var replacementNode = parameter.findReplacementNode(substitutions), node = replacementNode; ///
+                    return node;
+                });
+                return nodes;
+            }
+        },
+        {
+            key: "verify",
+            value: function verify(assignments, stated, context) {
+                var verifies = false;
+                var procedureCallString = this.string; ///
+                context.trace("Verifying the '".concat(procedureCallString, "' procedure call..."), this.node);
+                var name = this.getName(), procedure = context.findProcedureByName(name);
+                if (procedure !== null) {
+                    var procedureBoolean = procedure.isBoolean();
+                    if (procedureBoolean) {
+                        verifies = true;
+                    } else {
+                        context.trace("The '".concat(procedureCallString, "' procedure is not boolean."), this.node);
+                    }
+                } else {
+                    context.trace("The '".concat(procedureCallString, "' procedure is not present."), this.node);
+                }
+                if (verifies) {
+                    context.debug("...verified the '".concat(procedureCallString, "' procedure call."), this.node);
+                }
+                return verifies;
+            }
+        },
+        {
+            key: "unifyIndependently",
+            value: function unifyIndependently(substitutions, context) {
+                var unifiesIndependently = false;
+                var procedureCallString = this.string; ///
+                context.trace("Unifying the '".concat(procedureCallString, "' procedure call independently..."));
+                var name = this.getName(), nodes = this.findNodes(substitutions), procedure = context.findProcedureByName(name), expressions = _occamfurtle.Expressions.fromNodes(nodes, context);
+                try {
+                    var value = procedure.call(expressions, context), boolean = value.getBoolean();
+                    unifiesIndependently = boolean; ///
+                } catch (exception) {
+                    var message = exception.getMessage();
+                    context.info(message);
+                }
+                if (unifiesIndependently) {
+                    context.debug("...unified the '".concat(procedureCallString, "' procedure call independently."));
+                }
+                return unifiesIndependently;
+            }
+        },
+        {
+            key: "toJSON",
+            value: function toJSON() {
+                var parametersJSON = (0, _json.parametersToParametersJSON)(this.parameters), procedureReference = (0, _json.procedureReferenceToProcedureReferenceJSON)(this.procedureReference), parameters = parametersJSON, json = {
+                    procedureReference: procedureReference,
+                    parameters: parameters
+                };
+                return json;
+            }
+        }
+    ], [
+        {
+            key: "fromJSON",
+            value: function fromJSON(json, context) {
+                var procedureReference = (0, _json.procedureReferenceFromJSON)(json, context), parameters = (0, _json.parametersFromJSON)(json, context), node = null, string = stringFromProcedureReferenceAndParameters(procedureReference, parameters), procedureCall = new ProcedureCall(node, string, procedureReference, parameters);
+                return procedureCall;
+            }
+        },
+        {
+            key: "fromPremiseNode",
+            value: function fromPremiseNode(premiseNode, context) {
+                var procedureCall = null;
+                var procedureCallNode = premiseNode.getProcedureCallNode();
+                if (procedureCallNode !== null) {
+                    procedureCall = procedureCallFromProcedureCallNode(procedureCallNode, context);
+                }
+                return procedureCall;
+            }
+        },
+        {
+            key: "fromSuppositionNode",
+            value: function fromSuppositionNode(suppositionNode, context) {
+                var procedureCall = null;
+                var procedureCallNode = suppositionNode.getProcedureCallNode();
+                if (procedureCallNode !== null) {
+                    procedureCall = procedureCallFromProcedureCallNode(procedureCallNode, context);
+                }
+                return procedureCall;
+            }
+        }
+    ]);
+    return ProcedureCall;
+}(), _define_property(_ProcedureCall, "name", "ProcedureCall"), _ProcedureCall));
+function procedureCallFromProcedureCallNode(procedureCallNode, context) {
+    var ProcedureCall = _ontology.default.ProcedureCall, ProcedureReference = _ontology.default.ProcedureReference, node = procedureCallNode, procedureReference = ProcedureReference.fromProcedureCallNode(procedureCallNode, context), parameters = parametersFromProcedureCallNode(procedureCallNode, context), string = stringFromProcedureReferenceAndParameters(procedureReference, parameters), procedureCall = new ProcedureCall(node, string, procedureReference, parameters);
+    return procedureCall;
+}
+function parametersFromProcedureCallNode(procedureCallNode, context) {
+    var Parameter = _ontology.default.Parameter, parameterNodes = procedureCallNode.getParameterNodes(), parameters = parameterNodes.map(function(parameterNode) {
+        var parameter = Parameter.fromParameterNode(parameterNode, context);
+        return parameter;
+    });
+    return parameters;
+}
+function stringFromProcedureReferenceAndParameters(procedureReference, parameters) {
+    var name = procedureReference.getName(), parametersString = parameters.reduce(function(parametersString, parameter) {
+        var parameterString = parameter.getString();
+        parametersString = parametersString === null ? parameterString : "".concat(parametersString, ", ").concat(parameterString);
+        return parametersString;
+    }, null), string = "".concat(name, "(").concat(parametersString, ")");
+    return string;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/ontology/procedureCall.js"],"sourcesContent":["\"use strict\";\n\nimport { Expressions } from \"occam-furtle\";\n\nimport ontology from \"../ontology\";\n\nimport { define } from \"../ontology\";\nimport { parametersFromJSON, procedureReferenceFromJSON, parametersToParametersJSON, procedureReferenceToProcedureReferenceJSON } from \"../utilities/json\";\n\nexport default define(class ProcedureCall {\n  constructor(node, string, procedureReference, parameters) {\n    this.node = node;\n    this.string = string;\n    this.procedureReference = procedureReference;\n    this.parameters = parameters;\n  }\n\n  getNode() {\n    return this.node;\n  }\n\n  getString() {\n    return this.string;\n  }\n\n  getProcedureReference() {\n    return this.procedureReference;\n  }\n\n  getParameters() {\n    return this.parameters;\n  }\n\n  getName() { return this.procedureReference.getName(); }\n\n  findNodes(substitutions) {\n    const nodes = this.parameters.map((parameter) => {\n      const replacementNode = parameter.findReplacementNode(substitutions),\n            node = replacementNode;  ///\n\n      return node;\n    });\n\n    return nodes;\n  }\n\n  verify(assignments, stated, context) {\n    let verifies = false;\n\n    const procedureCallString = this.string; ///\n\n    context.trace(`Verifying the '${procedureCallString}' procedure call...`, this.node);\n\n    const name = this.getName(),\n          procedure = context.findProcedureByName(name);\n\n    if (procedure !== null) {\n      const procedureBoolean = procedure.isBoolean();\n\n      if (procedureBoolean) {\n        verifies = true;\n      } else {\n        context.trace(`The '${procedureCallString}' procedure is not boolean.`, this.node);\n      }\n    } else {\n      context.trace(`The '${procedureCallString}' procedure is not present.`, this.node);\n    }\n\n    if (verifies) {\n      context.debug(`...verified the '${procedureCallString}' procedure call.`, this.node);\n    }\n\n    return verifies;\n  }\n\n  unifyIndependently(substitutions, context) {\n    let unifiesIndependently = false;\n\n    const procedureCallString = this.string; ///\n\n    context.trace(`Unifying the '${procedureCallString}' procedure call independently...`);\n\n    const name = this.getName(),\n          nodes = this.findNodes(substitutions),\n          procedure = context.findProcedureByName(name),\n          expressions = Expressions.fromNodes(nodes, context);\n\n    try {\n      const value = procedure.call(expressions, context),\n            boolean = value.getBoolean();\n\n      unifiesIndependently = boolean; ///\n    } catch (exception) {\n      const message = exception.getMessage();\n\n      context.info(message);\n    }\n\n    if (unifiesIndependently) {\n      context.debug(`...unified the '${procedureCallString}' procedure call independently.`);\n    }\n\n    return unifiesIndependently;\n  }\n\n  toJSON() {\n    const parametersJSON = parametersToParametersJSON(this.parameters),\n          procedureReference = procedureReferenceToProcedureReferenceJSON(this.procedureReference),\n          parameters = parametersJSON,  ///\n          json = {\n            procedureReference,\n            parameters\n          };\n\n    return json;\n  }\n\n  static name = \"ProcedureCall\";\n\n  static fromJSON(json, context) {\n    const procedureReference = procedureReferenceFromJSON(json, context),\n          parameters = parametersFromJSON(json, context),\n          node = null,\n          string = stringFromProcedureReferenceAndParameters(procedureReference, parameters),\n          procedureCall = new ProcedureCall(node, string, procedureReference, parameters);\n\n    return procedureCall;\n  }\n\n  static fromPremiseNode(premiseNode, context) {\n    let procedureCall = null;\n\n    const procedureCallNode = premiseNode.getProcedureCallNode();\n\n    if (procedureCallNode !== null) {\n      procedureCall = procedureCallFromProcedureCallNode(procedureCallNode, context);\n    }\n\n    return procedureCall;\n  }\n\n  static fromSuppositionNode(suppositionNode, context) {\n    let procedureCall = null;\n\n    const procedureCallNode = suppositionNode.getProcedureCallNode();\n\n    if (procedureCallNode !== null) {\n      procedureCall = procedureCallFromProcedureCallNode(procedureCallNode, context);\n    }\n\n    return procedureCall;\n  }\n});\n\nfunction procedureCallFromProcedureCallNode(procedureCallNode, context) {\n  const { ProcedureCall, ProcedureReference } = ontology,\n        node = procedureCallNode, ///\n        procedureReference = ProcedureReference.fromProcedureCallNode(procedureCallNode, context),\n        parameters = parametersFromProcedureCallNode(procedureCallNode, context),\n        string = stringFromProcedureReferenceAndParameters(procedureReference, parameters),\n        procedureCall = new ProcedureCall(node, string, procedureReference, parameters);\n\n  return procedureCall;\n}\n\nfunction parametersFromProcedureCallNode(procedureCallNode, context) {\n  const { Parameter } = ontology,\n        parameterNodes = procedureCallNode.getParameterNodes(),\n        parameters = parameterNodes.map((parameterNode) => {\n          const parameter = Parameter.fromParameterNode(parameterNode, context);\n\n          return parameter;\n        });\n\n  return parameters;\n}\n\nfunction stringFromProcedureReferenceAndParameters(procedureReference, parameters) {\n  const name = procedureReference.getName(),\n        parametersString = parameters.reduce((parametersString, parameter) => {\n          const parameterString = parameter.getString();\n\n          parametersString = (parametersString === null) ?\n                                parameterString : ///\n                                  `${parametersString}, ${parameterString}`;\n\n          return parametersString;\n        }, null),\n        string = `${name}(${parametersString})`;\n\n  return string;\n}\n"],"names":["define","ProcedureCall","node","string","procedureReference","parameters","getNode","getString","getProcedureReference","getParameters","getName","findNodes","substitutions","nodes","map","parameter","replacementNode","findReplacementNode","verify","assignments","stated","context","verifies","procedureCallString","trace","name","procedure","findProcedureByName","procedureBoolean","isBoolean","debug","unifyIndependently","unifiesIndependently","expressions","Expressions","fromNodes","value","call","boolean","getBoolean","exception","message","getMessage","info","toJSON","parametersJSON","parametersToParametersJSON","procedureReferenceToProcedureReferenceJSON","json","fromJSON","procedureReferenceFromJSON","parametersFromJSON","stringFromProcedureReferenceAndParameters","procedureCall","fromPremiseNode","premiseNode","procedureCallNode","getProcedureCallNode","procedureCallFromProcedureCallNode","fromSuppositionNode","suppositionNode","ontology","ProcedureReference","fromProcedureCallNode","parametersFromProcedureCallNode","Parameter","parameterNodes","getParameterNodes","parameterNode","fromParameterNode","parametersString","reduce","parameterString"],"mappings":"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"}

package/lib/{dom → ontology}/procedureReference.js

@@ -8,7 +8,7 @@ Object.defineProperty(exports, "default", {
         return _default;
     }
 });
-var _dom = require("../dom");
+var _ontology = require("../ontology");
 function _class_call_check(instance, Constructor) {
     if (!(instance instanceof Constructor)) {
         throw new TypeError("Cannot call a class as a function");
@@ -42,7 +42,7 @@ function _define_property(obj, key, value) {
     return obj;
 }
 var _ProcedureReference;
-var _default = (0, _dom.domAssigned)((_ProcedureReference = /*#__PURE__*/ function() {
+var _default = (0, _ontology.define)((_ProcedureReference = /*#__PURE__*/ function() {
     function ProcedureReference(string, name) {
         _class_call_check(this, ProcedureReference);
         this.string = string;
@@ -89,4 +89,4 @@ var _default = (0, _dom.domAssigned)((_ProcedureReference = /*#__PURE__*/ functi
     return ProcedureReference;
 }(), _define_property(_ProcedureReference, "name", "ProcedureReference"), _ProcedureReference));
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9vbnRvbG9neS9wcm9jZWR1cmVSZWZlcmVuY2UuanMiXSwic291cmNlc0NvbnRlbnQiOlsiXCJ1c2Ugc3RyaWN0XCI7XG5cbmltcG9ydCB7IGRlZmluZSB9IGZyb20gXCIuLi9vbnRvbG9neVwiO1xuXG5leHBvcnQgZGVmYXVsdCBkZWZpbmUoY2xhc3MgUHJvY2VkdXJlUmVmZXJlbmNlIHtcbiAgY29uc3RydWN0b3Ioc3RyaW5nLCBuYW1lKSB7XG4gICAgdGhpcy5zdHJpbmcgPSBzdHJpbmc7XG4gICAgdGhpcy5uYW1lID0gbmFtZTtcbiAgfVxuXG4gIGdldFN0cmluZygpIHtcbiAgICByZXR1cm4gdGhpcy5zdHJpbmc7XG4gIH1cblxuICBnZXROYW1lKCkge1xuICAgIHJldHVybiB0aGlzLm5hbWU7XG4gIH1cblxuICB0b0pTT04oKSB7XG4gICAgY29uc3QgbmFtZSA9IHRoaXMubmFtZSxcbiAgICAgICAgICBqc29uID0ge1xuICAgICAgICAgICAgbmFtZVxuICAgICAgICAgIH07XG5cbiAgICByZXR1cm4ganNvbjtcbiAgfVxuXG4gIHN0YXRpYyBmcm9tSlNPTihqc29uLCBjb250ZXh0KSB7XG4gICAgY29uc3QgeyBuYW1lIH0gPSBqc29uLFxuICAgICAgICAgIHN0cmluZyA9IG5hbWUsICAvLy9cbiAgICAgICAgICBwcm9jZWR1cmVSZWZlcmVuY2UgPSBuZXcgUHJvY2VkdXJlUmVmZXJlbmNlKHN0cmluZywgbmFtZSk7XG5cbiAgICByZXR1cm4gcHJvY2VkdXJlUmVmZXJlbmNlO1xuICB9XG5cbiAgc3RhdGljIG5hbWUgPSBcIlByb2NlZHVyZVJlZmVyZW5jZVwiO1xuXG4gIHN0YXRpYyBmcm9tUHJvY2VkdXJlQ2FsbE5vZGUocHJvY2VkdXJlQ2FsbE5vZGUsIGNvbnRleHQpIHtcbiAgICBjb25zdCBwcm9jZWR1cmVOYW1lID0gcHJvY2VkdXJlQ2FsbE5vZGUuZ2V0UHJvY2VkdXJlTmFtZSgpLFxuICAgICAgICAgIG5hbWUgPSBwcm9jZWR1cmVOYW1lLCAvLy9cbiAgICAgICAgICBzdHJpbmcgPSBuYW1lLCAgLy8vXG4gICAgICAgICAgcHJvY2VkdXJlUmVmZXJlbmNlID0gbmV3IFByb2NlZHVyZVJlZmVyZW5jZShzdHJpbmcsIG5hbWUpO1xuXG4gICAgcmV0dXJuIHByb2NlZHVyZVJlZmVyZW5jZTtcbiAgfVxufSk7XG4iXSwibmFtZXMiOlsiZGVmaW5lIiwiUHJvY2VkdXJlUmVmZXJlbmNlIiwic3RyaW5nIiwibmFtZSIsImdldFN0cmluZyIsImdldE5hbWUiLCJ0b0pTT04iLCJqc29uIiwiZnJvbUpTT04iLCJjb250ZXh0IiwicHJvY2VkdXJlUmVmZXJlbmNlIiwiZnJvbVByb2NlZHVyZUNhbGxOb2RlIiwicHJvY2VkdXJlQ2FsbE5vZGUiLCJwcm9jZWR1cmVOYW1lIiwiZ2V0UHJvY2VkdXJlTmFtZSJdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7K0JBSUE7OztlQUFBOzs7d0JBRnVCOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0lBRXZCLFdBQWVBLElBQUFBLGdCQUFNLHVDQUFDO2FBQU1DLG1CQUNkQyxNQUFNLEVBQUVDLElBQUk7Z0NBREVGO1FBRXhCLElBQUksQ0FBQ0MsTUFBTSxHQUFHQTtRQUNkLElBQUksQ0FBQ0MsSUFBSSxHQUFHQTs7OztZQUdkQyxLQUFBQTttQkFBQUEsU0FBQUE7Z0JBQ0UsT0FBTyxJQUFJLENBQUNGLE1BQU07WUFDcEI7OztZQUVBRyxLQUFBQTttQkFBQUEsU0FBQUE7Z0JBQ0UsT0FBTyxJQUFJLENBQUNGLElBQUk7WUFDbEI7OztZQUVBRyxLQUFBQTttQkFBQUEsU0FBQUE7Z0JBQ0UsSUFBTUgsT0FBTyxJQUFJLENBQUNBLElBQUksRUFDaEJJLE9BQU87b0JBQ0xKLE1BQUFBO2dCQUNGO2dCQUVOLE9BQU9JO1lBQ1Q7Ozs7WUFFT0MsS0FBQUE7bUJBQVAsU0FBT0EsU0FBU0QsSUFBSSxFQUFFRSxPQUFPO2dCQUMzQixJQUFNLEFBQUVOLE9BQVNJLEtBQVRKLE1BQ0ZELFNBQVNDLE1BQ1RPLHFCQUFxQixJQUFJVCxtQkFBbUJDLFFBQVFDO2dCQUUxRCxPQUFPTztZQUNUOzs7WUFJT0MsS0FBQUE7bUJBQVAsU0FBT0Esc0JBQXNCQyxpQkFBaUIsRUFBRUgsT0FBTztnQkFDckQsSUFBTUksZ0JBQWdCRCxrQkFBa0JFLGdCQUFnQixJQUNsRFgsT0FBT1UsZUFDUFgsU0FBU0MsTUFDVE8scUJBQXFCLElBQUlULG1CQUFtQkMsUUFBUUM7Z0JBRTFELE9BQU9PO1lBQ1Q7Ozs7S0FUQSxzQ0FBT1AsUUFBTyJ9