ig-types 6.16.4 → 6.19.0

package/Array.js

@@ -482,6 +482,35 @@ object.Mixin('ArrayProtoMixin', 'soft', {
 			this.constructor.zip(this, func, ...arrays)
 			: this.constructor.zip(func, this, ...arrays) },
 
+	// Insert new values between elements of an array
+	//
+	//	.between(value)
+	//		-> array
+	//
+	//	.between(func)
+	//		-> array
+	//
+	//	func([a, b], from_index, to_index, array)
+	//		-> elem
+	//
+	between: function(func){
+		var res = []
+		// NOTE: we skip the last element...
+		for(var i=0; i < this.length; i+=1){
+			var pair = new Array(2)
+			i in this ?
+				res.push(pair[0] = this[i])
+				: (res.length += 1)
+			if(i+1 >= this.length){
+				break }
+			i+1 in this
+				&& (pair[1] = this[i+1])
+			res.push(
+				typeof(func) == 'function' ?
+					func.call(this, pair, i, res.length, this)
+					: func) }
+		return res },
+
 	// get iterator over array...
 	//
 	//	Array.iter()

package/Promise.js

@@ -249,6 +249,15 @@ object.Constructor('IterablePromise', Promise, {
 			: (await Promise.all(list))
 				.flat() },
 
+	[Symbol.asyncIterator]: async function*(){
+		var list = this.__packed
+		if(list instanceof Promise){
+			yield this.__unpack(await list) 
+			return }
+		for await(var elem of list){
+			yield* elem instanceof Array ?
+				elem
+				: [elem] } },
 
 	// iterator methods...
 	//
@@ -294,6 +303,22 @@ object.Constructor('IterablePromise', Promise, {
 			.then(function(){ 
 				return res }) },
 
+	// XXX BETWEEN...
+	between: function(func){
+		var i = 0
+		var j = 0
+		var prev
+		return this.constructor(this,
+			function(e){
+				return i++ > 0 ?
+					[
+						typeof(func) == 'function' ?
+							func.call(this, [prev, e], i, i + j++)
+							: func,
+						e,
+					]
+					: [e] }) },
+
 	// XXX .chain(..) -- see generator.chain(..)
 
 	flat: function(depth=1){

package/README.md

@@ -30,6 +30,7 @@ Library of JavaScript type extensions, types and utilities.
     - [`<array>.toMap(..)`](#arraytomap)
     - [`Array.zip(..)` / `<array>.zip(..)`](#arrayzip--arrayzip)
     - [`Array.iter(..)` / `<array>.iter()`](#arrayiter--arrayiter)
+    - [`<array>.between(..)`](#arraybetween)
     - [Abortable `Array` iteration](#abortable-array-iteration)
       - [`array.STOP` / `array.STOP(..)`](#arraystop--arraystop)
       - [`<array>.smap(..)` / `<array>.sfilter(..)` / `<array>.sreduce(..)` / `<array>.sforEach(..)`](#arraysmap--arraysfilter--arraysreduce--arraysforeach)
@@ -48,6 +49,7 @@ Library of JavaScript type extensions, types and utilities.
     - [`<set>.replace(..)`](#setreplace)
     - [`<set>.replaceAt(..)`](#setreplaceat)
     - [`<set>.sort(..)`](#setsort)
+    - [`<set>.filter(..)` / `<set>.map(..)` / `<set>.forEach(..)` / `<set>.reduce(..)` / `<set>.reduceRight(..)`](#setfilter--setmap--setforeach--setreduce--setreduceright)
   - [`Date`](#date)
     - [`Date.timeStamp(..)`](#datetimestamp)
     - [`Date.fromTimeStamp(..)`](#datefromtimestamp)
@@ -75,6 +77,7 @@ Library of JavaScript type extensions, types and utilities.
       - [`<promise>.iter()`](#promiseiter)
       - [`<promise-iter>.iter()`](#promise-iteriter)
       - [`<promise-iter>.map(..)` / `<promise-iter>.filter(..)` / `<promise-iter>.reduce(..)`](#promise-itermap--promise-iterfilter--promise-iterreduce)
+    - [`<promise-iter>.between(..)`](#promise-iterbetween)
       - [`<promise-iter>.flat(..)`](#promise-iterflat)
       - [`<promise-iter>.reverse()`](#promise-iterreverse)
       - [`<promise-iter>.concat(..)`](#promise-iterconcat)
@@ -100,7 +103,8 @@ Library of JavaScript type extensions, types and utilities.
       - [`<generator>.iter(..)`](#generatoriter-1)
       - [`<generator>.map(..)` / `<generator>.filter(..)`](#generatormap--generatorfilter)
       - [`<generator>.reduce(..)` / `<generator>.greduce(..)`](#generatorreduce--generatorgreduce)
-      - [`<generator>.forEach(..)`](#generatorforeach)
+      - [`<generator>.forEach(..)` (EXPERIMENTAL)](#generatorforeach-experimental)
+      - [`<generator>.between(..)`](#generatorbetween)
       - [`<generator>.slice(..)`](#generatorslice)
       - [`<generator>.at(..)` / `<generator>.gat(..)`](#generatorat--generatorgat)
       - [`<generator>.flat(..)`](#generatorflat)
@@ -117,6 +121,7 @@ Library of JavaScript type extensions, types and utilities.
       - [`<generator>.unshift(..)` / `<generator>.push(..)`](#generatorunshift--generatorpush-1)
       - [`<Generator>.slice(..)`](#generatorslice-1)
       - [`<Generator>.map(..)` / `<Generator>.filter(..)` / `<Generator>.reduce(..)` / `<Generator>.flat()`](#generatormap--generatorfilter--generatorreduce--generatorflat)
+      - [`<Generator>.between(..)`](#generatorbetween-1)
       - [`<Generator>.toArray()`](#generatortoarray-1)
       - [`<Generator>.join(..)`](#generatorjoin-1)
       - [`<Generator>.then(..)` / `<Generator>.catch(..)` / `<Generator>.finally(..)`](#generatorthen--generatorcatch--generatorfinally-1)
@@ -737,6 +742,19 @@ Return an iterator/generator from the current array.
 This is mostly useful in combination with the [Generator extensions and utilities](#generator-extensions-and-utilities)
 
 
+### `<array>.between(..)`
+
+```bnf
+<array>.between(<value>)
+    -> <array>
+<array>.between(<func>)
+    -> <array>
+
+<func>([<pre>, <post>], <index-in>, <index-out>, <array>)
+    -> <value>
+```
+
+
 ### Abortable `Array` iteration
 
 A an alternative to `Array`'s `.map(..)` / `.filter(..)` / .. methods with ability to
@@ -1077,6 +1095,12 @@ This is similar to [`<map>.sort(..)`](#mapsort) and [`Object.sort(..)`](#objects
 see the later for more info.
 
 
+### `<set>.filter(..)` / `<set>.map(..)` / `<set>.forEach(..)` / `<set>.reduce(..)` / `<set>.reduceRight(..)`
+
+For more info see corresponding stoppable methods in 
+[`Array`'s section](#arraysmap--arraysfilter--arraysreduce--arraysforeach).
+
+
 
 ## `Date`
 
@@ -1563,6 +1587,14 @@ in how they process values:
   appropriate method on the result.
   <!-- XXX list + mark definitions as "(proxy)" -->
 
+Promise iterators directly support _for-await-of_ iteration:
+
+```javascript
+for await (var elem of Promise.iter(/* ... */)){
+    // ...
+}
+```
+
 <!-- 
 XXX should we support generators as input?
     ...not sure about the control flow direction here, on one hand the generator
@@ -1658,6 +1690,19 @@ Note that since `.reduce(..)` handler's execution order can not be known,
 there is no point in implementing `.reduceRigth(..)`.
 
 
+### `<promise-iter>.between(..)`
+
+```bnf
+<promise-iter>.between(<value>)
+    -> <promise-iter>
+<promise-iter>.between(<func>)
+    -> <promise-iter>
+
+<func>([<pre>, <post>], <index-in>, <index-out>, <promise-iter>)
+    -> <value>
+```
+
+
 #### `<promise-iter>.flat(..)`
 
 ```bnf
@@ -2136,7 +2181,7 @@ XXX .reduce(..) can return a non-iterable -- test and document this case...
     ...compare with Array.prototype.reduce(..)
 -->
 
-#### `<generator>.forEach(..)`
+#### `<generator>.forEach(..)` (EXPERIMENTAL)
 
 ```bnf
 <generator>.forEach(<func>)
@@ -2145,7 +2190,21 @@ XXX .reduce(..) can return a non-iterable -- test and document this case...
 
 This is different from the above in that this will unwind the `<generator>`.
 
-Note that this differs from `<array>.forEach(..)` in that his will return the resulting array, essentially behaving like `.map(..)`.
+Note that this differs from `<array>.forEach(..)` in that his will return the 
+resulting array, essentially behaving like `.map(..)`.
+
+
+#### `<generator>.between(..)`
+
+```bnf
+<generator>.between(<value>)
+    -> <generator>
+<generator>.between(<func>)
+    -> <generator>
+
+<func>([<pre>, <post>], <index-in>, <index-out>, <generator>)
+    -> <value>
+```
 
 
 #### `<generator>.slice(..)`
@@ -2428,6 +2487,19 @@ but return a `<Generator>`.
 <!-- XXX -->
 
 
+#### `<Generator>.between(..)`
+
+```bnf
+<Generator>.between(<value>)
+    -> <Generator>
+<Generator>.between(<func>)
+    -> <Generator>
+
+<func>([<pre>, <post>], <index-in>, <index-out>, <Generator>)
+    -> <value>
+```
+
+
 #### `<Generator>.toArray()`
 
 Return a function that will return a `<generator>` output as an `Array`.

package/Set.js

@@ -8,11 +8,29 @@
 /*********************************************************************/
 
 var object = require('ig-object')
+var stoppable = require('ig-stoppable')
 
 
 
 /*********************************************************************/
 
+// Wrap .map(..) / .filter(..) / .reduce(..) / .. to support STOP...
+// 
+// NOTE: internally these are implemented as for-of loops (./generator.js)
+var stoppableSet = function(iter){
+	return function(func){
+		return new Set([...this][iter](...arguments)) } }
+var stoppableValue = function(iter, no_return=false){
+	return function(func){
+		var res = [...this][iter](...arguments) 
+		return no_return ?
+			undefined
+			: res } }
+
+
+
+//---------------------------------------------------------------------
+
 var SetProtoMixin =
 module.SetProtoMixin =
 object.Mixin('SetMixin', 'soft', {
@@ -110,6 +128,12 @@ object.Mixin('SetMixin', 'soft', {
 		this.sort(order) 
 
 		return removed },
+
+	filter: stoppableSet('filter'),
+	map: stoppableSet('map'),
+	reduce: stoppableValue('reduce'),
+	reduceRight: stoppableValue('reduceRight'),
+	forEach: stoppableValue('map', true),
 })
 
 

package/generator.js

@@ -223,7 +223,10 @@ object.Mixin('GeneratorMixin', 'soft', {
 	reduce: makeGenerator('reduce'),
 	reduceRight: makeGenerator('reduceRight'),
 
-	// XXX add .toString(..) ???
+	between: makeGenerator('between'),
+
+	// XXX EXPERIMENTAL
+	// XXX add .toString(..) to this???
 	forEach: function(func){
 		var that = this
 		return function(){
@@ -403,9 +406,23 @@ object.Mixin('GeneratorProtoMixin', 'soft', {
 	greduce: function*(func, res){
 		yield this.reduce(...arguments) },
 
+	between: stoppable(function*(func){
+		var i = 0
+		var j = 0
+		var prev
+		for(var e of this){
+			if(i > 0){
+				yield typeof(func) == 'function' ?
+					func.call(this, [prev, e], i-1, i + j++, this)
+					: func }
+			prev = e
+			yield e
+			i++ } }),
+
 	// NOTE: this is a special case in that it will unwind the generator...
 	// NOTE: this is different from <array>.forEach(..) in that this will
 	// 		return the resulting array.
+	// XXX EXPERIMENTAL
 	forEach: function(func){
 		return [...this].map(func) },
 
@@ -502,6 +519,9 @@ object.Mixin('AsyncGeneratorMixin', 'soft', {
 	map: makeGenerator('async', 'map'),
 	filter: makeGenerator('async', 'filter'),
 	reduce: makeGenerator('async', 'reduce'),
+
+	// XXX TEST...
+	between: makeGenerator('async', 'between'),
 })
 
 var AsyncGeneratorProtoMixin =
@@ -559,6 +579,21 @@ object.Mixin('AsyncGeneratorProtoMixin', 'soft', {
 			return [] })
 		return state },
 
+	// XXX BETWEEN...
+	between: async function*(func){
+		var i = 0
+		var j = 0
+		var prev
+		yield* this.iter(function(e){
+			return i++ > 0 ?
+				[
+					typeof(func) == 'function' ?
+						func.call(this, [prev, e], i, i + j++, this)
+						: func,	
+					e,
+				]
+				: [e] }) },
+
 	// XXX TEST...
 	chain: async function*(...next){
 		yield* next

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ig-types",
-  "version": "6.16.4",
+  "version": "6.19.0",
   "description": "Generic JavaScript types and type extensions...",
   "main": "main.js",
   "scripts": {