ig-types 6.15.1 → 6.16.1

package/Array.js

@@ -12,6 +12,7 @@
 /*********************************************************************/
 
 var object = require('ig-object')
+var stoppable = require('ig-stoppable')
 
 var generator = require('./generator')
 
@@ -22,8 +23,7 @@ var generator = require('./generator')
 // NOTE: this is used in a similar fashion to Python's StopIteration...
 var STOP =
 module.STOP =
-	object.STOP
-
+	stoppable.STOP
 
 
 //---------------------------------------------------------------------
@@ -212,8 +212,12 @@ object.Mixin('ArrayMixin', 'soft', {
 			// done...
 			: [] },
 
-	iter: function*(lst=[]){
-		yield* lst.iter() },
+	// XXX not sure about the handler API here yet... 
+	iter: function*(lst=[], handler=undefined){
+		yield* lst.iter(
+			...(handler ? 
+				[handler] 
+				: [])) },
 })
 
 
@@ -488,8 +492,22 @@ object.Mixin('ArrayProtoMixin', 'soft', {
 	//		-> iterator
 	//
 	// XXX should this take an argument and be like map??
-	iter: function*(){
-		yield* this },
+	// 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 }}),
 
 
 	// Stoppable iteration...

package/Function.js

@@ -0,0 +1,18 @@
+/**********************************************************************
+* 
+*
+*
+**********************************************/  /* 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 AsyncFunction =
+module.AsyncFunction =
+	(async function(){}).constructor
+
+
+
+/**********************************************************************
+* vim:set ts=4 sw=4 :                               */ return module })

package/Promise.js

@@ -30,6 +30,8 @@
 
 var object = require('ig-object')
 
+//var generator = require('./generator')
+
 
 
 //---------------------------------------------------------------------
@@ -58,6 +60,7 @@ var object = require('ig-object')
 // 		
 // XXX how do we handle errors/rejections???
 // 		...mostly the current state is OK, but need more testing...
+// XXX add support for async generators...
 // 		
 
 var iterPromiseProxy = 
@@ -117,6 +120,11 @@ object.Constructor('IterablePromise', Promise, {
 	// 		stop will stop the handlers not yet run and not the next 
 	// 		handlers in sequence.
 	// 		XXX EXPEREMENTAL: STOP...
+	// XXX add support for async generators...
+	// 		...an async generator is not "parallel", i.e. intil one 
+	// 		returned promise is resolved the generator blocks (will not 
+	// 		advance)...
+	// 		...can we feed out a results one by one???
 	__pack: function(list, handler=undefined){
 		var that = this
 		// handle iterable promise list...
@@ -198,20 +206,6 @@ object.Constructor('IterablePromise', Promise, {
 					: handler(elem) }) },
 		//*/
 	// transform/handle packed array (sync)...
-	//
-	// XXX BUG:
-	// 			await Promise.iter(['a', Promise.resolve(222), ['c']])
-	// 					.map(async e => e)
-	// 				-> ['a', <promise>, ['c']]
-	// 		is not the same as:
-	// 			await Promise.iter(['a', Promise.resolve(222), ['c']])
-	// 					.map(e => e)
-	// 				-> ['a', 222, ['c']]
-	// 		...and these works as expected:
-	// 			await Promise.iter(['a', Promise.resolve(222), ['c']], async e => [e])
-	// 				-> ['a', 222, ['c']]
-	// 			await Promise.iter(['a', Promise.resolve(222), ['c']], e => [e])
-	// 				-> ['a', 222, ['c']]
 	__handle: function(list, handler=undefined){
 		var that = this
 		if(typeof(list) == 'function'){
@@ -300,6 +294,8 @@ object.Constructor('IterablePromise', Promise, {
 			.then(function(){ 
 				return res }) },
 
+	// XXX .chain(..) -- see generator.chain(..)
+
 	flat: function(depth=1){
 		return this.constructor(this, 
 			function(e){ 
@@ -468,6 +464,11 @@ object.Constructor('IterablePromise', Promise, {
 	every: promiseProxy('every'),
 
 
+	join: async function(){
+		return [...(await this)]
+			.join(...arguments) },
+
+
 	// this is defined globally as Promise.prototype.iter(..)
 	//
 	// for details see: PromiseMixin(..) below...

package/README.md

@@ -13,6 +13,8 @@ Library of JavaScript type extensions, types and utilities.
     - [`Object.matchPartial(..)`](#objectmatchpartial)
     - [`<object>.run(..)`](#objectrun)
     - [`Object.sort(..)`](#objectsort)
+  - [`Function`](#function)
+    - [`func.AsyncFunction`](#funcasyncfunction)
   - [`Array`](#array)
     - [`<array>.first(..)` / `<array>.last(..)`](#arrayfirst--arraylast)
     - [`<array>.rol(..)`](#arrayrol)
@@ -78,6 +80,7 @@ Library of JavaScript type extensions, types and utilities.
       - [`<promise-iter>.concat(..)`](#promise-iterconcat)
       - [`<promise-iter>.push(..)` / `<promise-iter>.unshift(..)`](#promise-iterpush--promise-iterunshift)
       - [`<promise-iter>.at(..)` / `<promise-iter>.first()` / `<promise-iter>.last()`](#promise-iterat--promise-iterfirst--promise-iterlast)
+      - [`<promise-iter>.join(..)`](#promise-iterjoin)
       - [`<promise-iter>.some(..)` / `<promise-iter>.find(..)`](#promise-itersome--promise-iterfind)
       - [Array proxy methods returning `<promise-iter>`](#array-proxy-methods-returning-promise-iter)
       - [Array proxy methods returning a `<promise>`](#array-proxy-methods-returning-a-promise)
@@ -94,7 +97,7 @@ Library of JavaScript type extensions, types and utilities.
       - [`generator.iter(..)`](#generatoriter)
       - [`generator.STOP`](#generatorstop)
     - [Generator instance iteration](#generator-instance-iteration)
-      - [`<generator>.iter()`](#generatoriter-1)
+      - [`<generator>.iter(..)`](#generatoriter-1)
       - [`<generator>.map(..)` / `<generator>.filter(..)`](#generatormap--generatorfilter)
       - [`<generator>.reduce(..)` / `<generator>.greduce(..)`](#generatorreduce--generatorgreduce)
       - [`<generator>.slice(..)`](#generatorslice)
@@ -102,7 +105,7 @@ Library of JavaScript type extensions, types and utilities.
       - [`<generator>.flat(..)`](#generatorflat)
       - [`<generator>.shift()` / `<generator>.pop()` / `<generator>.gshift()` / `<generator>.gpop()`](#generatorshift--generatorpop--generatorgshift--generatorgpop)
       - [`<generator>.unshift(..)` / `<generator>.push(..)`](#generatorunshift--generatorpush)
-      - [`<generator>.promise()`](#generatorpromise)
+      - [`<generator>.join(..)`](#generatorjoin)
       - [`<generator>.then(..)` / `<generator>.catch(..)` / `<generator>.finally(..)`](#generatorthen--generatorcatch--generatorfinally)
       - [`<generator>.toArray()`](#generatortoarray)
     - [Treating iterators the same as generators](#treating-iterators-the-same-as-generators)
@@ -114,6 +117,7 @@ Library of JavaScript type extensions, types and utilities.
       - [`<Generator>.slice(..)`](#generatorslice-1)
       - [`<Generator>.map(..)` / `<Generator>.filter(..)` / `<Generator>.reduce(..)` / `<Generator>.flat()`](#generatormap--generatorfilter--generatorreduce--generatorflat)
       - [`<Generator>.toArray()`](#generatortoarray-1)
+      - [`<Generator>.join(..)`](#generatorjoin-1)
       - [`<Generator>.then(..)` / `<Generator>.catch(..)` / `<Generator>.finally(..)`](#generatorthen--generatorcatch--generatorfinally-1)
     - [Generator combinators](#generator-combinators)
       - [`<Generator>.chain(..)` / `<generator>.chain(..)`](#generatorchain--generatorchain)
@@ -124,6 +128,15 @@ Library of JavaScript type extensions, types and utilities.
       - [`generator.produce(..)`](#generatorproduce)
     - [Generator helpers](#generator-helpers)
       - [`generator.stoppable(..)`](#generatorstoppable)
+  - [Async generator extensions](#async-generator-extensions)
+      - [`generator.AsyncGenerator`](#generatorasyncgenerator)
+      - [`<async-generator>.then(..)` / `<async-generator>.catch(..)` / `<async-generator>.finally(..)`](#async-generatorthen--async-generatorcatch--async-generatorfinally)
+      - [`<async-generator>.iter(..)`](#async-generatoriter)
+      - [`<async-generator>.map(..)` / `<async-generator>.filter(..)` / `<async-generator>.reduce(..)`](#async-generatormap--async-generatorfilter--async-generatorreduce)
+      - [`<async-generator>.chain(..)`](#async-generatorchain)
+      - [`<async-generator>.flat(..)`](#async-generatorflat)
+      - [`<async-generator>.concat(..)`](#async-generatorconcat)
+      - [`<async-generator>.push(..)` / `<async-generator>.unshift(..)`](#async-generatorpush--async-generatorunshift)
   - [Containers](#containers)
     - [`containers.UniqueKeyMap()` (`Map`)](#containersuniquekeymap-map)
       - [`<unique-key-map>.set(..)`](#unique-key-mapset)
@@ -446,6 +459,30 @@ Object.keys(Object.sort(o, ['x', 'a', '100']))
 This is similar to [`<map>.sort(..)`](#mapsort) and [`<ser>.sort(..)`](#setsort).
 
 
+## `Function`
+
+```javascript
+var func = require('ig-types/Function')
+```
+
+### `func.AsyncFunction`
+
+The async function constructor.
+
+This enables us to test if an object is an instance of an async function. 
+
+```javascript
+var a = async function(){
+    // ...
+}
+
+a instanceof func.AsyncFunction // -> true
+```
+
+This is hidden by JavaScript by default.
+
+
+
 ## `Array`
 
 ```javascript
@@ -1677,6 +1714,12 @@ parent `<promise-iter>`.
 
 XXX
 
+
+#### `<promise-iter>.join(..)`
+
+XXX
+
+
 #### `<promise-iter>.some(..)` / `<promise-iter>.find(..)`
 
 ```bnf
@@ -2023,7 +2066,7 @@ Chained generators handle items depth-first, i.e. the items are passed as they
 are yielded down the generator chain.
 
 
-#### `<generator>.iter()`
+#### `<generator>.iter(..)`
 
 Iterate over the generator.
 ```bnf
@@ -2031,7 +2074,24 @@ Iterate over the generator.
     -> <generator>
 ```
 
-This is here mainly for compatibility with [`<array>`'s `.iter()`](#arrayiter--arrayiter).
+XXX move this to `generator.iter(..)`
+
+Compatible with [`<array>`'s `.iter()`](#arrayiter--arrayiter).
+
+`.iter(..)` also supports a handler function
+```bnf
+<generator>.iter(<handler>)
+    -> <generator>
+
+
+<handler>(<elem>, <index>)
+    -> <elem>
+    -> [<elem>, ..]
+    -> []
+```
+
+Note that the iterables returned by `<handler>(..)` will be expanded, to prevent 
+this wrap them in an array.
 
 
 #### `<generator>.map(..)` / `<generator>.filter(..)` 
@@ -2156,30 +2216,34 @@ Value added by `.unshift(..)` will be yielded by `<generator>` "first", i.e. on
 _next_ call to `.next()`, regardless of the current generator state.
 
 
-#### `<generator>.promise()`
+#### `<generator>.join(..)`
+
+XXX
+
+
+#### `<generator>.then(..)` / `<generator>.catch(..)` / `<generator>.finally(..)`
+
+Return a promise and resolve it with the generator value.
 
 ```bnf
-<generator>.promise()
+<generator>.then()
     -> <promise>
 ```
-Return a promise and resolve it with the generator value.
-
-Note that this will deplete the generator.
 
-
-#### `<generator>.then(..)` / `<generator>.catch(..)` / `<generator>.finally(..)`
+Adding handlers to the promise
 
 ```bnf
 <generator>.then(<resolve>, <reject>)
     -> <promise>
 
-<generator>.then(<reject>)
+<generator>.then(<resolve>)
     -> <promise>
 
 <generator>.finally(<handler>)
     -> <promise>
 ```
-Shorthands to `<generator>.promise().then(..)` / `<generator>.promise().catch(..)` / `<generator>.promise().finally(..)`
+
+Note that this will deplete the generator.
 
 These are the same as equivalent `Promise` methods, for more info see:  
 https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise
@@ -2360,6 +2424,10 @@ Return a function that will return a `<generator>` output as an `Array`.
     -> <function>
 ```
 
+#### `<Generator>.join(..)`
+
+XXX
+
 
 #### `<Generator>.then(..)` / `<Generator>.catch(..)` / `<Generator>.finally(..)`
 
@@ -2483,6 +2551,26 @@ stoppable(<generator>)
 
 <!-- XXX example? -->
 
+## Async generator extensions
+
+XXX EXPERIMENTAL
+
+#### `generator.AsyncGenerator`
+
+#### `<async-generator>.then(..)` / `<async-generator>.catch(..)` / `<async-generator>.finally(..)`
+
+#### `<async-generator>.iter(..)`
+
+#### `<async-generator>.map(..)` / `<async-generator>.filter(..)` / `<async-generator>.reduce(..)`
+
+#### `<async-generator>.chain(..)`
+
+#### `<async-generator>.flat(..)`
+
+#### `<async-generator>.concat(..)`
+
+#### `<async-generator>.push(..)` / `<async-generator>.unshift(..)`
+
 
 
 ## Containers

package/event.js

@@ -120,6 +120,8 @@ object.Constructor('Eventful', {
 				Object.defineProperty(context, '__event_handlers__', {
 						value: {[this.name]: (handlers = [])},
 						enumerable: false,
+						configurable: true,
+						writable: true,
 					}) 
 					&& handlers
 				: (context.__event_handlers__[this.name] = 
@@ -293,6 +295,8 @@ module.EventHandlerMixin = object.Mixin('EventHandlerMixin', {
 				&& Object.defineProperty(this, '__event_handlers__', {
 					value: {},
 					enumerable: false,
+					configurable: true,
+					writable: true,
 				})
 			;(this.__event_handlers__[evt] = 
 					this.__event_handlers__[evt] || [])
@@ -343,14 +347,14 @@ module.EventDocMixin = object.Mixin('EventDocMixin', {
 		return object.deepKeys(this)
 			.filter(function(n){ 
 				// avoid triggering props...
-				return !object.values(this, n, function(){ return object.STOP }, true)[0].get
+				return !object.values(this, n, true).next().value.get
 					// XXX this is too strict...
 					&& (this[n] || {}).constructor === Eventful}.bind(this)) },
 	get events(){
 		return object.deepKeys(this)
 			.filter(function(n){ 
 				// avoid triggering props...
-				return !object.values(this, n, function(){ return object.STOP }, true)[0].get
+				return !object.values(this, n, true).next().value.get
 					// XXX this is too strict...
 					&& (this[n] || {}).constructor === Event }.bind(this)) },
 })

package/generator.js

@@ -8,6 +8,7 @@
 /*********************************************************************/
 
 var object = require('ig-object')
+var stoppable = require('ig-stoppable')
 
 
 
@@ -16,7 +17,7 @@ var object = require('ig-object')
 // NOTE: this is used in a similar fashion to Python's StopIteration...
 var STOP =
 module.STOP =
-	object.STOP
+	stoppable.STOP
 
 
 //---------------------------------------------------------------------
@@ -38,11 +39,11 @@ module.STOP =
 // of each of them.
 // So, below we will define:
 //
-// 	GeneratorPrototype 
+// 	Generator.prototype 
 // 		prototype of the generator constructors (i.e. Iter(..) from the 
 // 		above example)
 //
-// 	GeneratorPrototype.prototype
+// 	Generator.prototype.prototype
 // 		generator instance prototype (i.e. iter for the above code)
 //
 //
@@ -58,17 +59,10 @@ module.STOP =
 //
 //---------------------------------------------------------------------
 
-var GeneratorPrototype =
-	(function*(){}).constructor.prototype
-
 var Generator = 
 module.Generator =
 	(function*(){}).constructor
 
-
-var AsyncGeneratorPrototype =
-	(async function*(){}).constructor.prototype
-
 var AsyncGenerator =
 module.AsyncGenerator =
 	(async function*(){}).constructor
@@ -85,19 +79,44 @@ var ITERATOR_PROTOTYPES = [
 
 
 //---------------------------------------------------------------------
-
 // generic generator wrapper...
+
+// helper...
+var __iter = 
+module.__iter =
+function*(lst=[]){
+	if(typeof(lst) == 'object' 
+			&& Symbol.iterator in lst){
+		yield* lst 
+	} else {
+		yield lst } }
+
+// XXX updatae Array.js' version for compatibility...
+// XXX DOCS!!!
 var iter = 
 module.iter = 
 Generator.iter =
-	function*(lst=[]){
-		for(var e of lst){
-			yield e } }
+	stoppable(function(lst=[]){
+		// handler -> generator-constructor...
+		if(typeof(lst) == 'function'){
+			// we need to be callable...
+			var that = this instanceof Function ?
+				this
+				// generic root generator...
+				: module.__iter
+			return function*(){
+				yield* that(...arguments).iter(lst) } }
+		// no handler -> generator instance...
+		return module.__iter(lst) })
+
+// NOTE: we need .iter(..) to both return generators if passed an iterable
+// 		and genereator constructos if passed a function...
+iter.__proto__ = Generator.prototype
 
 
 
 //---------------------------------------------------------------------
-// GeneratorPrototype "class" methods...
+// Generator.prototype "class" methods...
 //
 // the following are effectively the same:
 // 	1) Wrapper
@@ -121,9 +140,11 @@ Generator.iter =
 
 //
 // 	makeGenerator(<name>)
+// 	makeGenerator(<name>, <handler>)
 // 		-> <func>
 //
-// 	makeGenerator(<name>, <handler>)
+// 	makeGenerator('async', <name>)
+// 	makeGenerator('async', <name>, <handler>)
 // 		-> <func>
 //
 //
@@ -140,14 +161,26 @@ Generator.iter =
 // XXX this needs to be of the correct type... (???)
 // XXX need to accept generators as handlers...
 var makeGenerator = function(name, pre){
+	var sync = true
+	if(name == 'async'){
+		sync = false
+		var [name, pre] = [...arguments].slice(1) }
 	return function(...args){
 		var that = this
 		return Object.assign(
-			function*(){
-				var a = pre ? 
-					pre.call(this, args, ...arguments)
-					: args
-				yield* that(...arguments)[name](...a) }, 
+			// NOTE: the two branches here are identical, the only 
+			// 		difference is the async keyword...
+			sync ?
+				function*(){
+					var a = pre ? 
+						pre.call(this, args, ...arguments)
+						: args
+					yield* that(...arguments)[name](...a) }
+				: async function*(){
+					var a = pre ? 
+						pre.call(this, args, ...arguments)
+						: args
+					yield* that(...arguments)[name](...a) }, 
 			{ toString: function(){
 				return [
 					that.toString(), 
@@ -163,34 +196,6 @@ var makePromise = function(name){
 			return that(...arguments)[name](func) } } }
 
 
-var stoppable = 
-module.stoppable =
-function(func){
-	return Object.assign(
-		func instanceof Generator ?
-			function*(){
-				try{
-					yield* func.call(this, ...arguments)
-				} catch(err){
-					if(err === STOP){
-						return
-					} else if(err instanceof STOP){
-						yield err.value
-						return }
-					throw err } }
-			: function(){
-				try{
-					return func.call(this, ...arguments)
-				} catch(err){
-					if(err === STOP){
-						return
-					} else if(err instanceof STOP){
-						return err.value }
-					throw err } },
-		{ toString: function(){
-			return func.toString() }, }) }
-
-
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
 
 var GeneratorMixin =
@@ -198,9 +203,7 @@ module.GeneratorMixin =
 object.Mixin('GeneratorMixin', 'soft', {
 	STOP: object.STOP,
 
-	// NOTE: this is here for compatibility with Array.iter(..)
-	iter: function*(lst=[]){
-		yield* module.iter(lst) },
+	iter: module.iter,
 
 	gat: makeGenerator('gat'),
 	at: function(i){
@@ -229,7 +232,7 @@ object.Mixin('GeneratorMixin', 'soft', {
 				return that(...arguments).toArray() },
 			{ toString: function(){
 				return that.toString() 
-					+ '\n    .toString()'}, }) },
+					+ '\n    .toArray()'}, }) },
 	gpop: makeGenerator('gpop'),
 	pop: function(){
 		var that = this
@@ -239,7 +242,7 @@ object.Mixin('GeneratorMixin', 'soft', {
 				return that(...arguments).pop() },
 			{ toString: function(){
 				return that.toString() 
-					+ '\n    .gpop()'}, }) },
+					+ '\n    .pop()'}, }) },
 	push: makeGenerator('push'),
 	gshift: makeGenerator('gshift'),
 	shift: function(){
@@ -250,7 +253,7 @@ object.Mixin('GeneratorMixin', 'soft', {
 				return that(...arguments).shift() }, 
 			{ toString: function(){
 				return that.toString() 
-					+ '\n    .gshift()'}, }) },
+					+ '\n    .shift()'}, }) },
 	unshift: makeGenerator('unshift'),
 
 	// promises...
@@ -272,15 +275,43 @@ object.Mixin('GeneratorMixin', 'soft', {
 						e(...args)
 						: e }) }),
 	//zip: makeGenerator('zip'),
+	
+	enumerate: makeGenerator('enumerate'),
+
+	// XXX should this have a .gjoin(..) companion...
+	join: function(){
+		var args = [...arguments]
+		var that = this
+		return Object.assign(
+			function(){
+				//return that(...arguments).toArray().shift() }, 
+				return that(...arguments).join(...args) }, 
+			{ toString: function(){
+				return that.toString() 
+					+ '\n    .join()'}, }) },
 })
 
 
 var GeneratorProtoMixin =
 module.GeneratorProtoMixin =
 object.Mixin('GeneratorProtoMixin', 'soft', {
-	// NOTE: this is here for compatibility with [..].iter()
-	iter: function*(){ 
-		yield* this },
+	// XXX use module.iter(..) ???
+	iter: stoppable(function*(handler){ 
+		if(handler){
+			var i = 0
+			for(var elem of this){
+				var res = handler.call(this, elem, i) 
+				// expand iterables...
+				if(typeof(res) == 'object' 
+						&& Symbol.iterator in res){
+					yield* res
+				// as-is...
+				} else {
+					yield res }}
+		// no handler...
+		} else {
+			yield* this } }),
+	//*/
 
 	at: function(i){
 		return this.gat(i).next().value },
@@ -390,17 +421,19 @@ object.Mixin('GeneratorProtoMixin', 'soft', {
 
 	// promises...
 	//
-	// XXX how do we handle reject(..) / .catch(..)???
-	promise: function(){
+	then: function(onresolve, onreject){
 		var that = this
-		return new Promise(function(resolve){
-				resolve([...that]) }) },
-	then: function(func){
-		return this.promise().then(func) },
+		var p = new Promise(
+			function(resolve){
+				resolve([...that]) }) 
+		p = (onresolve || onreject) ?
+			p.then(...arguments)
+			: p
+		return p },
 	catch: function(func){
-		return this.promise().catch(func) },
+		return this.then().catch(func) },
 	finally: function(func){
-		return this.promise().finally(func) },
+		return this.then().finally(func) },
 
 	// combinators...
 	//
@@ -423,11 +456,20 @@ object.Mixin('GeneratorProtoMixin', 'soft', {
 		// XXX
 	},
 	//*/
+
+	enumerate: function*(){
+		var i = 0
+		for(var e of this){
+			yield [i++, e] } },
+
+	join: function(){
+		return [...this]
+			.join(...arguments) },
 })
 
 
-GeneratorMixin(GeneratorPrototype)
-GeneratorProtoMixin(GeneratorPrototype.prototype)
+GeneratorMixin(Generator.prototype)
+GeneratorProtoMixin(Generator.prototype.prototype)
 
 
 // Extend base iterators...
@@ -439,36 +481,106 @@ ITERATOR_PROTOTYPES
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
 // XXX EXPERIMENTAL...
 
-var makeAsyncGenerator = function(name, pre){
-	return function(...args){
-		var that = this
-		return Object.assign(
-			async function*(){
-				var a = pre ? 
-					pre.call(this, args, ...arguments)
-					: args
-				for await (var e of that(...arguments)[name](...a)){
-					yield e } }, 
-			{ toString: function(){
-				return [
-					that.toString(), 
-					// XXX need to normalize args better...
-					`.${ name }(${ args.join(', ') })`,
-				].join('\n    ') }, }) } }
-
 var AsyncGeneratorMixin =
 module.AsyncGeneratorMixin =
 object.Mixin('AsyncGeneratorMixin', 'soft', {
-	map: makeAsyncGenerator('map'),
+	// XXX TEST...
+	iter: makeGenerator('async', 'iter'),
+
+	map: makeGenerator('async', 'map'),
+	filter: makeGenerator('async', 'filter'),
+	reduce: makeGenerator('async', 'reduce'),
 })
 
 var AsyncGeneratorProtoMixin =
 module.AsyncGeneratorProtoMixin =
 object.Mixin('AsyncGeneratorProtoMixin', 'soft', {
+	// promise...
+	//
+	// NOTE: this will unwind the generator...
+	// XXX create an iterator promise???
+	// XXX should we unwind???
+	then: function(resolve, reject){
+		var that = this
+		var p = new Promise(async function(_resolve, _reject){
+			var res = []
+			for await(var elem of that){
+				res.push(elem) }
+			_resolve(res) }) 
+		p = (resolve || reject) ?
+			p.then(...arguments)
+			: p
+		return p },
+	catch: function(func){
+		return this.then().catch(func) },
+	finally: function(){
+		return this.then().finally(func) },
+
+	// XXX might be a good idea to use this approach above...
+	iter: stoppable(async function*(handler=undefined){
+		var i = 0
+		if(handler){
+			for await(var e of this){
+				var res = handler.call(this, e, i++)
+				if(typeof(res) == 'object' 
+						&& Symbol.iterator in res){
+					yield* res
+				} else {
+					yield res } }
+		} else {
+			yield* this } }),
+
+	map: async function*(func){
+		yield* this.iter(function(elem, i){
+			return [func.call(this, elem, i)] }) },
+	filter: async function*(func){
+		yield* this.iter(function(elem, i){
+			return func.call(this, elem, i) ?
+	   			[elem]
+				: [] }) },
+	// NOTE: there is not much point in .reduceRight(..) in an async 
+	// 		generator as we'll need to fully unwind it then go from the 
+	// 		end...
+	reduce: async function(func, state){
+		this.iter(function(elem, i){
+			state = func.call(this, state, elem, i) 
+			return [] })
+		return state },
+
+	// XXX TEST...
+	chain: async function*(...next){
+		yield* next
+			.reduce(function(cur, next){
+				return next(cur) }, this) },
+
+	flat: async function*(){
+		for await(var e of this){
+			if(e instanceof Array){
+				yield* e
+			} else {
+				yield e }}},
+
+	concat: async function*(other){
+		yield* this
+		yield* other },
+	push: async function*(elem){
+		yield* this
+		yield elem },
+	unsift: async function*(elem){
+		yield elem 
+		yield* this },
+
+	join: async function(){
+		return [...(await this)]
+			.join(...arguments) },
+
+	// XXX
+	// 	slice -- not sure if we need this...
+	// 	...
 })
 
-//AsyncGeneratorMixin(AsyncGeneratorPrototype)
-//AsyncGeneratorProtoMixin(AsyncGeneratorPrototype.prototype)
+AsyncGeneratorMixin(AsyncGenerator.prototype)
+AsyncGeneratorProtoMixin(AsyncGenerator.prototype.prototype)
 
 
 

package/main.js

@@ -22,6 +22,7 @@ module.patchDate = require('./Date').patchDate
 
 // Additional types...
 module.containers = require('./containers')
+module.func = require('./Function')
 module.generator = require('./generator')
 module.event = require('./event')
 module.runner = require('./runner')
@@ -31,7 +32,9 @@ module.runner = require('./runner')
 module.STOP = object.STOP
 
 // frequently used stuff...
+module.AsyncFunction = module.func.AsyncFunction
 module.Generator = module.generator.Generator
+module.AsyncGenerator = module.generator.AsyncGenerator
 // XXX doc...
 module.iter = module.generator.iter
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ig-types",
-  "version": "6.15.1",
+  "version": "6.16.1",
   "description": "Generic JavaScript types and type extensions...",
   "main": "main.js",
   "scripts": {
@@ -23,7 +23,8 @@
   },
   "homepage": "https://github.com/flynx/types.js#readme",
   "dependencies": {
-    "ig-object": "^5.4.16",
+    "ig-object": "^6.0.0",
+    "ig-stoppable": "^2.0.0",
     "object-run": "^1.0.1"
   },
   "devDependencies": {