ig-types 6.24.13 → 6.24.15

package/Promise.js

@@ -306,18 +306,6 @@ object.Constructor('IterablePromise', Promise, {
 			: list },
 	// transform/handle packed array (sync, but can return promises in the list)...
 	// XXX need a strict spec...
-	// XXX BUG???
-	// 			await Promise.iter([
-	// 						Promise.sync.resolve([1,1,1]), 
-	// 						[2,2,2], 
-	// 						Promise.resolve([3,3,3]), 
-	// 						Promise.iter([4,4,4]), 
-	// 						Promise.all([5,5,5]),
-	// 					], 
-	// 					e => e instanceof Array ? [[1,2,3]] : e)
-	// 				-> [ 1, 2, 3, [ 1, 2, 3 ], [ 1, 2, 3 ], [ 1, 2, 3 ], [ 1, 2, 3 ] ]
-	// 		...the fist result seems odd...
-	// 		XXX FIXED but need to add a test for IterablePromise branch below...
 	__handle: function(list, handler=undefined, onerror=undefined){
 		var that = this
 		if(typeof(list) == 'function'){
@@ -337,40 +325,40 @@ object.Constructor('IterablePromise', Promise, {
 			'smap'
 			: 'map'
 		var stop = false
-		var unwrap = function(elem){
-			return elem.length == 1 ?
-				elem[0]
-				: elem }
+		// XXX do we handle generators here???
+		var each = function(elem){
+			return elem instanceof Array ?
+				elem
+					.map(handler)
+					.flat()
+				: handler(elem) }
 		return list
 			[map](
 				function(elem){
+					// NOTE: we are calling .flat() on the result so we 
+					// 		need to keep a handled array as a single 
+					// 		element by wrapping the return of handled(..)...
 					return elem instanceof IterablePromise ?
-							// XXX should elem be expanded??? (like Array below)
 							(elem.isSync() ?
-								handler(elem.sync())
-								// XXX need to handle this but keep it IterablePromise...
-								: elem.iterthen(handler))
+								each(elem.sync())
+								: elem.iterthen(each))
 						// sync sync promise...
 						: (elem instanceof SyncPromise
 								&& !(elem.sync() instanceof Promise)) ?
-							[handler(unwrap(elem.sync()))]
+							[each(elem.sync())]
 						// promise / promise-like...
 						: elem && elem.then ?
 							// NOTE: when this is explicitly stopped we 
 							// 		do not call any more handlers after 
 							// 		STOP is thrown/returned...
-							// XXX TEST!!!
+							// NOTE: the promise protects this from .flat()
 							elem.then(function(elem){
 								return !stop ?
-									handler(unwrap(elem))
+									each(elem)
 									: [] })
 						: elem instanceof Array ?
-							// NOTE: we are calling .flat() on the result
-							// 		so we need to keep a handled array as 
-							// 		a single element by wrapping the return 
-							// 		of handled(..)...
-							[handler(unwrap(elem))]
-						: handler(elem) },
+							[each(elem)]
+						: each(elem) },
 				// handle STOP...
 				function(){
 					stop = true })
@@ -772,7 +760,8 @@ object.Constructor('IterablePromise', Promise, {
 		// instance...
 		var promise
 		var obj = Reflect.construct(
-			IterablePromise.__proto__, 
+			Promise,
+			//this.constructor.__proto__,
 			[function(resolve, reject){
 				// NOTE: this is here for Promise compatibility...
 				if(typeof(list) == 'function'){
@@ -781,13 +770,14 @@ object.Constructor('IterablePromise', Promise, {
 				if(list === false){
 					return reject() }
 				promise = {resolve, reject} }], 
-			IterablePromise)
+			this.constructor)
 
 		// populate new instance...
 		if(promise){
 			// handle/pack input data...
 			if(handler != 'raw'){
-				list = list instanceof IterablePromise ?
+				//list = list instanceof IterablePromise ?
+				list = list instanceof this.constructor ?
 					obj.__handle(list.__packed, handler, onerror)
 					: obj.__pack(list, handler, onerror) }
 			Object.defineProperty(obj, '__packed', {
@@ -827,53 +817,75 @@ object.Constructor('IterablePromise', Promise, {
 //---------------------------------------------------------------------
 // XXX EXPEREMENTAL/HACK...
 
-// XXX we are getting a list with promises triggered outside, we can't
-// 		control order of execution of this but we can control in what 
-// 		order the handler is called...
-// XXX this potentially shows a bug with IterablePromise:
-// 			Promise.seqiter(
-// 				[1, Promise.resolve(2), 3, Promise.resolve(4)], 
-// 				e => (console.log('---', e), e))
-// 		...this will not resolve/replace the 4's promise...
-// 		for context:
-// 			await Promise.resolve(Promise.resolve(Promise.resolve(123)))
-// 				-> 123
-// 		...is this just a nesting issue here???
-// 		Q: what IterablePromise does/should do if a promise resolves to 
-// 			a promise multiple times...
+// This like IterablePromise but guarantees handler execution in order 
+// element occurrence.
+//
+// For comparison:
+// 		Promise.all([ .. ]).then(func)
+// 			- func is called on element list
+// 			- func is called when all the elements are resolved
+// 		Promise.iter([ .. ]).iter(func)
+// 			- func per element
+// 			- func is called when an element is resolved/ready 
+// 				in any order
+// 		Promise.seqiter([ .. ]).iter(func)
+// 			- func per element
+// 			- func is called when an element is resolved/ready 
+// 				and when all elements before it are handled
+//
+// NOTE: that here a promise will block handling of later promises even 
+// 		if they are resolved before it.
+//
+// XXX BUG:
+// 			await Promise.seqiter([
+// 						1,
+// 						Promise.resolve(2), 
+// 						Promise.resolve(3)
+// 						Promise.resolve(4)
+// 						Promise.resolve(5)
+// 					])
+// 				-> [ 1, 2, [3], [[4]], [[[5]]] ]
+// 		looks like we need to flatten things...
+// 		XXX FIXED but need more testing...
 // XXX not sure if this is a viable strategy....
 var IterableSequentialPromise =
 module.IterableSequentialPromise =
 object.Constructor('IterableSequentialPromise', IterablePromise, {
-	__new__: function(_, list, handler=undefined, onerror=undefined){
-		var [_, list, ...rest] = arguments
-		var res = list
-		// format the list...
-		if(list instanceof Array 
-				|| list instanceof Promise){
-
-			var pre_process = function(list, start=0){
-				if(list instanceof Promise){
-					return list.then(pre_process) }
-				res = []
-				for(let [i, e] of list.entries().slice(start)){
-					if(e instanceof Promise){
-						res.push(e.then(function(e){
-							return [e,
-								// XXX need to flatten this...
-								...pre_process(list, i+1)] })) 
-						break }
-					res.push(e) } 
-				return res }
-			
-			res = pre_process(list)
-				
-			var obj = IterablePromise.prototype.__new__.call(this, _, res, 'raw')
-
-			return obj
-		}
-		// XXX use .parentCall(..)...
-		return IterablePromise.prototype.__new__.call(this, _, res, ...rest) },
+	// XXX needs more work...
+	__pack: function(list, handler=undefined, onerror=undefined){
+		var seqiter = this.constructor
+
+		var repack = function(list){
+			var res = []
+			for(var [i, e] of list.entries()){
+				// XXX check for .then(..) instead???
+				if(e instanceof Promise 
+						// skip last promise -- nothing to wrap...
+						&& i < list.length-1){
+					res.push(e
+						.then(function(e){ 
+							return seqiter([...e, ...list.slice(i+1)])
+								.flat() }))
+					break }
+				res.push(e) }
+			return res }
+
+		// NOTE: we are not handling the list here...
+		list = object.parentCall(IterableSequentialPromise.prototype.__pack, this, list) 
+		list = list instanceof SyncPromise ?
+			list.sync()
+			: list
+		list = list instanceof Array ?
+				repack(list)
+			// XXX check for .then(..) instead???
+			: list instanceof Promise ?
+				list.then(repack)
+			: list 
+
+		return handler ?
+			// XXX this seems to be wrong...
+			this.__handle(list, handler, onerror)
+			: list },
 })
 
 

package/package.json

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

package/test.js

@@ -267,13 +267,14 @@ var cases = test.Cases({
 				'promises as elements')
 
 		// XXX need a recursive assert...
-		var should_be = [ [1], [2], [3], [4], [5] ]
+		var should_be = [ [1], [2], [3], [4], [5], [6] ]
 		var got = await Promise.iter([
 				[1,1,1], 
 				Promise.sync.resolve([2,2,2]), 
 				Promise.resolve([3,3,3]), 
 				Promise.iter([4,4,4]), 
-				Promise.all([5,5,5]),
+				Promise.iter.resolve([5,5,5]), 
+				Promise.all([6,6,6]),
 			], 
 			function(e){
 				return e instanceof Array ? 
@@ -290,7 +291,7 @@ var cases = test.Cases({
 						&& got[i] instanceof Array
 						&& e.length == got[i].length
 						&& e[0] == got[i][0] }, true), 
-			'pack/unpack')
+			'pack/unpack:', got)
 	},
 
 	// Date.js