alterntive approach to shorten reference chains

Store `.ref`erences on the `Action`s (now generalised as `Handle`s)
instead of directly on the `Future`s. That way, when a handle is passed
down `near()` to the eventual resolution, even the reference from the
outermost future is only two hops (`.handle.ref`) instead of many.

Author: bergus

src/Action.js

@@ -1,5 +1,8 @@
-export default class Action {
+import Handle from './Handle'
+
+export default class Action extends Handle {
 	constructor (promise) {
+		super(null)
 		this.promise = promise
 	}
 
@@ -25,4 +28,9 @@ export default class Action {
 		} // else
 		this.handle(result)
 	}
+
+	run () {
+		this.ref._runAction(this)
+		super.run()
+	}
 }

src/Handle.js

@@ -0,0 +1,24 @@
+export default class Handle {
+	constructor (ref) {
+		this.ref = ref
+		this.length = 0
+	}
+	near () {
+		if (this.ref.handle !== this) {
+			this.ref = this.ref.near()
+		}
+		return this.ref
+	}
+	_add (action) {
+		this[this.length++] = action
+		// potential for flattening the tree here
+		return this
+	}
+	run () {
+		for (let i = 0; i < this.length; ++i) {
+			this.ref._runAction(this[i])
+			this[i] = void 0
+		}
+		this.length = 0
+	}
+}

src/Promise.js

@@ -6,6 +6,7 @@ import makeEmitError from './emitError'
 import maybeThenable from './maybeThenable'
 import { PENDING, FULFILLED, REJECTED, NEVER } from './state'
 import { isNever, isSettled } from './inspect'
+import Handle from './Handle'
 
 import then from './then'
 import map from './map'
@@ -51,9 +52,7 @@ class Core {
 export class Future extends Core {
 	constructor () {
 		super()
-		this.ref = void 0
-		this.action = void 0
-		this.length = 0
+		this.handle = void 0
 	}
 
 	// then :: Promise e a -> (a -> b) -> Promise e b
@@ -113,77 +112,82 @@ export class Future extends Core {
 
 	// near :: Promise e a -> Promise e a
 	near () {
-		if (!this._isResolved()) {
+		if (this.handle === void 0) {
 			return this
 		}
-
-		this.ref = this.ref.near()
-		return this.ref
+		return this.handle.near()
 	}
 
 	// state :: Promise e a -> Int
 	state () {
-		return this._isResolved() ? this.ref.near().state() : PENDING
+		// return this._isResolved() ? this.handle.near().state() : PENDING
+		var n = this.near()
+		return n === this ? PENDING : n.state()
 	}
 
 	_isResolved () {
-		return this.ref !== void 0
+		return this.near() !== this
 	}
 
 	_when (action) {
 		this._runAction(action)
 	}
 
 	_runAction (action) {
-		if (this.action === void 0) {
-			this.action = action
+		if (this.handle) {
+			this.handle._add(action)
+		} else if (action.ref != null && action.ref !== this) {
+			this.handle = new Handle(this)
+			this.handle._add(action)
 		} else {
-			this[this.length++] = action
+			this.handle = action
+			this.handle.ref = this
 		}
 	}
 
 	_resolve (x) {
-		this._become(resolve(x))
-	}
-
-	_fulfill (x) {
-		this._become(new Fulfilled(x))
-	}
-
-	_reject (e) {
+		x = resolve(x)
 		if (this._isResolved()) {
 			return
 		}
-
-		this.__become(new Rejected(e))
+		this._become(x)
 	}
 
-	_become (p) {
+	_fulfill (x) {
 		if (this._isResolved()) {
 			return
 		}
-
-		this.__become(p)
+		this._become(new Fulfilled(x))
 	}
 
-	__become (p) {
-		this.ref = p === this ? cycle() : p
-
-		if (this.action === void 0) {
+	_reject (e) {
+		if (this._isResolved()) {
 			return
 		}
-
-		taskQueue.add(this)
+		this._become(new Rejected(e))
 	}
 
-	run () {
-		const p = this.ref.near()
-		p._runAction(this.action)
-		this.action = void 0
+	_become (p) {
+		if (p === this) {
+			p = cycle()
+		}
 
-		for (let i = 0; i < this.length; ++i) {
-			p._runAction(this[i])
-			this[i] = void 0
+		if (this.handle) {
+			// assert: this.handle.ref === this
+			this.handle.ref = p
+			if (isSettled(p)) {
+				taskQueue.add(this.handle)
+			} else {
+				p._runAction(this.handle)
+			}
+		} else {
+			if (isSettled(p)) {
+				// for not unnecessarily creating handles that never see any actions
+				// works well because it has a near() method
+				this.handle = p
+			} else {
+				this.handle = new Handle(p)
+			}
 		}
 	}
 }

src/coroutine.js

@@ -3,8 +3,9 @@
 import Action from './Action'
 
 export default function (resolve, iterator, promise) {
-	new Coroutine(resolve, iterator, promise).run()
-	// taskQueue.add(new Coroutine(resolve, iterator, promise))
+	new Coroutine(resolve, iterator, promise).start()
+	// taskQueue.add(new Coroutine(resolve, iterator, promise)) // with start for run
+	// resolve(undefined)._when(new Coroutine(resolve, iterator, promise))
 	return promise
 }
 
@@ -16,7 +17,7 @@ class Coroutine extends Action {
 		this.throw = iterator.throw.bind(iterator)
 	}
 
-	run () {
+	start () {
 		this.tryCall(this.next, void 0)
 	}
 

test/coroutine-test.js

@@ -34,13 +34,44 @@ describe('coroutine', function () {
 			.then(x => assert.strictEqual(x, expected))
 	})
 
+	it('should fulfill on return', () => {
+		const expected = {}
+		const f = coroutine(function *(a) {
+			return a
+		})
+
+		return f(expected)
+			.then(x => assert.strictEqual(x, expected))
+	})
+
 	it('should reject on uncaught exception', () => {
 		const expected = new Error()
 		const f = coroutine(function *(a) {
-			yield reject(a)
+			throw a
 		})
 
 		return f(expected)
 			.then(assert.ifError, e => assert.strictEqual(e, expected))
 	})
+	
+	it('should be able to wait for the same promise multiple times', () => {
+		const f = coroutine(function *(a) {
+			var p = fulfill(a)
+			return (yield p) + (yield p)
+		})
+
+		return f('a').then(x => assert.equal(x, 'aa'))
+	})
+	
+	it('should be able to loop multiple promises', () => {
+		const f = coroutine(function *(a) {
+			var arr = []
+			for (let i=0; i<5; i++) {
+				arr.push(yield delay(1, i))
+			}
+			return arr
+		})
+
+		return f().then(x => assert.deepEqual(x, [0, 1, 2, 3, 4]))
+	})
 })