occam-verify-cli 1.0.582 → 1.0.584

package/lib/element/derivation.js

@@ -8,8 +8,8 @@ Object.defineProperty(exports, "default", {
         return _default;
     }
 });
-var _occamlanguages = require("occam-languages");
 var _necessary = require("necessary");
+var _occamlanguages = require("occam-languages");
 var _assign = /*#__PURE__*/ _interop_require_default(require("../process/assign"));
 var _elements = require("../elements");
 function _assert_this_initialized(self) {
@@ -18,6 +18,35 @@ function _assert_this_initialized(self) {
     }
     return self;
 }
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
 function _call_super(_this, derived, args) {
     derived = _get_prototype_of(derived);
     return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
@@ -149,8 +178,99 @@ function _is_native_reflect_construct() {
         return !!result;
     })();
 }
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
 var _Derivation;
-var last = _necessary.arrayUtilities.last;
+var last = _necessary.arrayUtilities.last, asyncEvery = _occamlanguages.asynchronousUtilities.asyncEvery;
 var _default = (0, _elements.define)((_Derivation = /*#__PURE__*/ function(Element) {
     _inherits(Derivation, Element);
     function Derivation(context, string, node, subproofOrProofAssertions) {
@@ -181,22 +301,57 @@ var _default = (0, _elements.define)((_Derivation = /*#__PURE__*/ function(Eleme
         {
             key: "verify",
             value: function verify(context) {
-                var verifies;
-                verifies = this.subproofOrProofAssertions.every(function(subproofOrProofAssertion) {
-                    var assignments = [], subproofOrProofAssertionVerifies = subproofOrProofAssertion.verify(assignments, context);
-                    if (subproofOrProofAssertionVerifies) {
-                        var assignmentsAssigned = (0, _assign.default)(assignments, context);
-                        if (assignmentsAssigned) {
-                            context.addSubproofOrProofAssertion(subproofOrProofAssertion);
-                            return true;
+                return _async_to_generator(function() {
+                    var verifies;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    asyncEvery(this.subproofOrProofAssertions, function(subproofOrProofAssertion) {
+                                        return _async_to_generator(function() {
+                                            var assignments, subproofOrProofAssertionVerifies, assignmentsAssigned;
+                                            return _ts_generator(this, function(_state) {
+                                                switch(_state.label){
+                                                    case 0:
+                                                        assignments = [];
+                                                        return [
+                                                            4,
+                                                            subproofOrProofAssertion.verify(assignments, context)
+                                                        ];
+                                                    case 1:
+                                                        subproofOrProofAssertionVerifies = _state.sent();
+                                                        if (subproofOrProofAssertionVerifies) {
+                                                            assignmentsAssigned = (0, _assign.default)(assignments, context);
+                                                            if (assignmentsAssigned) {
+                                                                context.addSubproofOrProofAssertion(subproofOrProofAssertion);
+                                                                return [
+                                                                    2,
+                                                                    true
+                                                                ];
+                                                            }
+                                                        }
+                                                        return [
+                                                            2
+                                                        ];
+                                                }
+                                            });
+                                        })();
+                                    })
+                                ];
+                            case 1:
+                                verifies = _state.sent();
+                                return [
+                                    2,
+                                    verifies
+                                ];
                         }
-                    }
-                });
-                return verifies;
+                    });
+                }).call(this);
             }
         }
     ]);
     return Derivation;
 }(_wrap_native_super(_occamlanguages.Element)), _define_property(_Derivation, "name", "Derivation"), _Derivation));
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9lbGVtZW50L2Rlcml2YXRpb24uanMiXSwic291cmNlc0NvbnRlbnQiOlsiXCJ1c2Ugc3RyaWN0XCI7XG5cbmltcG9ydCB7IGFycmF5VXRpbGl0aWVzIH0gZnJvbSBcIm5lY2Vzc2FyeVwiO1xuaW1wb3J0IHsgRWxlbWVudCwgYXN5bmNocm9ub3VzVXRpbGl0aWVzIH0gZnJvbSBcIm9jY2FtLWxhbmd1YWdlc1wiO1xuXG5pbXBvcnQgYXNzaWduQXNzaWdubWVudHMgZnJvbSBcIi4uL3Byb2Nlc3MvYXNzaWduXCI7XG5cbmltcG9ydCB7IGRlZmluZSB9IGZyb20gXCIuLi9lbGVtZW50c1wiO1xuXG5jb25zdCB7IGxhc3QgfSA9IGFycmF5VXRpbGl0aWVzLFxuICAgICAgeyBhc3luY0V2ZXJ5IH0gPSBhc3luY2hyb25vdXNVdGlsaXRpZXM7XG5cbmV4cG9ydCBkZWZhdWx0IGRlZmluZShjbGFzcyBEZXJpdmF0aW9uIGV4dGVuZHMgRWxlbWVudCB7XG4gIGNvbnN0cnVjdG9yKGNvbnRleHQsIHN0cmluZywgbm9kZSwgc3VicHJvb2ZPclByb29mQXNzZXJ0aW9ucykge1xuICAgIHN1cGVyKGNvbnRleHQsIHN0cmluZywgbm9kZSk7XG5cbiAgICB0aGlzLnN1YnByb29mT3JQcm9vZkFzc2VydGlvbnMgPSBzdWJwcm9vZk9yUHJvb2ZBc3NlcnRpb25zO1xuICB9XG5cbiAgZ2V0U3VicHJvb2ZPclByb29mQXNzZXJ0aW9ucygpIHtcbiAgICByZXR1cm4gdGhpcy5zdWJwcm9vZk9yUHJvb2ZBc3NlcnRpb25zO1xuICB9XG5cbiAgZ2V0TGFzdFByb29mQXNzZXJ0aW9uKCkge1xuICAgIGNvbnN0IGxhc3RTdWJwcm9vZk9yUHJvb2ZBc3NlcnRpb24gPSBsYXN0KHRoaXMuc3VicHJvb2ZPclByb29mQXNzZXJ0aW9ucyksXG4gICAgICAgICAgbGFzdFByb29mQXNzZXJ0aW9uID0gbGFzdFN1YnByb29mT3JQcm9vZkFzc2VydGlvbjsgIC8vL1xuXG4gICAgcmV0dXJuIGxhc3RQcm9vZkFzc2VydGlvbjtcbiAgfVxuXG4gIGFzeW5jIHZlcmlmeShjb250ZXh0KSB7XG4gICAgbGV0IHZlcmlmaWVzO1xuXG4gICAgdmVyaWZpZXMgPSBhd2FpdCBhc3luY0V2ZXJ5KHRoaXMuc3VicHJvb2ZPclByb29mQXNzZXJ0aW9ucywgYXN5bmMgKHN1YnByb29mT3JQcm9vZkFzc2VydGlvbikgPT4geyAvLy9cbiAgICAgIGNvbnN0IGFzc2lnbm1lbnRzID0gW10sXG4gICAgICAgICAgICBzdWJwcm9vZk9yUHJvb2ZBc3NlcnRpb25WZXJpZmllcyA9IGF3YWl0IHN1YnByb29mT3JQcm9vZkFzc2VydGlvbi52ZXJpZnkoYXNzaWdubWVudHMsIGNvbnRleHQpO1xuXG4gICAgICBpZiAoc3VicHJvb2ZPclByb29mQXNzZXJ0aW9uVmVyaWZpZXMpIHtcbiAgICAgICAgY29uc3QgYXNzaWdubWVudHNBc3NpZ25lZCA9IGFzc2lnbkFzc2lnbm1lbnRzKGFzc2lnbm1lbnRzLCBjb250ZXh0KTtcblxuICAgICAgICBpZiAoYXNzaWdubWVudHNBc3NpZ25lZCkge1xuICAgICAgICAgIGNvbnRleHQuYWRkU3VicHJvb2ZPclByb29mQXNzZXJ0aW9uKHN1YnByb29mT3JQcm9vZkFzc2VydGlvbik7XG5cbiAgICAgICAgICByZXR1cm4gdHJ1ZTtcbiAgICAgICAgfVxuICAgICAgfVxuICAgIH0pO1xuXG4gICAgcmV0dXJuIHZlcmlmaWVzO1xuICB9XG5cbiAgc3RhdGljIG5hbWUgPSBcIkRlcml2YXRpb25cIjtcbn0pO1xuXG4iXSwibmFtZXMiOlsibGFzdCIsImFycmF5VXRpbGl0aWVzIiwiYXN5bmNFdmVyeSIsImFzeW5jaHJvbm91c1V0aWxpdGllcyIsImRlZmluZSIsIkRlcml2YXRpb24iLCJjb250ZXh0Iiwic3RyaW5nIiwibm9kZSIsInN1YnByb29mT3JQcm9vZkFzc2VydGlvbnMiLCJnZXRTdWJwcm9vZk9yUHJvb2ZBc3NlcnRpb25zIiwiZ2V0TGFzdFByb29mQXNzZXJ0aW9uIiwibGFzdFN1YnByb29mT3JQcm9vZkFzc2VydGlvbiIsImxhc3RQcm9vZkFzc2VydGlvbiIsInZlcmlmeSIsInZlcmlmaWVzIiwic3VicHJvb2ZPclByb29mQXNzZXJ0aW9uIiwiYXNzaWdubWVudHMiLCJzdWJwcm9vZk9yUHJvb2ZBc3NlcnRpb25WZXJpZmllcyIsImFzc2lnbm1lbnRzQXNzaWduZWQiLCJhc3NpZ25Bc3NpZ25tZW50cyIsImFkZFN1YnByb29mT3JQcm9vZkFzc2VydGlvbiIsIkVsZW1lbnQiLCJuYW1lIl0sIm1hcHBpbmdzIjoiQUFBQTs7OzsrQkFZQTs7O2VBQUE7Ozt5QkFWK0I7OEJBQ2dCOzZEQUVqQjt3QkFFUDs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUV2QixJQUFNLEFBQUVBLE9BQVNDLHlCQUFjLENBQXZCRCxNQUNGLEFBQUVFLGFBQWVDLHFDQUFxQixDQUFwQ0Q7SUFFUixXQUFlRSxJQUFBQSxnQkFBTSwrQkFBQzs7YUFBTUMsV0FDZEMsT0FBTyxFQUFFQyxNQUFNLEVBQUVDLElBQUksRUFBRUMseUJBQXlCO2dDQURsQ0o7O2dCQUV4QixrQkFGd0JBO1lBRWxCQztZQUFTQztZQUFRQzs7UUFFdkIsTUFBS0MseUJBQXlCLEdBQUdBOzs7OztZQUduQ0MsS0FBQUE7bUJBQUFBLFNBQUFBO2dCQUNFLE9BQU8sSUFBSSxDQUFDRCx5QkFBeUI7WUFDdkM7OztZQUVBRSxLQUFBQTttQkFBQUEsU0FBQUE7Z0JBQ0UsSUFBTUMsK0JBQStCWixLQUFLLElBQUksQ0FBQ1MseUJBQXlCLEdBQ2xFSSxxQkFBcUJELDhCQUErQixHQUFHO2dCQUU3RCxPQUFPQztZQUNUOzs7WUFFTUMsS0FBQUE7bUJBQU4sU0FBTUEsT0FBT1IsT0FBTzs7d0JBQ2RTOzs7O2dDQUVPOztvQ0FBTWIsV0FBVyxJQUFJLENBQUNPLHlCQUF5QixFQUFFLFNBQU9POztnREFDM0RDLGFBQ0FDLGtDQUdFQzs7Ozt3REFKRkY7d0RBQ21DOzs0REFBTUQseUJBQXlCRixNQUFNLENBQUNHLGFBQWFYOzs7d0RBQXRGWSxtQ0FBbUM7d0RBRXpDLElBQUlBLGtDQUFrQzs0REFDOUJDLHNCQUFzQkMsSUFBQUEsZUFBaUIsRUFBQ0gsYUFBYVg7NERBRTNELElBQUlhLHFCQUFxQjtnRUFDdkJiLFFBQVFlLDJCQUEyQixDQUFDTDtnRUFFcEM7O29FQUFPOzs0REFDVDt3REFDRjs7Ozs7O3dDQUNGOzs7O2dDQWJBRCxXQUFXO2dDQWVYOztvQ0FBT0E7Ozs7Z0JBQ1Q7Ozs7O3FCQXJDNkNPLHVCQUFPLElBdUNwRCw4QkFBT0MsUUFBTyJ9

package/lib/element/procedureCall.js

@@ -18,6 +18,35 @@ function _assert_this_initialized(self) {
     }
     return self;
 }
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
 function _call_super(_this, derived, args) {
     derived = _get_prototype_of(derived);
     return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
@@ -144,6 +173,97 @@ function _is_native_reflect_construct() {
         return !!result;
     })();
 }
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
 var _ProcedureCall;
 var termsFromPrimitives = _occamfurtle.termsUtilities.termsFromPrimitives;
 var _default = (0, _elements.define)((_ProcedureCall = /*#__PURE__*/ function(Element) {
@@ -215,21 +335,61 @@ var _default = (0, _elements.define)((_ProcedureCall = /*#__PURE__*/ function(El
         {
             key: "unifyIndependently",
             value: function unifyIndependently(context) {
-                var unifiesIndependently = false;
-                var procedureCallString = this.getString(); ///
-                context.trace("Unifying the '".concat(procedureCallString, "' procedure call independently..."));
-                var name = this.getName(), primitives = this.findPrimitives(context), terms = termsFromPrimitives(primitives), procedure = context.findProcedureByName(name);
-                try {
-                    var term = procedure.call(terms, context), boolean = term.isBoolean();
-                    unifiesIndependently = boolean; ///
-                } catch (exception) {
-                    var message = exception.getMessage();
-                    context.info(message);
-                }
-                if (unifiesIndependently) {
-                    context.debug("...unified the '".concat(procedureCallString, "' procedure call independently."));
-                }
-                return unifiesIndependently;
+                return _async_to_generator(function() {
+                    var unifiesIndependently, procedureCallString, name, primitives, terms, procedure, term, boolean, primitiveValue, exception, message;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                unifiesIndependently = false;
+                                procedureCallString = this.getString(); ///
+                                context.trace("Unifying the '".concat(procedureCallString, "' procedure call independently..."));
+                                name = this.getName(), primitives = this.findPrimitives(context), terms = termsFromPrimitives(primitives), procedure = context.findProcedureByName(name);
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    3,
+                                    ,
+                                    4
+                                ]);
+                                term = procedure.call(terms, context);
+                                return [
+                                    4,
+                                    term.isBoolean()
+                                ];
+                            case 2:
+                                boolean = _state.sent();
+                                if (!boolean) {
+                                    context.info("The '".concat(procedureCallString, "' procedure call did not return a boolean."));
+                                } else {
+                                    primitiveValue = term.getPrimitiveValue();
+                                    if (primitiveValue) {
+                                        unifiesIndependently = true;
+                                    }
+                                }
+                                return [
+                                    3,
+                                    4
+                                ];
+                            case 3:
+                                exception = _state.sent();
+                                message = exception.getMessage();
+                                context.info(message);
+                                return [
+                                    3,
+                                    4
+                                ];
+                            case 4:
+                                if (unifiesIndependently) {
+                                    context.debug("...unified the '".concat(procedureCallString, "' procedure call independently."));
+                                }
+                                return [
+                                    2,
+                                    unifiesIndependently
+                                ];
+                        }
+                    });
+                }).call(this);
             }
         },
         {
@@ -254,4 +414,4 @@ var _default = (0, _elements.define)((_ProcedureCall = /*#__PURE__*/ function(El
     return ProcedureCall;
 }(_wrap_native_super(_occamlanguages.Element)), _define_property(_ProcedureCall, "name", "ProcedureCall"), _ProcedureCall));
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/element/procedureCall.js"],"sourcesContent":["\"use strict\";\n\nimport { Element } from \"occam-languages\";\nimport { termsUtilities } from \"occam-furtle\";\n\nimport { define } from \"../elements\";\nimport { parametersFromJSON, procedureReferenceFromJSON, parametersToParametersJSON, procedureReferenceToProcedureReferenceJSON } from \"../utilities/json\";\n\nconst { termsFromPrimitives } = termsUtilities;\n\nexport default define(class ProcedureCall extends Element {\n  constructor(context, string, node, parameters, procedureReference) {\n    super(context, string, node);\n\n    this.parameters = parameters;\n    this.procedureReference = procedureReference;\n  }\n\n  getParameters() {\n    return this.parameters;\n  }\n\n  getProcedureReference() {\n    return this.procedureReference;\n  }\n\n  getName() { return this.procedureReference.getName(); }\n\n  findPrimitives(context) {\n    const substitutions = context.getSubstitutions(),\n          primitives = this.parameters.map((parameter) => {\n            const primitive = parameter.findPrimitive(substitutions);\n\n            return primitive;\n          });\n\n    return primitives;\n  }\n\n  validate(context) {\n    let validates = false;\n\n    const procedureCallString = this.getString(); ///\n\n    context.trace(`Validating the '${procedureCallString}' procedure call...`);\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        validates = true;\n      } else {\n        context.trace(`The '${procedureCallString}' procedure is not boolean.`);\n      }\n    } else {\n      context.trace(`The '${procedureCallString}' procedure is not present.`);\n    }\n\n    if (validates) {\n      context.debug(`...validated the '${procedureCallString}' procedure call.`);\n    }\n\n    return validates;\n  }\n\n  unifyIndependently(context) {\n    let unifiesIndependently = false;\n\n    const procedureCallString = this.getString(); ///\n\n    context.trace(`Unifying the '${procedureCallString}' procedure call independently...`);\n\n    const name = this.getName(),\n          primitives = this.findPrimitives(context),\n          terms = termsFromPrimitives(primitives),\n          procedure = context.findProcedureByName(name);\n\n    try {\n      const term = procedure.call(terms, context),\n            boolean = term.isBoolean();\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 node = null,\n          parameters = parametersFromJSON(json, context),\n          procedureReference = procedureReferenceFromJSON(json, context),\n          string = stringFromProcedureReferenceAndParameters(procedureReference, parameters),\n          procedureCall = new ProcedureCall(context, string, node, parameters, procedureReference);\n\n    return procedureCall;\n  }\n});\n"],"names":["termsFromPrimitives","termsUtilities","define","ProcedureCall","context","string","node","parameters","procedureReference","getParameters","getProcedureReference","getName","findPrimitives","substitutions","getSubstitutions","primitives","map","parameter","primitive","findPrimitive","validate","validates","procedureCallString","getString","trace","name","procedure","findProcedureByName","procedureBoolean","isBoolean","debug","unifyIndependently","unifiesIndependently","terms","term","call","boolean","exception","message","getMessage","info","toJSON","parametersJSON","parametersToParametersJSON","procedureReferenceToProcedureReferenceJSON","json","fromJSON","parametersFromJSON","procedureReferenceFromJSON","stringFromProcedureReferenceAndParameters","procedureCall","Element"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/element/procedureCall.js"],"sourcesContent":["\"use strict\";\n\nimport { Element } from \"occam-languages\";\nimport { termsUtilities } from \"occam-furtle\";\n\nimport { define } from \"../elements\";\nimport { parametersFromJSON, procedureReferenceFromJSON, parametersToParametersJSON, procedureReferenceToProcedureReferenceJSON } from \"../utilities/json\";\n\nconst { termsFromPrimitives } = termsUtilities;\n\nexport default define(class ProcedureCall extends Element {\n  constructor(context, string, node, parameters, procedureReference) {\n    super(context, string, node);\n\n    this.parameters = parameters;\n    this.procedureReference = procedureReference;\n  }\n\n  getParameters() {\n    return this.parameters;\n  }\n\n  getProcedureReference() {\n    return this.procedureReference;\n  }\n\n  getName() { return this.procedureReference.getName(); }\n\n  findPrimitives(context) {\n    const substitutions = context.getSubstitutions(),\n          primitives = this.parameters.map((parameter) => {\n            const primitive = parameter.findPrimitive(substitutions);\n\n            return primitive;\n          });\n\n    return primitives;\n  }\n\n  validate(context) {\n    let validates = false;\n\n    const procedureCallString = this.getString(); ///\n\n    context.trace(`Validating the '${procedureCallString}' procedure call...`);\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        validates = true;\n      } else {\n        context.trace(`The '${procedureCallString}' procedure is not boolean.`);\n      }\n    } else {\n      context.trace(`The '${procedureCallString}' procedure is not present.`);\n    }\n\n    if (validates) {\n      context.debug(`...validated the '${procedureCallString}' procedure call.`);\n    }\n\n    return validates;\n  }\n\n  async unifyIndependently(context) {\n    let unifiesIndependently = false;\n\n    const procedureCallString = this.getString(); ///\n\n    context.trace(`Unifying the '${procedureCallString}' procedure call independently...`);\n\n    const name = this.getName(),\n          primitives = this.findPrimitives(context),\n          terms = termsFromPrimitives(primitives),\n          procedure = context.findProcedureByName(name);\n\n    try {\n      const term = procedure.call(terms, context),\n            boolean = await term.isBoolean();\n\n      if (!boolean) {\n        context.info(`The '${procedureCallString}' procedure call did not return a boolean.`);\n      } else {\n        const primitiveValue = term.getPrimitiveValue();\n\n        if (primitiveValue) {\n          unifiesIndependently = true;\n        }\n      }\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 node = null,\n          parameters = parametersFromJSON(json, context),\n          procedureReference = procedureReferenceFromJSON(json, context),\n          string = stringFromProcedureReferenceAndParameters(procedureReference, parameters),\n          procedureCall = new ProcedureCall(context, string, node, parameters, procedureReference);\n\n    return procedureCall;\n  }\n});\n"],"names":["termsFromPrimitives","termsUtilities","define","ProcedureCall","context","string","node","parameters","procedureReference","getParameters","getProcedureReference","getName","findPrimitives","substitutions","getSubstitutions","primitives","map","parameter","primitive","findPrimitive","validate","validates","procedureCallString","getString","trace","name","procedure","findProcedureByName","procedureBoolean","isBoolean","debug","unifyIndependently","unifiesIndependently","terms","term","boolean","primitiveValue","exception","message","call","info","getPrimitiveValue","getMessage","toJSON","parametersJSON","parametersToParametersJSON","procedureReferenceToProcedureReferenceJSON","json","fromJSON","parametersFromJSON","procedureReferenceFromJSON","stringFromProcedureReferenceAndParameters","procedureCall","Element"],"mappings":"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"}