ig-types 6.16.2 → 6.17.0

package/Array.js

@@ -482,6 +482,35 @@ object.Mixin('ArrayProtoMixin', 'soft', {
 			this.constructor.zip(this, func, ...arrays)
 			: this.constructor.zip(func, this, ...arrays) },
 
+	// Insert new values between elements of an array
+	//
+	//	.between(value)
+	//		-> array
+	//
+	//	.between(func)
+	//		-> array
+	//
+	//	func([a, b], from_index, to_index, array)
+	//		-> elem
+	//
+	between: function(func){
+		var res = []
+		// NOTE: we skip the last element...
+		for(var i=0; i < this.length; i+=1){
+			var pair = new Array(2)
+			i in this ?
+				res.push(pair[0] = this[i])
+				: (res.length += 1)
+			if(i+1 >= this.length){
+				break }
+			i+1 in this
+				&& (pair[1] = this[i+1])
+			res.push(
+				typeof(func) == 'function' ?
+					func.call(this, pair, i, res.length, this)
+					: func) }
+		return res },
+
 	// get iterator over array...
 	//
 	//	Array.iter()

package/Promise.js

@@ -294,6 +294,22 @@ object.Constructor('IterablePromise', Promise, {
 			.then(function(){ 
 				return res }) },
 
+	// XXX BETWEEN...
+	between: function(func){
+		var i = 0
+		var j = 0
+		var prev
+		return this.constructor(this,
+			function(e){
+				return i++ > 0 ?
+					[
+						typeof(func) == 'function' ?
+							func.call(this, [prev, e], i, i + j++)
+							: func,
+						e,
+					]
+					: [e] }) },
+
 	// XXX .chain(..) -- see generator.chain(..)
 
 	flat: function(depth=1){

package/README.md

@@ -30,6 +30,7 @@ Library of JavaScript type extensions, types and utilities.
     - [`<array>.toMap(..)`](#arraytomap)
     - [`Array.zip(..)` / `<array>.zip(..)`](#arrayzip--arrayzip)
     - [`Array.iter(..)` / `<array>.iter()`](#arrayiter--arrayiter)
+    - [`<array>.between(..)`](#arraybetween)
     - [Abortable `Array` iteration](#abortable-array-iteration)
       - [`array.STOP` / `array.STOP(..)`](#arraystop--arraystop)
       - [`<array>.smap(..)` / `<array>.sfilter(..)` / `<array>.sreduce(..)` / `<array>.sforEach(..)`](#arraysmap--arraysfilter--arraysreduce--arraysforeach)
@@ -75,6 +76,7 @@ Library of JavaScript type extensions, types and utilities.
       - [`<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>.between(..)`](#promise-iterbetween)
       - [`<promise-iter>.flat(..)`](#promise-iterflat)
       - [`<promise-iter>.reverse()`](#promise-iterreverse)
       - [`<promise-iter>.concat(..)`](#promise-iterconcat)
@@ -100,6 +102,8 @@ Library of JavaScript type extensions, types and utilities.
       - [`<generator>.iter(..)`](#generatoriter-1)
       - [`<generator>.map(..)` / `<generator>.filter(..)`](#generatormap--generatorfilter)
       - [`<generator>.reduce(..)` / `<generator>.greduce(..)`](#generatorreduce--generatorgreduce)
+      - [`<generator>.forEach(..)` (EXPERIMENTAL)](#generatorforeach-experimental)
+      - [`<generator>.between(..)`](#generatorbetween)
       - [`<generator>.slice(..)`](#generatorslice)
       - [`<generator>.at(..)` / `<generator>.gat(..)`](#generatorat--generatorgat)
       - [`<generator>.flat(..)`](#generatorflat)
@@ -116,6 +120,7 @@ Library of JavaScript type extensions, types and utilities.
       - [`<generator>.unshift(..)` / `<generator>.push(..)`](#generatorunshift--generatorpush-1)
       - [`<Generator>.slice(..)`](#generatorslice-1)
       - [`<Generator>.map(..)` / `<Generator>.filter(..)` / `<Generator>.reduce(..)` / `<Generator>.flat()`](#generatormap--generatorfilter--generatorreduce--generatorflat)
+      - [`<Generator>.between(..)`](#generatorbetween-1)
       - [`<Generator>.toArray()`](#generatortoarray-1)
       - [`<Generator>.join(..)`](#generatorjoin-1)
       - [`<Generator>.then(..)` / `<Generator>.catch(..)` / `<Generator>.finally(..)`](#generatorthen--generatorcatch--generatorfinally-1)
@@ -736,6 +741,19 @@ Return an iterator/generator from the current array.
 This is mostly useful in combination with the [Generator extensions and utilities](#generator-extensions-and-utilities)
 
 
+### `<array>.between(..)`
+
+```bnf
+<array>.between(<value>)
+    -> <array>
+<array>.between(<func>)
+    -> <array>
+
+<func>([<pre>, <post>], <index-in>, <index-out>, <array>)
+    -> <value>
+```
+
+
 ### Abortable `Array` iteration
 
 A an alternative to `Array`'s `.map(..)` / `.filter(..)` / .. methods with ability to
@@ -1657,6 +1675,19 @@ Note that since `.reduce(..)` handler's execution order can not be known,
 there is no point in implementing `.reduceRigth(..)`.
 
 
+### `<promise-iter>.between(..)`
+
+```bnf
+<promise-iter>.between(<value>)
+    -> <promise-iter>
+<promise-iter>.between(<func>)
+    -> <promise-iter>
+
+<func>([<pre>, <post>], <index-in>, <index-out>, <promise-iter>)
+    -> <value>
+```
+
+
 #### `<promise-iter>.flat(..)`
 
 ```bnf
@@ -2135,6 +2166,31 @@ XXX .reduce(..) can return a non-iterable -- test and document this case...
     ...compare with Array.prototype.reduce(..)
 -->
 
+#### `<generator>.forEach(..)` (EXPERIMENTAL)
+
+```bnf
+<generator>.forEach(<func>)
+    -> <array>
+```
+
+This is different from the above in that this will unwind the `<generator>`.
+
+Note that this differs from `<array>.forEach(..)` in that his will return the 
+resulting array, essentially behaving like `.map(..)`.
+
+
+#### `<generator>.between(..)`
+
+```bnf
+<generator>.between(<value>)
+    -> <generator>
+<generator>.between(<func>)
+    -> <generator>
+
+<func>([<pre>, <post>], <index-in>, <index-out>, <generator>)
+    -> <value>
+```
+
 
 #### `<generator>.slice(..)`
 
@@ -2416,6 +2472,19 @@ but return a `<Generator>`.
 <!-- XXX -->
 
 
+#### `<Generator>.between(..)`
+
+```bnf
+<Generator>.between(<value>)
+    -> <Generator>
+<Generator>.between(<func>)
+    -> <Generator>
+
+<func>([<pre>, <post>], <index-in>, <index-out>, <Generator>)
+    -> <value>
+```
+
+
 #### `<Generator>.toArray()`
 
 Return a function that will return a `<generator>` output as an `Array`.

package/event.js

@@ -132,9 +132,12 @@ object.Constructor('Eventful', {
 		return this },
 	unbind: function(context, handler){
 		var handlers = 
-			(this.handlerLocation == 'method' ?
+			this.handlerLocation == 'method' ?
 				method.__event_handlers__
-			: (context.__event_handlers__ || {})[this.name]) || []
+			//: (context.__event_handlers__ || {})[this.name]) || []
+			: context.hasOwnProperty('__event_handlers__') ?
+				(context.__event_handlers__ || {})[this.name] || []
+			: []
 		handlers.splice(0, handlers.length,
 			...handlers.filter(function(h){
 				return h !== handler
@@ -150,7 +153,10 @@ object.Constructor('Eventful', {
 		// context (default)...
 		// NOTE: these are allways called...
 		handlers = handlers
-			.concat((context.__event_handlers__ || {})[this.name] || [])
+			//.concat((context.__event_handlers__ || {})[this.name] || [])
+			.concat(context.hasOwnProperty('__event_handlers__') ?
+				(context.__event_handlers__ || {})[this.name] || []
+				: [])
 
 		// NOTE: this will stop event handling if one of the handlers 
 		// 		explicitly returns false...
@@ -334,7 +340,8 @@ module.EventHandlerMixin = object.Mixin('EventHandlerMixin', {
 		evt in this ?
 			// XXX add a better check...
 			this[evt](module.TRIGGER, ...args)
-			: this.__event_handlers__
+			//: this.__event_handlers__
+			: this.hasOwnProperty('__event_handlers__')
 				&& (this.__event_handlers__[evt] || [])
 					.forEach(function(h){ h(evt, ...args) }) 
 		return this },

package/generator.js

@@ -223,6 +223,15 @@ object.Mixin('GeneratorMixin', 'soft', {
 	reduce: makeGenerator('reduce'),
 	reduceRight: makeGenerator('reduceRight'),
 
+	between: makeGenerator('between'),
+
+	// XXX EXPERIMENTAL
+	// XXX add .toString(..) to this???
+	forEach: function(func){
+		var that = this
+		return function(){
+			return that(...arguments).forEach(func) } },
+
 	// non-generators...
 	//
 	toArray: function(){
@@ -397,6 +406,26 @@ object.Mixin('GeneratorProtoMixin', 'soft', {
 	greduce: function*(func, res){
 		yield this.reduce(...arguments) },
 
+	between: stoppable(function*(func){
+		var i = 0
+		var j = 0
+		var prev
+		for(var e of this){
+			if(i > 0){
+				yield typeof(func) == 'function' ?
+					func.call(this, [prev, e], i-1, i + j++, this)
+					: func }
+			prev = e
+			yield e
+			i++ } }),
+
+	// NOTE: this is a special case in that it will unwind the generator...
+	// NOTE: this is different from <array>.forEach(..) in that this will
+	// 		return the resulting array.
+	// XXX EXPERIMENTAL
+	forEach: function(func){
+		return [...this].map(func) },
+
 	pop: function(){
 		return [...this].pop() },
 	// XXX this needs the value to be iterable...
@@ -490,6 +519,9 @@ object.Mixin('AsyncGeneratorMixin', 'soft', {
 	map: makeGenerator('async', 'map'),
 	filter: makeGenerator('async', 'filter'),
 	reduce: makeGenerator('async', 'reduce'),
+
+	// XXX TEST...
+	between: makeGenerator('async', 'between'),
 })
 
 var AsyncGeneratorProtoMixin =
@@ -547,6 +579,21 @@ object.Mixin('AsyncGeneratorProtoMixin', 'soft', {
 			return [] })
 		return state },
 
+	// XXX BETWEEN...
+	between: async function*(func){
+		var i = 0
+		var j = 0
+		var prev
+		yield* this.iter(function(e){
+			return i++ > 0 ?
+				[
+					typeof(func) == 'function' ?
+						func.call(this, [prev, e], i, i + j++, this)
+						: func,	
+					e,
+				]
+				: [e] }) },
+
 	// XXX TEST...
 	chain: async function*(...next){
 		yield* next

package/package.json

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