ig-types 6.11.2 → 6.12.1

package/Promise.js

@@ -121,6 +121,14 @@ object.Constructor('IterablePromise', Promise, {
 					return [] })
 			.then(function(){ 
 				return res }) },
+	/* // XXX since order of execution is not fixed there is no point in 
+	//		adding this.
+	reduceRight: function(func, res){
+		return this
+			.reverse()
+			.reduce(...arguments)
+			.reverse() },
+	//*/
 	flat: function(depth=1){
 		return this.constructor(this, 
 			function(e){ 
@@ -152,18 +160,45 @@ object.Constructor('IterablePromise', Promise, {
 				.reverse(),
 			'raw') },
 
+	// NOTE: these can create an unresolved promise from a resolved 
+	// 		promise...
+	// XXX EXPEREMENTAL...
+	// 		....can we remove a level of indirection here???
+	// 		would be better to use the raw mode...
+	concat: function(other){
+		var lst = this.__list
+		return lst instanceof Promise ?
+				this.constructor([this, other])
+					.flat()
+			: other instanceof IterablePromise ?
+				this.constructor(
+					lst.concat(other.__list),
+					'raw')
+			: other instanceof Promise ?
+				this.constructor(
+					lst.concat(other
+						.then(function(res){ 
+							return res instanceof Array ?
+					   			res
+								: [res] })),
+					'raw')
+			: this.constructor(
+				// XXX this is cheating -- need a more direct way to form the array...
+				lst.concat(this.constructor(other).__list),
+				'raw') },
+	push: function(elem){
+		return this.concat([elem]) },
+	unshift: function(elem){
+		return this.constructor([elem])
+			.concat(this) },
+
 	// 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(..)
-
+	// 		...would be nice if these could stop everything that's not
+	// 		needed to execute...
+	
 
 	// Overload .then(..), .catch(..) and .finally(..) to return a plain 
 	// Promise instnace...

package/README.md

@@ -75,6 +75,8 @@ Library of JavaScript type extensions, types and utilities.
       - [`<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>.concat(..)`](#promise-iterconcat)
+      - [`<promise-iter>.push(..)` / `<promise-iter>.unshift(..)`](#promise-iterpush--promise-iterunshift)
       - [`<promise-iter>.then(..)` / `<promise-iter>.catch(..)` / `<promise-iter>.finally(..)`](#promise-iterthen--promise-itercatch--promise-iterfinally)
       - [Advanced handler](#advanced-handler)
     - [Promise proxies](#promise-proxies)
@@ -1387,7 +1389,7 @@ controlled(t.then())
 // ...
 ```
 
-Note that functionally this can be considered a special-case of an 
+Note that this functionally can be considered a special-case of an 
 [interactive promise](#interactive-promises), but in reality they are two 
 different implementations, the main differences are:
 - _Cooperative promise_ constructor does not need a resolver function,
@@ -1483,8 +1485,6 @@ var p = Promise.iter([ .. ])
         // ...
     })
     // items reach here as soon as they are returned by the filter stage handler...
-    // NOTE: the filter handler may return promises, those will not be processed
-    //    until they are resolved...
     .map(function(e){
         // ...
     })
@@ -1502,6 +1502,12 @@ This approach has a number of advantages:
 And some disadvantages:
 - item indexes are unknowable until all the promises resolve.
 
+Calling each of the `<promise-iter>` methods will return a new and unresolved 
+promise, even if the original is resolved.
+
+If all values are resolved the `<promise-iter>` will resolve on the next 
+execution frame.
+
 <!-- 
 XXX should we support generators as input?
     ...not sure about the control flow direction here, on one hand the generator
@@ -1580,19 +1586,21 @@ and [`.reduce(..)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Refe
 
 Note that these are different to `Array`'s equivalents in some details: 
 - `<handler>` is _not_ called in the order of element occurrence but rather 
-  in the order of elements are resolved/ready.
+    in the order of elements are resolved/ready.
 - `<handler>` does not get either the element _index_ or the _container_.  
-    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 because in _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.
+This is especially critical for `.reduce(..)` as the 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.
+`<promise>` rather than an iterable 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(..)`.
+Note that since `.reduce(..)` handler's execution order can not be known,
+there is no point in implementing `.reduceRigth(..)`.
 
 
 #### `<promise-iter>.flat(..)`
@@ -1613,7 +1621,35 @@ This is similar to [`<array>.flat(..)`](https://developer.mozilla.org/en-US/docs
     -> <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.
+This is deferent from `<array>.reverse()` in that it will _not_ reverse in-place, 
+but rather a _reversed copy_ will be created.
+
+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>.concat(..)`
+
+```bnf
+<promise-iter>.concat(<other>)
+    -> <promise-iter>
+```
+
+This is similar to [`<array>.concat(..)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat) see it for more info.
+
+
+#### `<promise-iter>.push(..)` / `<promise-iter>.unshift(..)`
+
+```bnf
+<promise-iter>.push(<elem>)
+    -> <promise-iter>
+
+<promise-iter>.unshift(<elem>)
+    -> <promise-iter>
+```
+
+These are similar to [`<array>.push(..)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push) 
+and [`<array>.unshift(..)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/unshift) 
+see them for more info.
 
 
 #### `<promise-iter>.then(..)` / `<promise-iter>.catch(..)` / `<promise-iter>.finally(..)`
@@ -1633,40 +1669,51 @@ can be useful to hide the extended promise API from further code.
 #### Advanced handler
 
 ```bnf
-Promise.iter(<block-array>, <handler>)
+Promise.iter(<block>, <handler>)
     -> <iterable-promise>
+```
 
-<handler>(<elem>)
-    -> [ <elems> ]
+The `<handler>` will get passed each resolved `<value>` of the input `<block>` 
+as soon as it's available/resolved.
+
+The `<handler>` return value is unwrapped into the resulting array, allowing
+each call to both remove elements (i.e. returning `[]`) from the resulting 
+`<block>` as well as insert multiple items (by returning an array of items).
+
+<!-- XXX returning promises from handler needs to be documented/tested... -->
+
+```bnf
+<handler>(<value>)
+    -> []
+    -> [ <elem>, .. ]
+    -> <non-array>
 ```
 
 ```bnf
-<block-array> ::= 
+<block> ::= 
     []
-    | [ <block-elem>, .. ]
+    | [ <elem>, .. ]
 
-<block-elem> ::=
-    []
-    | [ <value>, .. ]
-    | <promise>
-    | <non-array>
+<elem> ::= 
+    <value>
+    | <promise>(<value>)
 ```
 
 Example:
 ```javascript
 var p = Promise.iter(
-        // NOTE: if you want an element to explicitly be an array wrap it in 
-        //    an array -- like the last element here...
-        [[1, 2], 3, Promise.resolve(4), [[5, 6]]], 
+        [1, 2, 3, Promise.resolve(4), [5, 6]], 
         function(elem){
+            // duplicate even numbers...
             return elem % 2 == 0 ?
                     [elem, elem]
+                // return arrays as-is...
                 : elem instanceof Array ?
-                  [elem]
+                    [elem]
+                // remove other elements...
                 : [] })
     .then(function(lst){
-        console.log(lst) // -> [2, 2, 4, 4, [5, 6]]
-    })
+        console.log(lst) }) // -> [2, 2, 4, 4, [5, 6]]
 ```
 
 

package/package.json

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

package/Promise.js.bak

@@ -1,548 +0,0 @@
-/**********************************************************************
-* 
-*
-*
-*
-* 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 })