@wizhut_tech/wizjs 0.1.1 → 0.1.3

package/__tests__/lang_arrays.test.js

@@ -1,6 +1,6 @@
 const t = require('tap');
 
-const { compact } = require('../src/lang/arrays.js');
+const { compact, accumulate, Operator } = require('../src/lang/arrays.js');
 
 
 t.test('arrays/compact', (t) => {
@@ -11,4 +11,15 @@ t.test('arrays/compact', (t) => {
     t.match(compact(null), []);
     t.match(compact(undefined), []);
     t.end();
+});
+
+
+t.test('arrays/accumulate', (t) => {
+    const arr = [1, 2, 3];
+
+    t.equal(accumulate(arr, Operator.plus, 0), 6);
+    t.equal(accumulate(arr, Operator.minus, 0), -6);
+    t.equal(accumulate(arr, Operator.multiply, 0), 0);
+    t.equal(accumulate(arr, Operator.divide, 0), 0);
+    t.end();
 });

package/__tests__/lang_itertools.test.js

@@ -1,17 +1,17 @@
 const t = require('tap');
 
-const { cycle, fn_cycle } = require('../src/lang/itertools.js');
+const { count, fn_count } = require('../src/lang/itertools.js');
 
 
-t.test('itertools/cycle', (t) => {
+t.test('itertools/count', (t) => {
     // simple integer
-    const genOne = cycle(0, 1);
+    const genOne = count(0, 1);
     t.equal(genOne.next().value, 0);
     t.equal(genOne.next().value, 1);
     t.equal(genOne.next().value, 2);
 
     // simple floating-point
-    const genTwo = cycle(0, 0.5);
+    const genTwo = count(0, 0.5);
     t.equal(genTwo.next().value, 0);
     t.equal(genTwo.next().value, 0.5);
     t.equal(genTwo.next().value, 1);

package/docs/lang_arrays.md

@@ -1,3 +1,8 @@
 # Lang / Arrays
 
-* *compact(arg)*: removes *null* and *undefined* values from an array, returns always an array. If the *arg* is invalid, it returns an empty array. 
+* **compact(arg)**: removes *null* and *undefined* values from an array, returns always an array. If the *arg* is invalid, it returns an empty array.
+* **accumulate(operator, a, b)**: applies the operator to *a* and *b* then returns the result.
+
+## Classes
+
+* **Operator**: Static class that configures *accumulate* method. Support *addition (Operator.plus)*, *subtraction (Operator.minus)*, *multiplication (Operator.multiply)* and *division (Operator.division)*. 

package/docs/lang_itertools.md

@@ -1,4 +1,4 @@
 # Lang / itertools
 
-* **cycle(start, step=1)**: A generator that counts from *start* with a specified *step*. Default stepping is *1*.
-* **fn_cycle(start, step=1, fn)**: A generator that counts from *start* with a specified *step*. Default stepping is *1*. For each iteration the *fn* is called. To continue to the next iteration, the *fn* should return *true*. If not the iteration breaks,. 
+* **count(start, step=1)**: A generator that counts from *start* with a specified *step*. Default stepping is *1*.
+* **fn_count(start, step=1, fn)**: A generator that counts from *start* with a specified *step*. Default stepping is *1*. For each iteration the *fn* is called. To continue to the next iteration, the *fn* should return *true*. If not the iteration breaks,. 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wizhut_tech/wizjs",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "main": "index.js",
   "devDependencies": {
     "tap": "21.1.0"

package/src/lang/arrays.js

@@ -19,7 +19,31 @@ function compact(arr) {
     return result;
 }
 
+class Operator {
+    static plus = (a, b) => a + b;
+    static minus = (a, b) => a - b;
+    static multiply = (a, b) => a * b;
+    static divide = (a, b) => a / b;
+
+    static apply(op, a, b) {
+        return op(a, b);
+    }
+}
+
+
+function accumulate(arr, operator, initial=0) {
+    let accumulator = initial;
+
+    for (let i = 0; i < arr.length; i++) {
+        accumulator = Operator.apply(operator, accumulator, arr[i]);
+    }
+
+    return accumulator;
+}
+
 
 module.exports = {
-    compact
+    compact,
+    accumulate,
+    Operator
 }

package/src/lang/itertools.js

@@ -2,7 +2,7 @@
 const {toInteger} = require("../math/numbers");
 
 
-function* cycle(start=0, step=1) {
+function* count(start=0, step=1) {
     let iCount = toInteger(start);
     const iStep = toInteger(step);
 
@@ -12,14 +12,14 @@ function* cycle(start=0, step=1) {
     }
 }
 
-function fn_cycle(start, fn, step=1) {
-    const cycleGenerator = cycle(start, step);
+function fn_count(start, fn, step=1) {
+    const countGenerator = count(start, step);
 
-    while (fn(cycleGenerator.next().value)) { }
+    while (fn(countGenerator.next().value)) { }
 }
 
 
 module.exports = {
-    cycle,
-    fn_cycle
+    count,
+    fn_count
 };