necessary 10.0.3 → 10.0.4

package/README.md

@@ -60,13 +60,13 @@ The miscellaneous functions are a special case. They can be treated as above but
 
 The first two `get()` and `post()` functions make use of the third `request()` function, which is more generic and can be used for arbitrary HTTP requests.
 
-* The `get()` function sends a `GET` request, taking `host`, `uri`, `query` and `callback` arguments, together with an optional `headers` argument after the `query` argument.
+* The `get()` function sends a `GET` request, taking `host`, `uri`, `query` and `operation` arguments, together with an optional `headers` argument after the `query` argument.
 
 The `query` argument should be a plain old JavaScript object, the names and values of which are encoded and concatenated to form the query string.
 
 The `headers` argument should also be a plain old JavaScript object. If it does not have an `accept` property then one wil be provided with the value `application/json`.
 
-The `callback` argument is expected to be a function taking `contnet` and `statusCode` arguments. If the `accept` property of the main `headers` argument is set to `application/json` then the callback function's `content` argument can be assumed to be JSON, or `null` if the request body cannot be parsed as such. The `statusCode` argument will be the response status code, for example `200` for a successful `OK` response.
+The `operation` argument is expected to be a function taking `contnet` and `statusCode` arguments. If the `accept` property of the main `headers` argument is set to `application/json` then the operation's `content` argument can be assumed to be JSON, or `null` if the request body cannot be parsed as such. The `statusCode` argument will be the response status code, for example `200` for a successful `OK` response.
 
 ```
 const host = "...",
@@ -147,7 +147,7 @@ const offEXT = onEXT(process.exit);
 offEXT();
 ```
 
-* The `prompt()` function is meant for use in shell applications. It takes a plain old JavaScript `options` object and a `callback` function as the its first and second arguments, respectively:
+* The `prompt()` function is meant for use in shell applications. It takes a plain old JavaScript `options` object and a `callback` function as its first and second arguments, respectively:
 
 ```
 const hidden = true,
@@ -835,14 +835,14 @@ Ideally the `host` argument should not include a trailing forward slash whereas
 - `eventually()`
 - `repeatedly()`
 
-These functions generally take either a callback or an array of callbacks, followed by a `done()` function and an optional `context` argument. They all pass a `next()` function to the callbacks followed by the `done()` function, the `context` and then an `index` argument. Callbacks are given access to the `done()` function which can be called instead of the `next()` function in order to terminate early.
+These functions generally take either a operatio or an array of operations, functions that mutate a context essentially, rather than returning a value, followed by a `done()` function and an optional `context` argument. They all pass a `next()` function to the operations followed by the `done()` function, the `context` and then an `index` argument. Operations are given access to the `done()` function which can be called instead of the `next()` function in order to terminate early.
 
-* The `whilst()` function takes a single callback, which it calls each time the callback invokes the given `next()` function or until the callback invokes the given `done()` function. The callback can also force termination by returning a truthy value, in which case it must *not* call the given `next()` or `done()` functions. In the example below the callback will be executed ten times:
+* The `whilst()` function takes a single operation, which it calls each time the operation invokes the given `next()` function or until the operation invokes the given `done()` function. The operation can also force termination by returning a truthy value, in which case it must *not* call the given `next()` or `done()` functions. In the example below the operation will be executed ten times:
 
 ```
 const context = {}; ///
 
-const callback = (next, done, context, index) => {
+const operation = (next, done, context, index) => {
   const terminate = (index === 9);
 
   if (terminate) {
@@ -854,17 +854,17 @@ const callback = (next, done, context, index) => {
   }
 }
 
-whilst(callback, () => {
+whilst(operation, () => {
   /// done
 }, context);
 ```
 
-* The `forEach()` function takes an array as the first argument followed by a single callback, which it calls for each element of the array unless the callback invokes the given `done()` function. If the `done()` function is never invoked by the callback, it is called once each of the array elements has been passed to the callback, provided the callback invokes the given `next ()` function each time. In the example below the callback will be executed four times:
+* The `forEach()` function takes an array as the first argument followed by a single operation, which it calls for each element of the array unless the operation invokes the given `done()` function. If the `done()` function is never invoked by the operation, it is called once each of the array elements has been passed to the operation, provided the operationinvokes the given `next ()` function each time. In the example below the operation will be executed four times:
 
 ```
 const context = {};
 
-const callback = (element, next, done, context, index) => {
+const operation = (element, next, done, context, index) => {
   const terminate = (element === 3);
 
   if (terminate) {
@@ -878,56 +878,56 @@ const callback = (element, next, done, context, index) => {
 
 const array = [0, 1, 2, 3, 4, 5];
 
-forEach(array, callback, () => {
+forEach(array, operation, () => {
   /// done
 }, context);
 ```
 
-* The `sequence()` function takes an array of callbacks, which it calls in turn unless the callback invokes the given `done()` function. If the `done()` function is never invoked by a callback, it is called once each of the callbacks have been called, provided each callback invokes the given `next ()` function. In the example below each of the callbacks bar the last is executed:
+* The `sequence()` function takes an array of operations, which it calls in turn unless the operation invokes the given `done()` function. If the `done()` function is never invoked by a operation, it is called once each of the operations have been called, provided each operation invokes the given `next ()` function. In the example below each of the operations bar the last is executed:
 
 ```
 const context = {};
 
-const firstCallback = (next, done, context, index) => { next(); },
-      secondCallback = (next, done, context, index) => { next(); },
-      thirdCallback = (next, done, context, index) => { done(); },
-      lastCallback = (next, done, context, index) => { next(); },
-      callbacks = [
-        firstCallback,
-        secondCallback,
-        thirdCallback,
-        lastCallback
+const firstOperation = (next, done, context, index) => { next(); },
+      secondOperation = (next, done, context, index) => { next(); },
+      thirdOperation = (next, done, context, index) => { done(); },
+      lastOperation = (next, done, context, index) => { next(); },
+      operation = [
+        firstOperation,
+        secondOperation,
+        thirdOperation,
+        lastOperation
       ];
 
-sequence(callbacks, () => {
+sequence(operations, () => {
   /// done
 }, context);
 ```
 
-* The `eventually()` function takes an array of callbacks, each of which it calls immediately without waiting for the callbacks to invoke the given `next()` functions. When each of the callbacks has invoked the given `next()` function, it will call the `done()` function. Note that in this case invoking the `done()` function from within a callback will not halt the execution of other callbacks, it is passed as an argument only for the sake of convention. In the example below each of the callbacks is executed:
+* The `eventually()` function takes an array of operations, each of which it calls immediately without waiting for the operations to invoke the given `next()` functions. When each of the operations has invoked the given `next()` function, it will call the `done()` function. Note that in this case invoking the `done()` function from within a operation will not halt the execution of other operations, it is passed as an argument only for the sake of convention. In the example below each of the operations is executed:
 
 ```
 const context = {};
 
-const firstCallback = (next, done, context, index) => { next(); },
-      secondCallback = (next, done, context, index) => { next(); },
-      thirdCallback = (next, done, context, index) => { done(); },
-      callbacks = [
-        firstCallback,
-        secondCallback,
-        thirdCallback
+const firstOperation = (next, done, context, index) => { next(); },
+      secondOperation = (next, done, context, index) => { next(); },
+      thirdOperation = (next, done, context, index) => { done(); },
+      operations = [
+        firstOperation,
+        secondOperation,
+        thirdOperation
       ];
 
-eventually(callbacks, () => {
+eventually(operations, () => {
   /// done
 }, context);
 ```
-* The `repeatedly()` function takes a single callback and a `length` parameter, immediately calling the callback a `length` number of times without waiting for it to invoke the given `next()` function each time. When the callback has invoked the given `next()` function a `length` number of times, it will call the `done()` function. Note that in this case invoking the `done()` function from within the callback will not halt its execution the requisite number of times, it is passed as an argument only for the sake of convention. In the example below the callback is executed ten times:
+* The `repeatedly()` function takes a single operation and a `length` parameter, immediately calling the operation a `length` number of times without waiting for it to invoke the given `next()` function each time. When the operation has invoked the given `next()` function a `length` number of times, it will call the `done()` function. Note that in this case invoking the `done()` function from within the operation will not halt its execution the requisite number of times, it is passed as an argument only for the sake of convention. In the example below the operation is executed ten times:
 
 ```
 const context = {};
 
-const callback = (next, done, context, index) => {
+const operation = (next, done, context, index) => {
   ...
 
   next();
@@ -935,7 +935,7 @@ const callback = (next, done, context, index) => {
 
 const length = 10;
 
-repeatedly(callback, length, () => {
+repeatedly(operation, length, () => {
   // done
 }, context);
 ```

package/lib/utilities/asynchronous.js

@@ -10,18 +10,18 @@ exports.repeatedly = repeatedly;
 exports.forwardsForEach = forwardsForEach;
 exports.backwardsForEach = backwardsForEach;
 exports.default = void 0;
-function whilst(callback, done, context) {
+function whilst(operation, done, context) {
     var count = -1;
     function next() {
         count++;
-        var index = count, terminate = callback(next, done, context, index);
+        var index = count, terminate = operation(next, done, context, index);
         if (terminate) {
             done();
         }
     }
     next();
 }
-function forEach(array, callback, done, context) {
+function forEach(array, operation, done, context) {
     var length = array.length; ///
     var count = -1;
     function next() {
@@ -31,13 +31,13 @@ function forEach(array, callback, done, context) {
             done();
         } else {
             var index = count, element = array[index];
-            callback(element, next, done, context, index);
+            operation(element, next, done, context, index);
         }
     }
     next();
 }
-function sequence(callbacks, done, context) {
-    var length = callbacks.length; ///
+function sequence(operations, done, context) {
+    var length = operations.length; ///
     var count = -1;
     function next() {
         count++;
@@ -45,13 +45,13 @@ function sequence(callbacks, done, context) {
         if (terminate) {
             done();
         } else {
-            var index = count, callback = callbacks[index];
-            callback(next, done, context, index);
+            var index = count, operation = operations[index];
+            operation(next, done, context, index);
         }
     }
     next();
 }
-function eventually(callbacks, done, context) {
+function eventually(operations, done, context) {
     var next = function next() {
         count++;
         var terminate = count === length;
@@ -59,13 +59,13 @@ function eventually(callbacks, done, context) {
             done();
         }
     };
-    var length = callbacks.length; ///
+    var length = operations.length; ///
     var count = 0;
-    callbacks.forEach(function(callback, index) {
-        callback(next, done, context, index);
+    operations.forEach(function(operation, index) {
+        operation(next, done, context, index);
     });
 }
-function repeatedly(callback, length, done, context) {
+function repeatedly(operation, length, done, context) {
     var next = function next() {
         count++;
         var terminate = count === length;
@@ -75,10 +75,10 @@ function repeatedly(callback, length, done, context) {
     };
     var count = 0;
     for(var index = 0; index < length; index++){
-        callback(next, done, context, index);
+        operation(next, done, context, index);
     }
 }
-function forwardsForEach(array, callback, done, context) {
+function forwardsForEach(array, operation, done, context) {
     var length = array.length; ///
     var count = -1;
     function next() {
@@ -88,12 +88,12 @@ function forwardsForEach(array, callback, done, context) {
             done();
         } else {
             var index = count, element = array[index];
-            callback(element, next, done, context, index);
+            operation(element, next, done, context, index);
         }
     }
     next();
 }
-function backwardsForEach(array, callback, done, context) {
+function backwardsForEach(array, operation, done, context) {
     var length = array.length; ///
     var count = length;
     function next() {
@@ -103,7 +103,7 @@ function backwardsForEach(array, callback, done, context) {
             done();
         } else {
             var index = count, element = array[index];
-            callback(element, next, done, context, index);
+            operation(element, next, done, context, index);
         }
     }
     next();
@@ -119,4 +119,4 @@ var _default = {
 };
 exports.default = _default;
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/utilities/asynchronous.js"],"sourcesContent":["\"use strict\";\r\n\r\nexport function whilst(callback, done, context) {\r\n  let count = -1;\r\n\r\n  function next() {\r\n    count++;\r\n\r\n    const index = count,  ///\r\n          terminate = callback(next, done, context, index);\r\n\r\n    if (terminate) {\r\n      done();\r\n    }\r\n  }\r\n\r\n  next();\r\n}\r\n\r\nexport function forEach(array, callback, done, context) {\r\n  const length = array.length;  ///\r\n\r\n  let count = -1;\r\n\r\n  function next() {\r\n    count++;\r\n\r\n    const terminate = (count === length);\r\n\r\n    if (terminate) {\r\n      done();\r\n    } else {\r\n      const index = count,  ///\r\n            element = array[index];\r\n\r\n      callback(element, next, done, context, index);\r\n    }\r\n  }\r\n\r\n  next();\r\n}\r\n\r\nexport function sequence(callbacks, done, context) {\r\n  const length = callbacks.length;  ///\r\n\r\n  let count = -1;\r\n\r\n  function next() {\r\n    count++;\r\n\r\n    const terminate = (count === length);\r\n\r\n    if (terminate) {\r\n      done();\r\n    } else {\r\n      const index = count,  ///\r\n            callback = callbacks[index];\r\n\r\n      callback(next, done, context, index);\r\n    }\r\n  }\r\n\r\n  next();\r\n}\r\n\r\nexport function eventually(callbacks, done, context) {\r\n  const length = callbacks.length;  ///\r\n\r\n  let count = 0;\r\n\r\n  function next() {\r\n    count++;\r\n\r\n    const terminate = (count === length);\r\n\r\n    if (terminate) {\r\n      done();\r\n    }\r\n  }\r\n\r\n  callbacks.forEach((callback, index) => {\r\n    callback(next, done, context, index);\r\n  });\r\n}\r\n\r\nexport function repeatedly(callback, length, done, context) {\r\n  let count = 0;\r\n\r\n  function next() {\r\n    count++;\r\n\r\n    const terminate = (count === length);\r\n\r\n    if (terminate) {\r\n      done();\r\n    }\r\n  }\r\n\r\n  for (let index = 0; index < length; index++) {\r\n    callback(next, done, context, index);\r\n  }\r\n}\r\n\r\nexport function forwardsForEach(array, callback, done, context) {\r\n  const length = array.length;  ///\r\n\r\n  let count = -1;\r\n\r\n  function next() {\r\n    count++;\r\n\r\n    const terminate = (count === length);\r\n\r\n    if (terminate) {\r\n      done();\r\n    } else {\r\n      const index = count,  ///\r\n            element = array[index];\r\n\r\n      callback(element, next, done, context, index);\r\n    }\r\n  }\r\n\r\n  next();\r\n}\r\n\r\nexport function backwardsForEach(array, callback, done, context) {\r\n  const length = array.length;  ///\r\n\r\n  let count = length;\r\n\r\n  function next() {\r\n    count--;\r\n\r\n    const terminate = (count === -1);\r\n\r\n    if (terminate) {\r\n      done();\r\n    } else {\r\n      const index = count,  ///\r\n            element = array[index];\r\n\r\n      callback(element, next, done, context, index);\r\n    }\r\n  }\r\n\r\n  next();\r\n}\r\n\r\nexport default {\r\n  whilst,\r\n  forEach,\r\n  sequence,\r\n  eventually,\r\n  repeatedly,\r\n  forwardsForEach,\r\n  backwardsForEach\r\n};\r\n"],"names":["whilst","forEach","sequence","eventually","repeatedly","forwardsForEach","backwardsForEach","callback","done","context","count","next","index","terminate","array","length","element","callbacks"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/utilities/asynchronous.js"],"sourcesContent":["\"use strict\";\r\n\r\nexport function whilst(operation, done, context) {\r\n  let count = -1;\r\n\r\n  function next() {\r\n    count++;\r\n\r\n    const index = count,  ///\r\n          terminate = operation(next, done, context, index);\r\n\r\n    if (terminate) {\r\n      done();\r\n    }\r\n  }\r\n\r\n  next();\r\n}\r\n\r\nexport function forEach(array, operation, done, context) {\r\n  const length = array.length;  ///\r\n\r\n  let count = -1;\r\n\r\n  function next() {\r\n    count++;\r\n\r\n    const terminate = (count === length);\r\n\r\n    if (terminate) {\r\n      done();\r\n    } else {\r\n      const index = count,  ///\r\n            element = array[index];\r\n\r\n      operation(element, next, done, context, index);\r\n    }\r\n  }\r\n\r\n  next();\r\n}\r\n\r\nexport function sequence(operations, done, context) {\r\n  const length = operations.length;  ///\r\n\r\n  let count = -1;\r\n\r\n  function next() {\r\n    count++;\r\n\r\n    const terminate = (count === length);\r\n\r\n    if (terminate) {\r\n      done();\r\n    } else {\r\n      const index = count,  ///\r\n            operation = operations[index];\r\n\r\n      operation(next, done, context, index);\r\n    }\r\n  }\r\n\r\n  next();\r\n}\r\n\r\nexport function eventually(operations, done, context) {\r\n  const length = operations.length;  ///\r\n\r\n  let count = 0;\r\n\r\n  function next() {\r\n    count++;\r\n\r\n    const terminate = (count === length);\r\n\r\n    if (terminate) {\r\n      done();\r\n    }\r\n  }\r\n\r\n  operations.forEach((operation, index) => {\r\n    operation(next, done, context, index);\r\n  });\r\n}\r\n\r\nexport function repeatedly(operation, length, done, context) {\r\n  let count = 0;\r\n\r\n  function next() {\r\n    count++;\r\n\r\n    const terminate = (count === length);\r\n\r\n    if (terminate) {\r\n      done();\r\n    }\r\n  }\r\n\r\n  for (let index = 0; index < length; index++) {\r\n    operation(next, done, context, index);\r\n  }\r\n}\r\n\r\nexport function forwardsForEach(array, operation, done, context) {\r\n  const length = array.length;  ///\r\n\r\n  let count = -1;\r\n\r\n  function next() {\r\n    count++;\r\n\r\n    const terminate = (count === length);\r\n\r\n    if (terminate) {\r\n      done();\r\n    } else {\r\n      const index = count,  ///\r\n            element = array[index];\r\n\r\n      operation(element, next, done, context, index);\r\n    }\r\n  }\r\n\r\n  next();\r\n}\r\n\r\nexport function backwardsForEach(array, operation, done, context) {\r\n  const length = array.length;  ///\r\n\r\n  let count = length;\r\n\r\n  function next() {\r\n    count--;\r\n\r\n    const terminate = (count === -1);\r\n\r\n    if (terminate) {\r\n      done();\r\n    } else {\r\n      const index = count,  ///\r\n            element = array[index];\r\n\r\n      operation(element, next, done, context, index);\r\n    }\r\n  }\r\n\r\n  next();\r\n}\r\n\r\nexport default {\r\n  whilst,\r\n  forEach,\r\n  sequence,\r\n  eventually,\r\n  repeatedly,\r\n  forwardsForEach,\r\n  backwardsForEach\r\n};\r\n"],"names":["whilst","forEach","sequence","eventually","repeatedly","forwardsForEach","backwardsForEach","operation","done","context","count","next","index","terminate","array","length","element","operations"],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "necessary",
   "author": "James Smith",
-  "version": "10.0.3",
+  "version": "10.0.4",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/necessary",
   "description": "A collection of utility functions.",

package/src/utilities/asynchronous.js

@@ -1,13 +1,13 @@
 "use strict";
 
-export function whilst(callback, done, context) {
+export function whilst(operation, done, context) {
   let count = -1;
 
   function next() {
     count++;
 
     const index = count,  ///
-          terminate = callback(next, done, context, index);
+          terminate = operation(next, done, context, index);
 
     if (terminate) {
       done();
@@ -17,7 +17,7 @@ export function whilst(callback, done, context) {
   next();
 }
 
-export function forEach(array, callback, done, context) {
+export function forEach(array, operation, done, context) {
   const length = array.length;  ///
 
   let count = -1;
@@ -33,15 +33,15 @@ export function forEach(array, callback, done, context) {
       const index = count,  ///
             element = array[index];
 
-      callback(element, next, done, context, index);
+      operation(element, next, done, context, index);
     }
   }
 
   next();
 }
 
-export function sequence(callbacks, done, context) {
-  const length = callbacks.length;  ///
+export function sequence(operations, done, context) {
+  const length = operations.length;  ///
 
   let count = -1;
 
@@ -54,17 +54,17 @@ export function sequence(callbacks, done, context) {
       done();
     } else {
       const index = count,  ///
-            callback = callbacks[index];
+            operation = operations[index];
 
-      callback(next, done, context, index);
+      operation(next, done, context, index);
     }
   }
 
   next();
 }
 
-export function eventually(callbacks, done, context) {
-  const length = callbacks.length;  ///
+export function eventually(operations, done, context) {
+  const length = operations.length;  ///
 
   let count = 0;
 
@@ -78,12 +78,12 @@ export function eventually(callbacks, done, context) {
     }
   }
 
-  callbacks.forEach((callback, index) => {
-    callback(next, done, context, index);
+  operations.forEach((operation, index) => {
+    operation(next, done, context, index);
   });
 }
 
-export function repeatedly(callback, length, done, context) {
+export function repeatedly(operation, length, done, context) {
   let count = 0;
 
   function next() {
@@ -97,11 +97,11 @@ export function repeatedly(callback, length, done, context) {
   }
 
   for (let index = 0; index < length; index++) {
-    callback(next, done, context, index);
+    operation(next, done, context, index);
   }
 }
 
-export function forwardsForEach(array, callback, done, context) {
+export function forwardsForEach(array, operation, done, context) {
   const length = array.length;  ///
 
   let count = -1;
@@ -117,14 +117,14 @@ export function forwardsForEach(array, callback, done, context) {
       const index = count,  ///
             element = array[index];
 
-      callback(element, next, done, context, index);
+      operation(element, next, done, context, index);
     }
   }
 
   next();
 }
 
-export function backwardsForEach(array, callback, done, context) {
+export function backwardsForEach(array, operation, done, context) {
   const length = array.length;  ///
 
   let count = length;
@@ -140,7 +140,7 @@ export function backwardsForEach(array, callback, done, context) {
       const index = count,  ///
             element = array[index];
 
-      callback(element, next, done, context, index);
+      operation(element, next, done, context, index);
     }
   }