C. Scott Ananian
ecmascript at cscott.net
Tue Jun 9 15:46:51 UTC 2015
On Tue, Jun 9, 2015 at 11:11 AM, Mark S. Miller <erights at google.com> wrote:
> Ok, thanks for the example. I understand your rationale. This is what I
> asked for but not what I was really looking for. Can we come up with an
> example where class and species usefully differ where neither is Promise?
> IOW, where the species a proper subclass of Promise and a proper superclass
> of the class in question.
> species: The generic class of an object. This is normally the same as the
class of an object, otherwise it is a class which describes the generic
> group of classes to which a particular class belongs. Note that this does
not necessarily have to be class from the same branch of the hierarchy.
But I was not able to find this any examples where the species was not
"from the same branch of the hierachy" in my smalltalk research. The only
examples I could dig up had the species equal to the top-level superclass
for the "generic group", like Array, Promise, etc.
But I'm not a smalltalk expert, by any means. I hope that some of the
smalltalkers among us (or those who work with former smalltalkers?) might
be able to come up with more examples.
That said, I think the WeakPromise and TimeoutPromise examples are
Further, note that if you are using the `prfun` library, the "Promise" you
are using is actually a subclass of `globals.Promise`. This is so that
`prfun` can add all of its fun `Promise.try` etc methods without polluting
the global `Promise`.
So in that case: `PrFunPromise extends Promise`, `TimeoutPromise extends
PrFunPromise`, and `TimeoutPromise[Symbol.species] = PrFunPromise`.
But that's probably not really what you were looking for, either.
On Tue, Jun 9, 2015 at 11:04 AM, Allen Wirfs-Brock <allen at wirfs-brock.com>
> I generally agree. You invoke one of these methods on a specific Promise
> constructor, presumably with the intend that it is an instance to that
> constructor you expect to get back.
> For example, compare the likely intent of:
> It seems just like what we discussed for Promise.resolve
I generally agree, and would not object to travelling down this path.
*However*, note that the implementations given for `Promise.all` and
`Promise.race` use Promises in two different ways: (1) every element of the
array argument has `C1.resolve(elem).then(....)` applied to it, and (2) the
result is constructed with `NewPromiseCapability(C2)`. It's not entirely
clear to me that C1 and C2 should be the same. Consider the
`TimeoutPromise`: do we want to apply a timeout to every element
individually *and* to the result as a whole?
It seems that C1 might use species (to avoid the timeout/weak reference),
but C2 ignore it (to apply the timeout/weak reference to the final result)
The idea that `WeakPromise.all(x)` means `WeakPromise.resolve(x).all()` is
a little bit surprising (because the constructed `WeakPromise` is not
visible externally and thus the result honors species and is not itself a
`WeakPromise`), but does have a consistency of its own. So I'm torn.
But if we decided that `WeakPromise.all()` should return a `WeakPromise`
then I'd suggest that we change step 6 from:
> Let promiseCapability be NewPromiseCapability(C).
> Let promiseCapability be NewPromiseCapability(this).
in both `Promise.all` and `Promise.race`, but leave the definition of C
otherwise alone, so that internally-created promises honor the species.
-------------- next part --------------
An HTML attachment was scrubbed...
More information about the es-discuss