ig-types 6.16.3 → 6.18.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)
@@ -75,6 +76,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,6 +102,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(..)` (EXPERIMENTAL)](#generatorforeach-experimental)
+      - [`<generator>.between(..)`](#generatorbetween)
       - [`<generator>.slice(..)`](#generatorslice)
       - [`<generator>.at(..)` / `<generator>.gat(..)`](#generatorat--generatorgat)
       - [`<generator>.flat(..)`](#generatorflat)
@@ -116,6 +120,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)
@@ -736,6 +741,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
@@ -1562,6 +1580,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
@@ -1657,6 +1683,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
@@ -2135,6 +2174,31 @@ XXX .reduce(..) can return a non-iterable -- test and document this case...
     ...compare with Array.prototype.reduce(..)
 -->
 
+#### `<generator>.forEach(..)` (EXPERIMENTAL)
+
+```bnf
+<generator>.forEach(<func>)
+    -> <array>
+```
+
+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(..)`.
+
+
+#### `<generator>.between(..)`
+
+```bnf
+<generator>.between(<value>)
+    -> <generator>
+<generator>.between(<func>)
+    -> <generator>
+
+<func>([<pre>, <post>], <index-in>, <index-out>, <generator>)
+    -> <value>
+```
+
 
 #### `<generator>.slice(..)`
 
@@ -2416,6 +2480,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/generator.js

@@ -223,6 +223,15 @@ object.Mixin('GeneratorMixin', 'soft', {
 	reduce: makeGenerator('reduce'),
 	reduceRight: makeGenerator('reduceRight'),
 
+	between: makeGenerator('between'),
+
+	// XXX EXPERIMENTAL
+	// XXX add .toString(..) to this???
+	forEach: function(func){
+		var that = this
+		return function(){
+			return that(...arguments).forEach(func) } },
+
 	// non-generators...
 	//
 	toArray: function(){
@@ -397,6 +406,26 @@ 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) },
+
 	pop: function(){
 		return [...this].pop() },
 	// XXX this needs the value to be iterable...
@@ -490,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 =
@@ -547,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.3",
+  "version": "6.18.0",
   "description": "Generic JavaScript types and type extensions...",
   "main": "main.js",
   "scripts": {