Re: Deprecating Future's .then()

On 4/06/13 11:48 PM, Anne van Kesteren wrote:
> On Tue, Jun 4, 2013 at 8:55 AM, Sam Tobin-Hochstadt <[email protected]> wrote:
>> Thinking about this more, I'm now unsure why both `fulfill` and
>> `resolve` are needed given the semantics of `.chain()` and `.then()`
>> described below.
>>
>> In particular, if `.then()` chains recursively *before* calling the
>> callback, then there's no difference between:
>>
>>      Future.resolve(x).then(v => ...)
>>
>> and
>>
>>      Future.fulfill(x).then(v => ...)
>>
>> even when `x` is a promise.  The only way to observe this is with `.chain()`.
>>
>> Thoughts?
> I'm just going to try to repeat what you said here to make sure I understand.
>
> Promise.resolve(val) creates a promise of val, regardless of whether
> val is a promise, has a callable then property, or anything like that.
> (In that sense it is equivalent to Future.accept() today.)
>
> promise.then() keeps unwrapping promise's internal value until it no
> longer has a callable then property at which point it invokes the
> relevant callback passed to promise.then(). (Exact algorithm TBD after
> broader agreement.)
>
> promise.chain() invokes its relevant callback with promise's internal value.
>
> promise.then() and promise.chain() return value (newPromise) is
> resolved with the return value of their callbacks after it has been
> unwrapped once.

What is the algorithm for this single unwrapping which is done to the 
return value of .then() / .chain() callbacks? Is it something like:

Assuming the return value from the callback (result) is to be 
conditionally unwrapped and then fulfil the future (f) with associated 
resolver (r):

     function unwrap(result, f, r) {
         if (result && typeof result.chain === 'function') 
result.chain(accept, reject);
         else if (result && typeof result.then === 'function') 
result.then(accept, reject);
         else accept(result);

         function accept(val) { r.accept(val); }
         function reject(err) { r.reject(val); }
     }


Or should 'chain-ables' be restricted to `result instanceof Future`?

Can .chain() be called with missing accept/reject callbacks? e.g.

     .chain(null, function(err) { throw err; });

What is the behavior of the default accept / reject callbacks in this case?