ig-types 6.11.0 → 6.11.3

package/Array.js

@@ -492,6 +492,7 @@ object.Mixin('ArrayProtoMixin', 'soft', {
 	smap: stoppableList('map'),
 	sfilter: stoppableList('filter'),
 	sreduce: stoppableValue('reduce'),
+	sreduceRight: stoppableValue('reduceRight'),
 	sforEach: stoppableValue('map', true),
 
 	// Chunk iteration...

package/Promise.js

@@ -80,12 +80,13 @@ object.Constructor('IterablePromise', Promise, {
 	// NOTE: these are different to Array's equivalents in that the handler
 	// 		is called not in the order of the elements but rather in order 
 	// 		of promise resolution...
-	// NOTE: index of items is unknowable because items can expand on 
+	// NOTE: index of items is unknowable because items can expand and
 	// 		contract depending on handlrs (e.g. .filter(..) can remove 
 	// 		items)...
 	// 		This the following can not be implemented here:
 	// 			.slice(..)
 	// 			.splice(..)
+	// 			.values() / .keys()
 	// 			.at(..)
 	// 			[Symbol.iterator]()		- needs to be sync...
 	// 		The followng methods are questionable:
@@ -93,36 +94,65 @@ object.Constructor('IterablePromise', Promise, {
 	// 			.includes(..)
 	// 			.some(..) / .every(..)
 	// 			.sort(..)
+	//
 	// XXX should these support STOP???
 	map: function(func){
-		return this.constructor(this.__list, 
+		return this.constructor(this, 
 			function(e){
 				return [func(e)] }) },
 	filter: function(func){
-		return this.constructor(this.__list, 
+		return this.constructor(this, 
 			function(e){
 				return func(e) ? 
 					[e] 
 					: [] }) },
+	// NOTE: this does not return an iterable promise as we can't know 
+	// 		what the user reduces to...
+	// 		XXX we could look at the initial state though...
+	// NOTE: the items can be handled out of order because the nested 
+	// 		promises can resolve in any order.
+	//		XXX write how to go around this...
+	// NOTE: since order of execution can not be guaranteed there is no
+	// 		point in implementing .reduceRight(..)
 	reduce: function(func, res){
-		return this.constructor(this.__list, 
+		return this.constructor(this, 
 				function(e){
 					res = func(res, e)
 					return [] })
 			.then(function(){ 
 				return res }) },
 	flat: function(depth=1){
-		return this.constructor(this.__list, 
+		return this.constructor(this, 
 			function(e){ 
-				return (e && e.flat) ? 
-					e.flat(depth) 
-					: e }) },
-	// XXX do we need this???
-	//iter: function(){
-	//	return this },
-
-
-	// XXX do we need:
+				return (depth > 1 
+							&& e != null 
+							&& e.flat) ? 
+						e.flat(depth-1) 
+					: depth != 0 ?
+						e
+					: [e] }) },
+	reverse: function(){
+		var lst = this.__list
+		return this.constructor(
+			lst instanceof Promise ?
+				lst.then(function(elems){
+					return elems instanceof Array ?
+						elems.slice()
+							.reverse()
+						: elems })
+			: lst
+				.map(function(elems){
+					return elems instanceof Array ?
+							elems.slice()
+								.reverse()
+						: elems instanceof Promise ?
+							elems.then(function(elems){
+								return elems.reverse() })
+						: elems })
+				.reverse(),
+			'raw') },
+
+	// XXX do we need these?
 	// 			.pop()
 	// 			.shift()
 	// 			.first() / .last()
@@ -182,8 +212,8 @@ object.Constructor('IterablePromise', Promise, {
 	//
 	// Spectial cases usefull for extending this constructor...
 	//
-	//	Clone the iterator...
-	//	Promise.iter([ .. ], false)
+	//	Set raw .__list without any pre-processing...
+	//	Promise.iter([ .. ], 'raw')
 	//		-> iterable-promise
 	//
 	//	Create a rejected iterator...
@@ -204,9 +234,8 @@ object.Constructor('IterablePromise', Promise, {
 	// 		- another issue here is that the stop would happen in order of 
 	// 			execution and not order of elements...
 	__new__: function(_, list, handler){
-		var promise
-
 		// instance...
+		var promise
 		var obj = Reflect.construct(
 			IterablePromise.__proto__, 
 			[function(resolve, reject){
@@ -220,49 +249,47 @@ object.Constructor('IterablePromise', Promise, {
 			IterablePromise)
 
 		if(promise){
-			//var __stop = false
-			// apply handler(..) to the list...
-			//
-			// NOTE: the top level promises are not wrapped in arrays...
-			list =
-				// apply the handler...
-				handler ?
-					// XXX can we handle STOP here???
-					// 		...we will not be able to stop already started 
-					// 		promises...
-					list.map(function(block){
-						//* XXX STOP...
-						return (block instanceof Array ? 
-								block 
-								: [block])
-						/*/
-						// NOTE: we are not using Array's .iter() so as to
-						// 		keep the dependency minimal...
-						return generator.iter(
-								block instanceof Array ? 
-									block 
-									: [block])
-						//*/
-							.map(function(e){
-								// NOTE: we are counting actual expanded 
-								// 		values and not the "blocks"...
-								return (e && e.then && e.catch) ?
-									// promise...
-									e.then(function(v){ 
-										return handler(v) })
-									// basic value...
-									: handler(e) }) })
-						.flat()
-						// XXX STOP
-						//.toArray()
-				// normal constructor...
-				: handler === undefined ?
-					list.map(function(e){ 
-						return e instanceof Promise ?
-							e
-							: [e] })
-				// clone...
-				: list.slice()
+
+			if(handler != 'raw'){
+				handler = handler
+					?? function(e){ 
+						return [e] }
+
+				// NOTE: this is recursive to handle expanding nested promises...
+				var handle = function(elem){
+					// call the handler...
+					return (elem && elem.then) ?
+						//elem.then(function(elem){
+						//	return handler(elem) })
+						elem.then(handler)
+						: handler(elem) }
+
+				// handle the list...
+				// NOTE: we can't .flat() the results here as we need to 
+				// 		wait till all the promises resolve...
+				list =
+					(list instanceof IterablePromise 
+							&& !(list.__list instanceof Promise)) ?
+						// NOTE: this is essentially the same as below but 
+						// 		with a normalized list as input...
+						// 		XXX can we merge the two???
+						list.__list
+							.map(function(elems){
+								return elems instanceof Promise ?
+									elems.then(function(elems){
+										return elems
+											.map(handle) 
+											.flat() })
+									: elems
+										.map(handle)
+										.flat() })
+					: list instanceof Promise ?
+						// special case: promised list...
+						list.then(function(list){
+							return [list].flat()
+								.map(handle) })	
+					: [list].flat()
+						.map(handle) }
 
 			Object.defineProperty(obj, '__list', {
 				value: list,
@@ -270,9 +297,14 @@ object.Constructor('IterablePromise', Promise, {
 			})
 
 			// handle promise state...
-			Promise.all(list)
+			;(list instanceof Promise ?
+					// special case: promised list...
+					list
+					: Promise.all([list].flat()))
 				.then(function(res){
-					promise.resolve(res.flat()) })
+					promise.resolve(handler ?
+						res.flat()
+						: res) })
 				.catch(promise.reject) }
 
 		return obj },
@@ -417,6 +449,7 @@ object.Constructor('CooperativePromise', Promise, {
 
 //---------------------------------------------------------------------
 
+// XXX EXPEREMENTAL...
 var ProxyPromise =
 module.ProxyPromise =
 object.Constructor('ProxyPromise', Promise, {
@@ -461,14 +494,6 @@ object.Constructor('ProxyPromise', Promise, {
 
 //---------------------------------------------------------------------
 
-// XXX EXPEREMENTAL...
-var PromiseProtoMixin =
-module.PromiseProtoMixin =
-object.Mixin('PromiseProtoMixin', 'soft', {
-	as: ProxyPromise,
-})
-
-
 var PromiseMixin =
 module.PromiseMixin =
 object.Mixin('PromiseMixin', 'soft', {
@@ -479,7 +504,18 @@ object.Mixin('PromiseMixin', 'soft', {
 
 PromiseMixin(Promise)
 
+
 // XXX EXPEREMENTAL...
+var PromiseProtoMixin =
+module.PromiseProtoMixin =
+object.Mixin('PromiseProtoMixin', 'soft', {
+	as: ProxyPromise,
+
+	// XXX
+	iter: function(){
+		return IterablePromise(this) },
+})
+
 PromiseProtoMixin(Promise.prototype)
 
 

package/README.md

@@ -70,8 +70,11 @@ Library of JavaScript type extensions, types and utilities.
       - [`<promise-coop>.then(..)`](#promise-coopthen)
     - [Promise iteration](#promise-iteration)
       - [`Promise.iter(..)` / `promise.IterablePromise(..)`](#promiseiter--promiseiterablepromise)
+      - [`<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>.flat(..)`](#promise-iterflat)
+      - [`<promise-iter>.reverse()`](#promise-iterreverse)
       - [`<promise-iter>.then(..)` / `<promise-iter>.catch(..)` / `<promise-iter>.finally(..)`](#promise-iterthen--promise-itercatch--promise-iterfinally)
       - [Advanced handler](#advanced-handler)
     - [Promise proxies](#promise-proxies)
@@ -1452,8 +1455,8 @@ promise, and it is similar to a _generator_ in that it allows iteration over the
 contained values and chaining of operations but unlike `Promise.all(..)` this 
 iteration occurs depth-first instead of breadth first.
 
-Essentially one can think of _promise iterators_ vs. _generators_ as the former
-being internally controlled and asynchronous while the later being externally
+One can think of _promise iterators_ vs. _generators_ as the former being 
+internally controlled and asynchronous while the later being externally
 controlled and synchronous.
 
 Here is a traditional example using `Promise.all(..)`:
@@ -1515,8 +1518,32 @@ XXX should we support infinite generators as input?
 #### `Promise.iter(..)` / `promise.IterablePromise(..)`
 
 Create an _iterable promise_
+
 ```bnf
 Promise.iter(<array>)
+Promise.iter(<promise>)
+    -> <promise-iter>
+```
+
+#### `<promise>.iter()`
+
+Wrap a promise in an promise iterator. 
+
+```bnf
+<promise>.iter()
+    -> <promise-iter>
+```
+
+If `<promise>` resolves to a non-array value it will be treated as a single 
+element, otherwise the array will be iterated over.
+
+
+#### `<promise-iter>.iter()`
+
+Return a shallow copy of the current promise iterator.
+
+```bnf
+<promise-iter>.iter()
     -> <promise-iter>
 ```
 
@@ -1545,7 +1572,7 @@ and [`.reduce(..)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Refe
 
 ```bnf
 <promise-iter>.reduce(<handler>, <state>)
-    -> <promise-iter>
+    -> <promise>
 
 <handler>(<state>, <elem>)
     -> <state>
@@ -1558,6 +1585,15 @@ Note that these are different to `Array`'s equivalents in some details:
     this is because the index with _out-of-order_ and _depth-first_ execution the 
     index is unknowable and the container is a promise/black-box.
 
+This is especially critical for `.reduce(..)` as iteration in an order different 
+from the order of elements _can_ affect actual result if this is not expected.
+
+`.reduce(..)` is also a bit different here in that it will return a basic 
+`<promise>` object as we can't know what will it will reduce to.
+
+Note that since `.reduce(..)` order can not be guaranteed there is no point 
+in implementing `.reduceRigth(..)`.
+
 
 #### `<promise-iter>.flat(..)`
 
@@ -1570,6 +1606,16 @@ Note that these are different to `Array`'s equivalents in some details:
 This is similar to [`<array>.flat(..)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flat) see it for more info.
 
 
+#### `<promise-iter>.reverse()`
+
+```bnf
+<promise-iter>.reverse()
+    -> <promise-iter>
+```
+
+This is similar to [`<array>.reverse(..)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse) see it for more info.
+
+
 #### `<promise-iter>.then(..)` / `<promise-iter>.catch(..)` / `<promise-iter>.finally(..)`
 
 An extension to

package/RegExp.js

@@ -64,7 +64,8 @@ object.Mixin('RegExpProtoMixin', 'soft', {
 
 
 RegExpMixin(RegExp)
-RegExpProtoMixin(RegExp.prototype)
+// XXX EXPEREMENTAL...
+//RegExpProtoMixin(RegExp.prototype)
 
 
 var quoteRegExp =

package/generator.js

@@ -210,6 +210,7 @@ object.Mixin('GeneratorMixin', 'soft', {
 	map: makeGenerator('map'),
 	filter: makeGenerator('filter'),
 	reduce: makeGenerator('reduce'),
+	reduceRight: makeGenerator('reduceRight'),
 
 	// non-generators...
 	//

package/package.json

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