Nashorn и Scala будущее конверсии JS Promise

У меня есть серверная сторона, реализованная в интерфейсе Scala и React/Flux. Мои сервисы возвращают Futures, и они обрабатываются в Scalatra AsyncResult для ответов JSON.

Для установки изоморфной/серверной рендеринга я не хотел менять блокировку служб, поэтому я начал с Scala Future- > java.util.function.Function conversion показанного здесь,

Но диспетчер в Flux хотел бы получить JS Promise. До сих пор я обнаружил лишь довольно сложное звучание вокруг этого слайдов 68-81

Есть ли какой-либо рекомендуемый способ справиться с этим преобразованием Scala Future → JS Promise?

Ответ 1

Я постараюсь ответить на вопрос Scala Future to JS Promise. Как вы не представили пример. Я приведу здесь конверсию. Если мы скажем, что у нас есть будущее, реализованное в Scala следующим образом:

val f: Future = Future {
  session.getX()
}

f onComplete {
  case Success(data) => println(data)
  case Failure(t) => println(t.getMessage)
}

то соответствующий код в JavaScript/ES6 может выглядеть следующим образом:

var f = new Promise(function(resolve, reject) {  
   session.getX();
});

f.then((data) => {   
  console.log(data);
}).catch((t) => {
  console.log(t);
}));

Я знаю, что это не Scala, но я хотел включить его для полноты. Это отображение от Future до Promise, взятое из Scala.js docs:

+-----------------------------------+------------------------+-------------------------------------------------------------------------------------------------------+
|              Future               |        Promise         |                                                 Notes                                                 |
+-----------------------------------+------------------------+-------------------------------------------------------------------------------------------------------+
| foreach(func)                     | then(func)             | Executes func for its side-effects when the future completes.                                         |
| map(func)                         | then(func)             | The result of func is wrapped in a new future.                                                        |
| flatMap(func)                     | then(func)             | func must return a future.                                                                            |
| recover(func)                     | catch(func)            | Handles an error. The result of func is wrapped in a new future.                                      |
| recoverWith(func)                 | catch(func)            | Handles an error. func must return a future.                                                          |
| filter(predicate)                 | N/A                    | Creates a new future by filtering the value of the current future with a predicate.                   |
| zip(that)                         | N/A                    | Zips the values of this and that future, and creates a new future holding the tuple of their results. |
| Future.successful(value)          | Promise.resolve(value) | Returns a successful future containing value                                                          |
| Future.failed(exception)          | Promise.reject(value)  | Returns a failed future containing exception                                                          |
| Future.sequence(iterable)         | Promise.all(iterable)  | Returns a future that completes when all of the futures in the iterable argument have been completed. |
| Future.firstCompletedOf(iterable) | Promise.race(iterable) | Returns a future that completes as soon as one of the futures in the iterable completes.              |
+-----------------------------------+------------------------+-------------------------------------------------------------------------------------------------------+