ig-types 6.24.9 → 6.24.12

package/Array.js

@@ -524,19 +524,27 @@ object.Mixin('ArrayProtoMixin', 'soft', {
 	// XXX this should handle throwing STOP!!!
 	// 		...might also ne a good idea to isolate the STOP mechanics 
 	// 		into a spearate module/package...
-	iter: stoppable(function*(handler=undefined){
-		if(handler){
-			var i = 0
-			for(var e of this){
-				var res = handler.call(this, e, i++) 
-				// treat non-iterables as single elements...
-				if(typeof(res) == 'object' 
-						&& Symbol.iterator in res){
-					yield* res
-				} else {
-					yield res } } 
-		} else {
-			yield* this }}),
+	iter: stoppable(
+		function*(handler=undefined, onstop){
+			if(handler){
+				var i = 0
+				for(var e of this){
+					var res = handler.call(this, e, i++) 
+					// treat non-iterables as single elements...
+					if(typeof(res) == 'object' 
+							&& Symbol.iterator in res){
+						yield* res
+					} else {
+						yield res } } 
+			} else {
+				yield* this }},
+		// handle stops is onstop(..) is defined...
+		function(res, _, onstop){
+			typeof(onstop) == 'function'
+				&& onstop.call(this, 
+					...(res === STOP ? 
+						[] 
+						: [res])) }),
 
 
 	// Stoppable iteration...

package/Promise.js

@@ -124,6 +124,7 @@ object.Constructor('IterablePromise', Promise, {
 	// 		handlers in sequence.
 	// 		XXX EXPEREMENTAL: STOP...
 	// XXX ITER can we unwind (sync/async) generators one by one???
+	/* XXX this repeats part of the functionality of .__handle(..)
 	__pack: function(list, handler=undefined, onerror=undefined){
 		var that = this
 		// handle iterator...
@@ -167,8 +168,7 @@ object.Constructor('IterablePromise', Promise, {
 		handler = handler 
 			?? function(elem){ 
 				return [elem] }
-
-		//* XXX EXPEREMENTAL: STOP...
+		// XXX this repeats .__handle(..), need to unify...
 		var stop = false
 		var map = 'map'
 		var pack = function(){
@@ -205,7 +205,6 @@ object.Constructor('IterablePromise', Promise, {
 						: !handle ?
 							elem
 						: handler(elem) }) }
-
 		// pack (stoppable)...
 		if(!!this.constructor.STOP){
 			map = 'smap'
@@ -225,21 +224,7 @@ object.Constructor('IterablePromise', Promise, {
 
 		// pack (non-stoppable)...
 		return pack() },
-		/*/
-		return [list].flat()
-			.map(function(elem){
-				return elem && elem.then ?
-						//that.__pack(elem, handler)
-						elem.then(handler)
-					: elem instanceof Array ?
-						handler(elem)
-					// NOTE: we keep things that do not need protecting 
-					// 		from .flat() as-is...
-					: !handle ?
-						elem
-					: handler(elem) }) },
-		//*/
-	// transform/handle packed array (sync)...
+	// transform/handle packed array (sync, but can return promises in the list)...
 	__handle: function(list, handler=undefined, onerror=undefined){
 		var that = this
 		if(typeof(list) == 'function'){
@@ -255,24 +240,126 @@ object.Constructor('IterablePromise', Promise, {
 		// NOTE: since each section of the packed .__array is the same 
 		// 		structure as the input we'll use .__pack(..) to handle 
 		// 		them, this also keeps all the handling code in one place.
-		//* XXX EXPEREMENTAL: STOP...
 		var map = !!this.constructor.STOP ?
 			'smap'
 			: 'map'
 		return list[map](function(elem){
-		/*/
-		return list.map(function(elem){
-		//*/
-			return elem instanceof Array ?
+				elem = elem instanceof Array 
+						|| elem instanceof Promise ?
 					that.__pack(elem, handler, onerror)
-				: elem instanceof Promise ?
-					that.__pack(elem, handler, onerror)
-						//.then(function(elem){
-						.then(function([elem]){
-							return elem })
-				: [handler(elem)] })
+					: [handler(elem)]
+				elem = elem instanceof Promise ?
+					elem.then(function([e]){
+						return e })
+					: elem
+				return elem })
    			.flat() },
-	// XXX EXPEREMENTAL...
+	/*/
+	__pack: function(list, handler=undefined, onerror=undefined){
+		var that = this
+		// handle iterator...
+		// XXX ITER do we unwind the iterator here or wait to unwind later???
+		if(typeof(list) == 'object' 
+				&& Symbol.iterator in list){
+			if(!onerror){
+				list = [...list]
+			// handle errors in input generator...
+			// NOTE: this does not offer the most control because semantically 
+			// 		we bust behave in the same manner as <generator>.iter(..)
+			} else {
+				var res = []
+				try{
+					for(var e of list){
+						res.push(e) }
+				}catch(err){
+					var r = onerror(err)
+					r !== undefined
+						&& res.push(r) } 
+				list = res } } 
+		// handle iterable promise...
+		if(list instanceof IterablePromise){
+			return this.__handle(list.__packed, handler, onerror) }
+		// handle promise / async-iterator...
+		// XXX ITER do we unwind the iterator here or wait to unwind later???
+		if(typeof(list) == 'object' 
+					&& Symbol.asyncIterator in list){
+			return list
+				.iter(handler, onerror) 
+				.then(function(list){
+					return that.__pack(list) }) } 
+		if(list instanceof Promise){
+			return list
+				.then(function(list){
+					return that.__pack(list, handler, onerror) }) }
+		// pack...
+		list = [list].flat()
+			.map(function(elem){
+				return elem instanceof Array ?
+						[elem]
+					: elem instanceof Promise ?
+						elem.then(function(e){
+							return [e] })
+					: elem })
+		// handle if needed...
+		return handler ?
+			this.__handle(list, handler, onerror)
+			: list },
+	// transform/handle packed array (sync, but can return promises in the list)...
+	// XXX need a strict spec...
+	__handle: function(list, handler=undefined, onerror=undefined){
+		var that = this
+		if(typeof(list) == 'function'){
+			handler = list
+			list = this.__packed }
+		if(!handler){
+			return list }
+		// handle promise list...
+		if(list instanceof Promise){
+			return list.then(function(list){
+				return that.__handle(list, handler, onerror) }) }
+		// do the work...
+		list = list instanceof Array ?
+			list
+			: [list]
+		var map = !!this.constructor.STOP ?
+			'smap'
+			: 'map'
+		var stop = false
+		return list
+			[map](
+				function(elem){
+					return elem instanceof IterablePromise ?
+							// XXX should this be expanded??? (like Array below)
+							(elem.isSync() ?
+								handler(elem.sync())
+								// XXX need to handle this but keep it IterablePromise...
+								: elem.iterthen(handler))
+						: (elem instanceof SyncPromise
+								&& !(elem.sync() instanceof Promise)) ?
+							// XXX should this be expanded??? (like Array below)
+							handler(elem.sync())
+						// promise / promise-like...
+						: elem && elem.then ?
+							// NOTE: when this is explicitly stopped we 
+							// 		do not call any more handlers...
+							// XXX TEST!!!
+							elem.then(function(elem){
+								return !stop ?
+									handler(
+										elem.length == 1 ?
+											elem[0]
+											:elem) 
+									: [] })
+						: elem instanceof Array ?
+							[handler(
+								elem.length == 1 ?
+									elem[0]
+									: elem)]
+						: handler(elem) },
+				function(res){
+					stop = true })
+   			.flat() },
+	//*/
 	// XXX this should return IterablePromise if .__packed is partially sync (???)
 	// unpack array (sync/async)...
 	__unpack: function(list){
@@ -293,30 +380,13 @@ object.Constructor('IterablePromise', Promise, {
 			// give up on a sync solution...
 			if(e instanceof Promise){
 				// XXX can we return an IterablePromise???
-				// XXX this will cause infinite recursion....
-				//return Promise.iter(list).flat() }
 				// XXX is there a more elegant way to do this???
 				return Promise.all(list)
 					.then(function(list){ 
 						return list.flat() })
 					.iter() }
-				//return Promise.all(list)
-				//	.then(function(list){ 
-				//		return list.flat() }) }
 			res.push(e) }
 		return res.flat() },
-	/*/
-	// unpack array (async)...
-	__unpack: async function(list){
-		list = list 
-			?? this.__packed
-		// handle promise list...
-		return list instanceof Promise ?
-			this.__unpack(await list)
-			// do the work...
-			: (await Promise.all(list))
-				.flat() },
-	//*/
 	
 	[Symbol.asyncIterator]: async function*(){
 		var list = this.__packed
@@ -738,6 +808,60 @@ 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...
+// 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) },
+})
+
+
+
 //---------------------------------------------------------------------
 // Interactive promise...
 // 
@@ -1044,41 +1168,52 @@ var PromiseMixin =
 module.PromiseMixin =
 object.Mixin('PromiseMixin', 'soft', {
 	iter: IterablePromise,
+	// XXX
+	seqiter: IterableSequentialPromise,
+
 	interactive: InteractivePromise,
 	cooperative: CooperativePromise,
+
 	sync: SyncPromise,
+
 	// XXX should this be implemented via SyncPromise??? 
+	// XXX not sure if we need to expand async generators...
+	// 		(update README if this changes)
 	awaitOrRun: function(data, func, error){
 		data = [...arguments]
 		func = data.pop()
 		if(typeof(data.at(-1)) == 'function'){
 			error = func
 			func = data.pop() }
-		// ceck if we need to await...
-		return data
-				.reduce(function(res, e){
+		error = error ? 
+			[error] 
+			: []
+		// check if we need to await...
+		return data.reduce(function(res, e){
 					return res 
 						|| e instanceof Promise }, false) ?
-			// NOTE: we will not reach this on empty data...
-			(data.length > 1 ?
-				Promise.all(data)
-					.then(
-						function(res){ 
-							return func(...res) }, 
-						...(error ? 
-							[error] 
-							: []))
-				: data[0].then(
-					func, 
-					...(error ? 
-						[error] 
-						: [])))
-			: error ?
+				// NOTE: we will not reach this on empty data...
+				(data.length > 1 ?
+					Promise.all(data)
+						.then(
+							function(res){ 
+								return func(...res) }, 
+							...error)
+					: data[0].then(func, ...error))
+			// XXX not sure if we need to expand async generators...
+			// 		...since it has .then(..) it can be treated as a promise...
+			// XXX should we just check for .then(..) ???
+			// XXX update README if this changes...
+			: (data.length == 1 
+					&& Symbol.asyncIterator in data[0]
+					&& 'then' in data[0]) ?
+				data[0].then(func, ...error)
+			: error.length > 0 ?
 				function(){
 					try{
 						return func(...data)
 					}catch(err){
-						return error(err) } }()
+						return error[0](err) } }()
 			: func(...data) },
 })
 
@@ -1089,8 +1224,13 @@ var PromiseProtoMixin =
 module.PromiseProtoMixin =
 object.Mixin('PromiseProtoMixin', 'soft', {
 	as: ProxyPromise,
+
 	iter: function(handler=undefined, onerror=undefined){
 		return IterablePromise(this, handler, onerror) },
+	// XXX
+	seqiter: function(handler=undefined, onerror=undefined){
+		return IterableSequentialPromise(this, handler, onerror) },
+
 	// unify the general promise API with other promise types...
 	// XXX should this be here???
 	// XXX error if given must return the result... (???)