ig-types 6.10.1 → 6.11.2

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 },
@@ -415,6 +447,51 @@ object.Constructor('CooperativePromise', Promise, {
 
 
 
+//---------------------------------------------------------------------
+
+// XXX EXPEREMENTAL...
+var ProxyPromise =
+module.ProxyPromise =
+object.Constructor('ProxyPromise', Promise, {
+	__new__: function(context, constructor){
+		var proto = 'prototype' in constructor ?
+			constructor.prototype
+			: constructor
+		var obj = Reflect.construct(
+			ProxyPromise.__proto__, 
+			[function(resolve, reject){
+				context.then(resolve)
+				context.catch(reject) }], 
+			ProxyPromise) 
+		// populate...
+		// NOTE: we are not using object.deepKeys(..) here as we need 
+		// 		the key origin not to trigger property getters...
+		var seen = new Set()
+		while(proto != null){
+			Object.entries(Object.getOwnPropertyDescriptors(proto))
+				.forEach(function([key, value]){
+					// skip overloaded keys...
+					if(seen.has(key)){
+						return }
+					// skip non-functions...
+					if(typeof(value.value) != 'function'){
+						return }
+					// skip non-enumerable except for Object.prototype.run(..)...
+					if(!(key == 'run' 
+								&& Object.prototype.run === value.value) 
+							&& !value.enumerable){
+						return }
+					// proxy...
+					obj[key] = function(...args){
+						// XXX should we also .catch(..) here???
+						return context.then(function(res){
+							return res[key](...args) }) } })
+			proto = proto.__proto__ } 
+		return obj },
+})
+
+
+
 //---------------------------------------------------------------------
 
 var PromiseMixin =
@@ -425,10 +502,23 @@ object.Mixin('PromiseMixin', 'soft', {
 	cooperative: CooperativePromise,
 })
 
-
 PromiseMixin(Promise)
 
 
+// XXX EXPEREMENTAL...
+var PromiseProtoMixin =
+module.PromiseProtoMixin =
+object.Mixin('PromiseProtoMixin', 'soft', {
+	as: ProxyPromise,
+
+	// XXX
+	iter: function(){
+		return IterablePromise(this) },
+})
+
+PromiseProtoMixin(Promise.prototype)
+
+
 
 
 /**********************************************************************

package/Promise.js.bak

@@ -0,0 +1,548 @@
+/**********************************************************************
+* 
+*
+*
+*
+* This defines the following extensions to Promise:
+*
+* 	Promise.iter(seq)
+* 		Iterable promise object.
+* 		Similar to Promise.all(..) but adds basic iterator/generator
+* 		API and will resolve the items as they are ready (resolved).
+*
+* 	Promise.interactive(handler)
+* 		Interactive promise object.
+* 		This adds a basic message passing API to the promise.
+*
+* 	Promise.cooperative()
+* 		Cooperative promise object.
+* 		Exposes the API to resolve/reject the promise object 
+* 		externally.
+*
+*
+*
+**********************************************/  /* c8 ignore next 2 */
+((typeof define)[0]=='u'?function(f){module.exports=f(require)}:define)
+(function(require){ var module={} // make module AMD/node compatible...
+/*********************************************************************/
+
+var object = require('ig-object')
+
+// XXX required for STOP...
+//var generator = require('./generator')
+
+
+/*********************************************************************/
+
+/* XXX not used yet...
+// NOTE: this is used in a similar fashion to Python's StopIteration...
+var STOP =
+module.STOP =
+	object.STOP
+//*/
+
+
+//---------------------------------------------------------------------
+// Iterable promise...
+// 
+// Like Promise.all(..) but adds ability to iterate through results
+// via generators .map(..)/.reduce(..) and friends...
+// 
+
+var IterablePromise =
+module.IterablePromise =
+object.Constructor('IterablePromise', Promise, {
+	// XXX
+	//STOP: object.STOP,
+
+	//
+	// Format:
+	// 	[
+	//		[ <value> ],
+	//		<promise>,
+	//		...
+	// 	]
+	//
+	__list: null,
+
+
+	// iterator methods...
+	//
+	// These will return a new IterablePromise instance...
+	//
+	// When called from a resolved promise these will return a new 
+	// resolved promise with updated values...
+	//
+	// When called from a rejected promise these will return a rejected 
+	// with the same reason 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 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:
+	// 			.indexOf(..)
+	// 			.includes(..)
+	// 			.some(..) / .every(..)
+	// 			.sort(..)
+	// XXX BUG:
+	// 			Promise.iter([1,2,3])
+	// 				.map(e => e)
+	// 		is not the same as:
+	// 			Promise.iter([1,2,3])
+	// 				.map(e => e)
+	// 				.map(e => e)
+	// XXX should these support STOP???
+	map: function(func){
+		return this.constructor(this.__list.flat(), 
+			function(e){
+				return [func(e)] }) },
+	filter: function(func){
+		return this.constructor(this.__list.flat(), 
+			function(e){
+				return func(e) ? 
+					[e] 
+					: [] }) },
+	// NOTE: this does not return an iterable promise as we can't know 
+	// 		what the user reduces to...
+	// 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.flat(), 
+				function(e){
+					res = func(res, e)
+					return [] })
+			.then(function(){ 
+				return res }) },
+	flat: function(depth=1){
+		return this.constructor(this.__list.flat(), 
+			function(e){ 
+				return (depth > 1 
+							&& e != null 
+							&& e.flat) ? 
+						e.flat(depth-1) 
+					: depth != 0 ?
+						e
+					: [e] }) },
+	// XXX REVERSE...
+	// XXX BUG: 
+	//			await Promise.iter([1, Promise.iter(['a', ['b', 'c']]), [2, 3], 4])
+	//				.flat()
+	//					-> [ 1, 'a', [ 'b', 'c' ], 2, 3, 4 ]
+	// 			await Promise.iter([1, Promise.iter(['a', ['b', 'c']]), [2, 3], 4])
+	// 				.flat()
+	// 				.reverse()
+	//					-> [ 4, 2, 3, [ 'b', 'c', 'a' ], 1 ]
+	//		...should be:
+	//					-> [ 4, 2, 3, [ 'b', 'c' ], 'a', 1 ]
+	//		it's odd we are not seeing this in other places...
+	reverse: function(){
+		return this.constructor(this.__list
+			.map(function(elems){
+				return elems && elems.then ?
+					elems.then(function(res){
+						return res
+							.reverse()
+				   			.flat() })
+					: elems })
+			.reverse()
+			.flat()) },
+
+	// compatibility with root promise...
+	// XXX BUG:
+	// 			await Promise.iter(Promise.resolve([1,2,[3, 4]])).iter()
+	//				-> [ [ 1, 2, 3, 4 ] ]
+	iter: function(){
+		return this.constructor(
+			// clone and unwrap the .__list
+			this.__list
+				.map(function(elems){
+					return elems && elems.then ?
+						elems.then(function(res){
+							return res instanceof Array ?
+								res.flat() 
+								: res })
+						: elems })
+				.flat()) },
+	
+	// XXX do we need these?
+	// 			.pop()
+	// 			.shift()
+	// 			.first() / .last()
+	// XXX these can change the "resolved" state...
+	// 		...i.e. return a pending promise when called from a fulfilled 
+	// 		promise....
+	// 			.concat(..)
+	// 			.push(..)
+	// 			.unshift(..)
+	// 			.first(..) / .last(..)
+
+
+	// Overload .then(..), .catch(..) and .finally(..) to return a plain 
+	// Promise instnace...
+	//
+	// NOTE: .catch(..) and .finally(..) are implemented through .then(..)
+	// 		so we do not need to overload those...
+	// NOTE: this is slightly different from .then(..) in that it can be 
+	// 		called without arguments and return a promise wrapper. This can
+	// 		be useful to hide special promise functionality...
+	then: function (onfulfilled, onrejected){
+		var p = new Promise(
+			function(resolve, reject){
+				Promise.prototype.then.call(this,
+					// NOTE: resolve(..) / reject(..) return undefined so
+					// 		we can't pass them directly here...
+					function(res){ 
+						resolve(res)
+						return res },
+					function(res){
+						reject(res)
+						return res }) }.bind(this))
+		return arguments.length > 0 ?
+			p.then(...arguments) 
+			: p },
+
+
+	//
+	//	Promise.iter([ .. ])
+	//		-> iterable-promise
+	//
+	//	Promise.iter([ .. ], handler)
+	//		-> iterable-promise
+	//
+	//
+	// 	handler(e)
+	// 		-> [value]
+	// 		-> []
+	//
+	//
+	// NOTE: element index is unknowable untill the full list is expanded
+	// 		as handler(..)'s return value can expand to any number of 
+	// 		items...
+	// 		XXX we can make the index a promise, then if the client needs
+	// 			the value they can wait for it...
+	//
+	//
+	// Spectial cases usefull for extending this constructor...
+	//
+	//	Clone the iterator...
+	//	Promise.iter([ .. ], false)
+	//		-> iterable-promise
+	//
+	//	Create a rejected iterator...
+	//	Promise.iter(false)
+	//		-> iterable-promise
+	//
+	//
+	// XXX if list is an iterator, can we fill this async???
+	// XXX iterator/generator as input:
+	// 		- do we unwind here or externally?
+	// 			...feels like with the generator external unwinding is 
+	// 			needed...
+	// XXX would be nice to support trowing STOP...
+	// 		- this is more complicated than simply suing .smap(..) instead 
+	// 			of .map(..) because the list can contain async promises...
+	// 			...would need to wrap each .then(..) call in try-catch and
+	// 			manually handle the stop...
+	// 		- another issue here is that the stop would happen in order of 
+	// 			execution and not order of elements...
+	// XXX add support for list as a promise....
+	__new__: function(_, list, handler){
+		// handle: IterablePromise(<list>, <mode>)
+		if(typeof(handler) == 'string'){
+			mode = handler
+			handler = undefined }
+
+		// instance...
+		var promise
+		var obj = Reflect.construct(
+			IterablePromise.__proto__, 
+			[function(resolve, reject){
+				// NOTE: this is here for Promise compatibilty...
+				if(typeof(list) == 'function'){
+					return list.call(this, ...arguments) } 
+				// initial reject... 
+				if(list === false){
+					return reject() }
+				promise = {resolve, reject} }], 
+			IterablePromise)
+
+		if(promise){
+			// clone/normalize...
+			list = 
+				// special case: promised list...
+				list instanceof Promise ?
+					list.then(function(res){ 
+						return [res] })
+				: [list].flat()
+					.map(function(e){
+						return (e && e.then) ?
+							e.then(function(e){ 
+								return [e] })
+							: [e] })
+
+			if(handler){
+				// NOTE: this is recursive to handle expanding nested promises...
+				var handle = function(elem){
+					// call the handler...
+					return (elem && elem.then) ?
+						elem.then(function(elems){
+							return elems
+								.map(handle)
+								.flat() })
+						: elem 
+							.map(handler)
+							.flat() }
+
+				// handle the list...
+				//list = list.map(handle) }
+				list =
+					list instanceof Promise ?
+						// special case: promised list...
+						list.then(function(list){
+							return list.map(handle) })	
+						: list.map(handle) }
+
+			Object.defineProperty(obj, '__list', {
+				value: list,
+				enumerable: false,
+			})
+
+			// handle promise state...
+			//Promise.all(list)
+			;(list instanceof Promise ?
+					// special case: promised list...
+					list
+					: Promise.all(list))
+				.then(function(res){
+					promise.resolve(res.flat()) })
+				.catch(promise.reject) }
+
+		return obj },
+})
+
+
+
+//---------------------------------------------------------------------
+// Interactive promise...
+// 
+// Adds ability to send messages to the running promise.
+// 
+
+var InteractivePromise =
+module.InteractivePromise =
+object.Constructor('InteractivePromise', Promise, {
+	// XXX do we need a way to remove handlers???
+	__message_handlers: null,
+
+	send: function(...args){
+		var that = this
+		;(this.__message_handlers || [])
+			.forEach(function(h){ h.call(that, ...args) })
+		return this },
+
+	then: IterablePromise.prototype.then,
+
+	//
+	//	Promise.interactive(handler)
+	//		-> interacive-promise
+	//
+	//	handler(resolve, reject, onmessage)
+	//
+	//	onmessage(func)
+	//
+	//
+	__new__: function(_, handler){
+		var handlers = []
+
+		var onmessage = function(func){
+			// remove all handlers...
+			if(func === false){
+				var h = (obj == null ?
+					handlers
+					: (obj.__message_handlers || []))
+				h.splice(0, handlers.length)
+			// remove a specific handler...
+			} else if(arguments[1] === false){
+				var h = (obj == null ?
+					handlers
+					: (obj.__message_handlers || []))
+				h.splice(h.indexOf(func), 1)
+			// register a handler...
+			} else {
+				var h = obj == null ?
+					// NOTE: we need to get the handlers from .__message_handlers
+					// 		unless we are not fully defined yet, then use the 
+					// 		bootstrap container (handlers)...
+					// 		...since we can call onmessage(..) while the promise 
+					// 		is still defined there is no way to .send(..) until it
+					// 		returns a promise object, this races here are highly 
+					// 		unlikely...
+					handlers
+					: (obj.__message_handlers = 
+						obj.__message_handlers ?? [])
+				handlers.push(func) } }
+
+		var obj = Reflect.construct(
+			InteractivePromise.__proto__, 
+			!handler ?
+				[]
+				: [function(resolve, reject){
+					return handler(resolve, reject, onmessage) }], 
+			InteractivePromise)
+		Object.defineProperty(obj, '__message_handlers', {
+			value: handlers,
+			enumerable: false,
+			// XXX should this be .configurable???
+			configurable: true,
+		})
+   		return obj },
+})
+
+
+
+//---------------------------------------------------------------------
+// Cooperative promise...
+// 
+// A promise that can be resolved/rejected externally.
+// NOTE: normally this has no internal resolver logic...
+// 
+
+var CooperativePromise =
+module.CooperativePromise =
+object.Constructor('CooperativePromise', Promise, {
+	__handlers: null,
+
+	get isSet(){
+		return this.__handlers === false },
+
+	set: function(value, resolve=true){
+		// can't set twice...
+		if(this.isSet){
+			throw new Error('.set(..): can not set twice') }
+		// bind to promise...
+		if(value && value.then && value.catch){
+			value.then(handlers.resolve)
+			value.catch(handlers.reject)
+		// resolve with value...
+		} else {
+			resolve ?
+				this.__handlers.resolve(value) 
+				: this.__handlers.reject(value) }
+		// cleanup and prevent setting twice...
+		this.__handlers = false
+		return this },
+
+	then: IterablePromise.prototype.then,
+
+	__new__: function(){
+		var handlers
+		var resolver = arguments[1]
+
+		var obj = Reflect.construct(
+			CooperativePromise.__proto__, 
+			[function(resolve, reject){
+				handlers = {resolve, reject} 
+				// NOTE: this is here to support builtin .then(..)
+				resolver
+					&& resolver(resolve, reject) }], 
+			CooperativePromise) 
+
+		Object.defineProperty(obj, '__handlers', {
+			value: handlers,
+			enumerable: false,
+			writable: true,
+		})
+		return obj },
+})
+
+
+
+//---------------------------------------------------------------------
+
+// XXX EXPEREMENTAL...
+var ProxyPromise =
+module.ProxyPromise =
+object.Constructor('ProxyPromise', Promise, {
+	__new__: function(context, constructor){
+		var proto = 'prototype' in constructor ?
+			constructor.prototype
+			: constructor
+		var obj = Reflect.construct(
+			ProxyPromise.__proto__, 
+			[function(resolve, reject){
+				context.then(resolve)
+				context.catch(reject) }], 
+			ProxyPromise) 
+		// populate...
+		// NOTE: we are not using object.deepKeys(..) here as we need 
+		// 		the key origin not to trigger property getters...
+		var seen = new Set()
+		while(proto != null){
+			Object.entries(Object.getOwnPropertyDescriptors(proto))
+				.forEach(function([key, value]){
+					// skip overloaded keys...
+					if(seen.has(key)){
+						return }
+					// skip non-functions...
+					if(typeof(value.value) != 'function'){
+						return }
+					// skip non-enumerable except for Object.prototype.run(..)...
+					if(!(key == 'run' 
+								&& Object.prototype.run === value.value) 
+							&& !value.enumerable){
+						return }
+					// proxy...
+					obj[key] = function(...args){
+						// XXX should we also .catch(..) here???
+						return context.then(function(res){
+							return res[key](...args) }) } })
+			proto = proto.__proto__ } 
+		return obj },
+})
+
+
+
+//---------------------------------------------------------------------
+
+var PromiseMixin =
+module.PromiseMixin =
+object.Mixin('PromiseMixin', 'soft', {
+	iter: IterablePromise,
+	interactive: InteractivePromise,
+	cooperative: CooperativePromise,
+})
+
+PromiseMixin(Promise)
+
+
+// XXX EXPEREMENTAL...
+var PromiseProtoMixin =
+module.PromiseProtoMixin =
+object.Mixin('PromiseProtoMixin', 'soft', {
+	as: ProxyPromise,
+
+	// XXX
+	iter: function(){
+		return IterablePromise(this) },
+})
+
+PromiseProtoMixin(Promise.prototype)
+
+
+
+
+/**********************************************************************
+* vim:set ts=4 sw=4 :                               */ return module })

package/README.md

@@ -70,10 +70,16 @@ 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)
+      - [`<promise>.as(..)`](#promiseas)
+      - [`<promise-proxy>.<method>(..)`](#promise-proxymethod)
   - [Generator extensions and utilities](#generator-extensions-and-utilities)
     - [The basics](#the-basics)
       - [`generator.Generator`](#generatorgenerator)
@@ -1449,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(..)`:
@@ -1512,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>
 ```
 
@@ -1542,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>
@@ -1555,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(..)`
 
@@ -1567,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
@@ -1621,6 +1670,56 @@ var p = Promise.iter(
 ```
 
 
+### Promise proxies
+
+_Promise proxies_ generate a set of prototype methods returning promises that when the parent promise is resolved will resolve to a specific method call.
+
+Example:
+```javascript
+var o = {
+    method: function(...args){
+        console.log('method:', ...args)
+    },
+}
+
+var p = Peomise.cooperative().as(o)
+
+p.method(1, 2, 3) // returns a promise...
+
+// ...
+
+// resolving a promise will trigger all the proxy emthod execution, so 
+// here 'method: 1, 2, 3' will get printed...
+p.set(o)
+
+```
+
+#### `<promise>.as(..)`
+
+Create a promise proxy
+
+```bnf
+<promise>.as(<object>)
+<promise>.as(<constructor>)
+    -> <promise-proxy>
+```
+
+A proxy promise will be populated with proxy methods to all the methods of the `<object>` or `<constructor>.prototype`.
+
+#### `<promise-proxy>.<method>(..)`
+
+When `<promise>` resolves, call the `.<method>(..)` on the resolved value.
+
+```bnf
+<promise-proxy>.<method>(..)
+    -> <method-promise>
+```
+
+`<method-promise>` will resolve the the return value of the `<method>` when 
+the main `<promise>` is resolved.
+
+
+
 ## Generator extensions and utilities
 
 ```javascript

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.10.1",
+  "version": "6.11.2",
   "description": "Generic JavaScript types and type extensions...",
   "main": "main.js",
   "scripts": {