javascript - w3schools - Js Deferred/Promise/Future comparado con lenguajes funcionales como Scala

understanding promises javascript

Question

Estoy utilizando principalmente lenguajes de programación como Scala y JavaScript. Estoy tratando de entender las similitudes y diferencias en cómo se usa la programación asíncrona reactiva en ambos idiomas. ¿Me puedes ayudar?

No estoy tomando ningún marco J Promise particular porque parece que muchos implementan especificaciones similares (como Promise / A). Sólo he usado Q hasta ahora.

Parece que en Javascript llamamos a Deferred el objeto que resolvemos para completar una Promise . En Scala, parece que la Promise es el objeto que resolves para obtener una mónada Future .

¿Alguien puede decirme si esto es correcto? ¿Hay alguna buena razón para un uso diferente del término Promise entre Js y Scala?

Además, en Scala solemos encadenar las mónadas del Future con otros cálculos que utilizan operadores como map y flatMap (también llamado bind en Haskell). ¿Cuál es el equivalente de estos en Js?

Puede que me equivoque, pero me parece que en Js el then en un tipo de Promise manejan los operadores de map y flatMap , ¿no? Si es así, ¿es posible obtener una promise of promise of result en Js? Al igual que podemos obtener un Future[Future[Result]] en Scala (que puede aplanarse a un Future[Result] todos modos).

¿Es Js Promise una mónada? Algo así parece que incluso si los nombres de los métodos no coinciden con los que encontramos en la literatura de la mónada.

Answer 1

Estoy tratando de entender las similitudes y diferencias en cómo se usa la programación asíncrona reactiva en ambos idiomas.

Este documento aquí no compara las promesas de Javascript con Scala, sino que promete Javascript con C ++ C # y Python: https://github.com/KjellSchubert/promise-future-task . Sé que eso no es exactamente lo que pediste, pero esto podría darte algunos consejos interesantes, no obstante.

Answer 2

Parece que en Javascript llamamos a Aplazado el objeto que resolvemos para completar una Promesa. En Scala, parece que la Promesa es el objeto que resuelves para obtener una mónada Futura.

¿Alguien puede decirme si esto es correcto? ¿Hay alguna buena razón para un uso diferente del término Promesa entre Js y Scala?

En Scala, Promise y Future han separado la funcionalidad, Future es un contenedor de cómputo asíncrono, que le devuelve algún valor en el futuro, y Promise es la parte de escritura para async-computation, que puede hacer de la siguiente manera.

val promise = Promise[String]
val future1 = promise.future
val future2 = future1.map { case s => println(s); s }

future2.onSuccess { case s => println(s + " 2nd time") }

promise.success("promise completed")

Una vez que ejecute la última sentencia, la salida será

promise completed
promise completed 2nd time

En Scala, usted lee el valor de Futuro usando onComplete, o lo encadena usando un mapa, y escribe a un Futuro usando su contraparte de Promesa

En las especificaciones de JS Promise A +, están agrupadas, Promise.then se usa tanto para el encadenamiento como para el valor de recuperación para efectos secundarios (por ejemplo, console.log), para escribir, utilizará el código de código de código siguiente como se describe a continuación.

var promise = new Promise(function(resolve, reject){
    Thread.sleep(10000);
    resolve("promise completed");
}

Answer 3

Si y no.

Aunque extremadamente similar. Con las promesas de JavaScript que cumplen con la especificación de Promises / A + .then no es realmente un enlace monádico y hace .map y .flatMap . Dentro de un .then handler, cuando devuelves una promesa, la desenvolverá recursivamente.

Promise.delay(1000).then(function() {
    return Promise.delay(1000).then(function () {
        return Promise.delay(2000);
    }).then(function () {
        return Promise.delay(5000)
    });
}).then(function () {
    alert("This is only shown after 8 seconds and not one");
});

(fiddle)

Usted tiene razón en que las bibliotecas de promesa JS estándar y la especificación A + no presentan promesas monádicas. Han sido discutidos, y existen implementaciones como fantasy-promises . Siguen una especificación differnet y tienen poca adopción. También vea this . En el foro de discusión de diseño lingüístico se ha mantenido una discusión sobre este tema: se considera un debate y un método de .chain monádica que no permite un mapa plano y permite promesas monádicas, pero es poco probable que lo logre.

Esto es por razones pragmáticas. La forma actual en que se implementan las promesas es inmensamente útil. Son raros los casos en que realmente desea un Future[Future y normalmente desea que las continuaciones solo funcionen en el idioma. Las promesas "toman prestado" de las mónadas y son "monádicas" en cierto sentido. .then muy cerca de .then y en mi cabeza los uso indistintamente :)

Es imposible tener una Promise[Promise[Value]] como una Future[Future[Value]] en Scala con la mayoría de las bibliotecas prometedoras. Tendría que envolverlo en un objeto y tener Promise[Container[Promise[Value]]] .

Promise.delay(1000).then(function () {
    return Promise.delay(1000).then(function () {
        return {
            wrap: Promise.delay(2000).then(function () {
                return Promise.delay(5000);
            })
        };
    });
}).then(function () {
    alert("This logs after 1 second");
    // I''ve also not seen a really solid use case 
    // except TypeScript type inference which is meh
});

(fiddle)

También hay una serie de otras diferencias más pequeñas entre los dos, pero en general estás en lo cierto en tus afirmaciones.