Promise API

I see one more problem with this. As the ecosystem is now, there is not just ES2015 Promise (native or polyfilled), that is, the global Promise, but many frameworks use different implementations (Parse has its own Parse.Promise, Angular has $q, there are Q and Bluebird implementations which are also dependencies of some libraries).

So, Amber must actually be able to provide functionality for all major implementations.

The way how to achieve it is, IMO, having AbstractPromise base class with basic functionality, using only minimal subset (.then(null, fn) instead of .catch(fn) etc.) and letting the rest on subclasses, while providing subclass Promise that wraps global Promise expecting it to be ES2015 one, but adding other AbstractPromise-derived wrappers for other types of promises, installable as libraries.

Herby Vojčík wrote:

Herby Vojčík wrote:

Second version, after Philippe Back's suggestions:

Object >> asPromise
"returns a Promise resolved to self"
<return JS_Promise.resolve(self)>

JSObjectProxy >> asPromise
<return JS_Promise.resolve(self["@jsObject"])>

Promise class >> forBlock: aBlock
"Inspired by GNU Smalltalk API.
Returns a Promise fulfilled or rejected by `aBlock value`.
Only usable for synchronous operations in aBlock."
^ aBlock valueAsPromise

BlockClosure >> valueAsPromise
<return JS_Promise.resolve().then(function () {return self._value()})>

Promise class >> asyncForBlock: aBlock
"aBlock is called with PromiseModel object.
`aPromiseModel value: x` resolves the promise.
`aPromiseModel signal: y` rejects the promise.
Returns a Promise that eventually
succeeds or fails, asynchronously."
^ aBlock newPromise

BlockClosure >> newPromise
"self is called with PromiseModel object.
`aPromiseModel value: x` resolves the promise.
`aPromiseModel signal: y` rejects the promise.
Returns a Promise that eventually
succeeds or fails, asynchronously."
<return new JS_Promise(function (resolve, reject) {
return self._value_($globals.PromiseModel._newResolve_reject_(
resolve, reject
));
})>

PromiseModel class >> newResolve: aBlock reject: anotherBlock
"Creates a PromiseModel instance
that calls aBlock when anInstance value: is sent
and calls anotherBlock when anInstance signal: is sent."

PromiseModel >> value: anObject
"Resolves underlying promise."

PromiseModel >> signal: anObject
"Rejects underlying promise."

Collection >> allAsPromise
"Returns a collection that succeeds

"Returns a promise that ...

when all promises in self asArray succeed.
It is resolved with array of their results."
^ self asArray allAsPromise

Array >> allAsPromise
<return JS_Promise.all(self._collect_(function (each) {
return each._asPromise();
}))>

Promise class >> all: aCollection
"Returns a collection that succeeds

"Returns a promise that ...

when all promises in aCollection succeed.
It is resolved with array of their results."
^ aCollection allAsPromise

Collection >> anyAsPromise
"Returns a collection that succeeds

"Returns a promise that ...

when any of the promises in self asArray succeed.
It is resolved with result of the first one that resolves."
^ self asArray anyAsPromise

Array >> anyAsPromise
<return JS_Promise.any(self._collect_(function (each) {
return each._asPromise();
}))>

Promise class >> any: aCollection
"Returns a collection that succeeds

"Returns a promise that ...

when any of the promises in aCollection succeed.
It is resolved with result of the first one that resolves."
^ aCollection anyAsPromise

Promise >> all:then:on:do:
Promise >> all:then:catch:
Promise >> all:then:
Promise >> then:on:do:
Promise >> then:catch:
Promise >> then:
"all: nadicBlock
then: aBlockOrCollectionOfBlocks
on: aClass do: catchBlock
catch: catchAllBlock"
<return self
// if all: present
.then(function(args) {
return nadicBlock._valueWithPossibleArguments_(args);
})
// if then: arg is aBlock
.then(function (result) {
return aBlock._value_(result);
})
// if then: arg is collection of blocks,
// thenArg do: [ :each | "add .then call as above" ]
// if on: aClass do: catchBlock present
.catch(function (ex) {
if ($recv(ex)._isKindOf_(aClass)
return catchBlock._value_(ex);
else throw ex;
})
// if catch: catchAllBlock is present
.catch(function (ex) {
return catchAllBlock._value_(ex);
})
>

As you can see, Promise.reject API is not wrapped, but I don't it's
needed than often and can always be done with `[ :m | m signal: 'foo' ]
newPromise`.

For example:

(fetch value: url)
then: {
[ :data | JSON parse: data].
[ :parsed |
parsed at: #id ifAbsent: [ Error signal: "Missing name."].
parsed ].
...
}
catch: [ :e | self handleError: e ofUrl: url ]

and creating promise of your own:

[ :model |
anObject apiWithCallback: [ :err :result | err
ifNotNil: [ model signal: err ]
ifNil: [ console log: result. model value: result payload ] ]
] newPromise

Opinions?

Thanks, Herby

--
You received this message because you are subscribed to the Google Groups "amber-lang" group.
To unsubscribe from this group and stop receiving emails from it, send an email to [hidden email].
For more options, visit https://groups.google.com/d/optout.

There is one more problem as I see it: there surely will be promises created as inline objects, as here: https://github.com/requirejs/alameda-prim/commit/9ad546fff02b765ebe6943929218d07c1f2c655d#diff-aeb8d45ae32f6d853d4ac616eb5875b9R138. This means, we must actually implement all:then:on:do:catch: family of messages in JSObjectProxy as well, and catch all thenables dynamically.

What also means, there is enough to wrap the official global Promise, let the others be caught by JSObjectProxy, and people can wrap other implementations if they see it fit / it helps them with performance issues / it allows them create promises of a specific library.

So I would say, create a base class called Thenable with *then:* family. Then, subclass Promise wrapping global ES2015 Promise and also *then:* family in JSObjectProxy which can test dynamically if typeof self.then === "function" && (self.catch == null || typeof self.catch === "function") and if yes, delegate to Thenable to do the work on self.

Herby

Herby Vojčík wrote:

I see one more problem with this. As the ecosystem is now, there is not
just ES2015 Promise (native or polyfilled), that is, the global Promise,
but many frameworks use different implementations (Parse has its own
Parse.Promise, Angular has $q, there are Q and Bluebird implementations
which are also dependencies of some libraries).

So, Amber must actually be able to provide functionality for all major
implementations.

The way how to achieve it is, IMO, having AbstractPromise base class
with basic functionality, using only minimal subset (.then(null, fn)
instead of .catch(fn) etc.) and letting the rest on subclasses, while
providing subclass Promise that wraps global Promise expecting it to be
ES2015 one, but adding other AbstractPromise-derived wrappers for other
types of promises, installable as libraries.

Herby Vojčík wrote:

Herby Vojčík wrote:

Second version, after Philippe Back's suggestions:

Object >> asPromise
"returns a Promise resolved to self"
<return JS_Promise.resolve(self)>

JSObjectProxy >> asPromise
<return JS_Promise.resolve(self["@jsObject"])>

Promise class >> forBlock: aBlock
"Inspired by GNU Smalltalk API.
Returns a Promise fulfilled or rejected by `aBlock value`.
Only usable for synchronous operations in aBlock."
^ aBlock valueAsPromise

BlockClosure >> valueAsPromise
<return JS_Promise.resolve().then(function () {return self._value()})>

Promise class >> asyncForBlock: aBlock
"aBlock is called with PromiseModel object.
`aPromiseModel value: x` resolves the promise.
`aPromiseModel signal: y` rejects the promise.
Returns a Promise that eventually
succeeds or fails, asynchronously."
^ aBlock newPromise

BlockClosure >> newPromise
"self is called with PromiseModel object.
`aPromiseModel value: x` resolves the promise.
`aPromiseModel signal: y` rejects the promise.
Returns a Promise that eventually
succeeds or fails, asynchronously."
<return new JS_Promise(function (resolve, reject) {
return self._value_($globals.PromiseModel._newResolve_reject_(
resolve, reject
));
})>

PromiseModel class >> newResolve: aBlock reject: anotherBlock
"Creates a PromiseModel instance
that calls aBlock when anInstance value: is sent
and calls anotherBlock when anInstance signal: is sent."

PromiseModel >> value: anObject
"Resolves underlying promise."

PromiseModel >> signal: anObject
"Rejects underlying promise."

Collection >> allAsPromise
"Returns a collection that succeeds

"Returns a promise that ...

when all promises in self asArray succeed.
It is resolved with array of their results."
^ self asArray allAsPromise

Array >> allAsPromise
<return JS_Promise.all(self._collect_(function (each) {
return each._asPromise();
}))>

Promise class >> all: aCollection
"Returns a collection that succeeds

"Returns a promise that ...

when all promises in aCollection succeed.
It is resolved with array of their results."
^ aCollection allAsPromise

Collection >> anyAsPromise
"Returns a collection that succeeds

"Returns a promise that ...

when any of the promises in self asArray succeed.
It is resolved with result of the first one that resolves."
^ self asArray anyAsPromise

Array >> anyAsPromise
<return JS_Promise.any(self._collect_(function (each) {
return each._asPromise();
}))>

Promise class >> any: aCollection
"Returns a collection that succeeds

"Returns a promise that ...

when any of the promises in aCollection succeed.
It is resolved with result of the first one that resolves."
^ aCollection anyAsPromise

Promise >> all:then:on:do:
Promise >> all:then:catch:
Promise >> all:then:
Promise >> then:on:do:
Promise >> then:catch:
Promise >> then:
"all: nadicBlock
then: aBlockOrCollectionOfBlocks
on: aClass do: catchBlock
catch: catchAllBlock"
<return self
// if all: present
.then(function(args) {
return nadicBlock._valueWithPossibleArguments_(args);
})
// if then: arg is aBlock
.then(function (result) {
return aBlock._value_(result);
})
// if then: arg is collection of blocks,
// thenArg do: [ :each | "add .then call as above" ]
// if on: aClass do: catchBlock present
.catch(function (ex) {
if ($recv(ex)._isKindOf_(aClass)
return catchBlock._value_(ex);
else throw ex;
})
// if catch: catchAllBlock is present
.catch(function (ex) {
return catchAllBlock._value_(ex);
})
>

As you can see, Promise.reject API is not wrapped, but I don't it's
needed than often and can always be done with `[ :m | m signal: 'foo' ]
newPromise`.

For example:

(fetch value: url)
then: {
[ :data | JSON parse: data].
[ :parsed |
parsed at: #id ifAbsent: [ Error signal: "Missing name."].
parsed ].
...
}
catch: [ :e | self handleError: e ofUrl: url ]

and creating promise of your own:

[ :model |
anObject apiWithCallback: [ :err :result | err
ifNotNil: [ model signal: err ]
ifNil: [ console log: result. model value: result payload ] ]
] newPromise

Opinions?

Thanks, Herby

--
You received this message because you are subscribed to the Google Groups "amber-lang" group.
To unsubscribe from this group and stop receiving emails from it, send an email to [hidden email].
For more options, visit https://groups.google.com/d/optout.

[hidden email] wrote:

Ok I see.

We need a couple of real examples (like in the Async Javascript book) I
think, so that we can explore a couple cases properly.

Phil

I in fact think that implementing just the bare minimum I envisioned is doable fast (in fact only thing needed is to do the JSObjectProxy part, but I would include the Thenable class there as well, so the delegation is put up properly). Creating the promises is then still hard because it must use JS API which is less Smalltalk-like ('reject value: x' is not as English-sentence-like like 'model signal: x'), but the main part will be there.

I am just a bit tired to do it just now, but I can probably do it somewhere in the weekend, and even release it. I want to add more promises to startup process, mainly, making amber.initialize({...}) return a promise, but for that would need more work with polyfilling for non-Promise environments.

On Jan 29, 2016 10:24 PM, "Herby Vojčík" <[hidden email]
<mailto:[hidden email]>> wrote:

    There is one more problem as I see it: there surely will be promises
    created as inline objects, as here:
    https://github.com/requirejs/alameda-prim/commit/9ad546fff02b765ebe6943929218d07c1f2c655d#diff-aeb8d45ae32f6d853d4ac616eb5875b9R138.
    This means, we must actually implement all:then:on:do:catch: family
    of messages in JSObjectProxy as well, and catch all thenables
    dynamically.

    What also means, there is enough to wrap the official global
    Promise, let the others be caught by JSObjectProxy, and people can
    wrap other implementations if they see it fit / it helps them with
    performance issues / it allows them create promises of a specific
    library.

    So I would say, create a base class called Thenable with *then:*
    family. Then, subclass Promise wrapping global ES2015 Promise and
    also *then:* family in JSObjectProxy which can test dynamically if
    typeof self.then === "function" && (self.catch == null || typeof
    self.catch === "function") and if yes, delegate to Thenable to do
    the work on self.

    Herby

    Herby Vojčík wrote:

        I see one more problem with this. As the ecosystem is now, there
        is not
        just ES2015 Promise (native or polyfilled), that is, the global
        Promise,
        but many frameworks use different implementations (Parse has its own
        Parse.Promise, Angular has $q, there are Q and Bluebird
        implementations
        which are also dependencies of some libraries).

        So, Amber must actually be able to provide functionality for all
        major
        implementations.

        The way how to achieve it is, IMO, having AbstractPromise base class
        with basic functionality, using only minimal subset (.then(null, fn)
        instead of .catch(fn) etc.) and letting the rest on subclasses,
        while
        providing subclass Promise that wraps global Promise expecting
        it to be
        ES2015 one, but adding other AbstractPromise-derived wrappers
        for other
        types of promises, installable as libraries.

        Herby Vojčík wrote:



            Herby Vojčík wrote:

                Second version, after Philippe Back's suggestions:

                Object >> asPromise
                "returns a Promise resolved to self"
                <return JS_Promise.resolve(self)>

                JSObjectProxy >> asPromise
                <return JS_Promise.resolve(self["@jsObject"])>

                Promise class >> forBlock: aBlock
                "Inspired by GNU Smalltalk API.
                Returns a Promise fulfilled or rejected by `aBlock value`.
                Only usable for synchronous operations in aBlock."
                ^ aBlock valueAsPromise

                BlockClosure >> valueAsPromise
                <return JS_Promise.resolve().then(function () {return
                self._value()})>

                Promise class >> asyncForBlock: aBlock
                "aBlock is called with PromiseModel object.
                `aPromiseModel value: x` resolves the promise.
                `aPromiseModel signal: y` rejects the promise.
                Returns a Promise that eventually
                succeeds or fails, asynchronously."
                ^ aBlock newPromise

                BlockClosure >> newPromise
                "self is called with PromiseModel object.
                `aPromiseModel value: x` resolves the promise.
                `aPromiseModel signal: y` rejects the promise.
                Returns a Promise that eventually
                succeeds or fails, asynchronously."
                <return new JS_Promise(function (resolve, reject) {
                return
                self._value_($globals.PromiseModel._newResolve_reject_(
                resolve, reject
                ));
                })>

                PromiseModel class >> newResolve: aBlock reject:
                anotherBlock
                "Creates a PromiseModel instance
                that calls aBlock when anInstance value: is sent
                and calls anotherBlock when anInstance signal: is sent."

                PromiseModel >> value: anObject
                "Resolves underlying promise."

                PromiseModel >> signal: anObject
                "Rejects underlying promise."

                Collection >> allAsPromise
                "Returns a collection that succeeds

            "Returns a promise that ...

                when all promises in self asArray succeed.
                It is resolved with array of their results."
                ^ self asArray allAsPromise

                Array >> allAsPromise
                <return JS_Promise.all(self._collect_(function (each) {
                return each._asPromise();
                }))>

                Promise class >> all: aCollection
                "Returns a collection that succeeds

            "Returns a promise that ...

                when all promises in aCollection succeed.
                It is resolved with array of their results."
                ^ aCollection allAsPromise

                Collection >> anyAsPromise
                "Returns a collection that succeeds

            "Returns a promise that ...

                when any of the promises in self asArray succeed.
                It is resolved with result of the first one that resolves."
                ^ self asArray anyAsPromise

                Array >> anyAsPromise
                <return JS_Promise.any(self._collect_(function (each) {
                return each._asPromise();
                }))>

                Promise class >> any: aCollection
                "Returns a collection that succeeds

            "Returns a promise that ...

                when any of the promises in aCollection succeed.
                It is resolved with result of the first one that resolves."
                ^ aCollection anyAsPromise

                Promise >> all:then:on:do:
                Promise >> all:then:catch:
                Promise >> all:then:
                Promise >> then:on:do:
                Promise >> then:catch:
                Promise >> then:
                "all: nadicBlock
                then: aBlockOrCollectionOfBlocks
                on: aClass do: catchBlock
                catch: catchAllBlock"
                <return self
                // if all: present
                .then(function(args) {
                return nadicBlock._valueWithPossibleArguments_(args);
                })
                // if then: arg is aBlock
                .then(function (result) {
                return aBlock._value_(result);
                })
                // if then: arg is collection of blocks,
                // thenArg do: [ :each | "add .then call as above" ]
                // if on: aClass do: catchBlock present
                .catch(function (ex) {
                if ($recv(ex)._isKindOf_(aClass)
                return catchBlock._value_(ex);
                else throw ex;
                })
                // if catch: catchAllBlock is present
                .catch(function (ex) {
                return catchAllBlock._value_(ex);
                })
                 >

                As you can see, Promise.reject API is not wrapped, but I
                don't it's
                needed than often and can always be done with `[ :m | m
                signal: 'foo' ]
                newPromise`.

                For example:

                (fetch value: url)
                then: {
                [ :data | JSON parse: data].
                [ :parsed |
                parsed at: #id ifAbsent: [ Error signal: "Missing name."].
                parsed ].
                ...
                }
                catch: [ :e | self handleError: e ofUrl: url ]

                and creating promise of your own:

                [ :model |
                anObject apiWithCallback: [ :err :result | err
                ifNotNil: [ model signal: err ]
                ifNil: [ console log: result. model value: result
                payload ] ]
                ] newPromise

                Opinions?

                Thanks, Herby




    --
    You received this message because you are subscribed to the Google
    Groups "amber-lang" group.
    To unsubscribe from this group and stop receiving emails from it,
    send an email to [hidden email]
    <mailto:[hidden email]>.
    For more options, visit https://groups.google.com/d/optout.

--
You received this message because you are subscribed to the Google
Groups "amber-lang" group.
To unsubscribe from this group and stop receiving emails from it, send
an email to [hidden email]
<mailto:[hidden email]>.
For more options, visit https://groups.google.com/d/optout.

--
You received this message because you are subscribed to the Google Groups "amber-lang" group.
To unsubscribe from this group and stop receiving emails from it, send an email to [hidden email].
For more options, visit https://groups.google.com/d/optout.