(.then promise #(reset a %))

Promises are async, you can't work with them in a sync manner.

How should I pass it to a function to process Promise's return value?

Call that function in .then.

As soon as you encounter a promise, there's no longer a return value. There's a continuation, where everything must follow if it is to be sync'ed.

there should be more to that error? or even multiple instances of that error? It is usually one error resulting in many others

Sorry, should've pasted this right away. Here's the complete stack

npx shadow-cljs compile test
shadow-cljs - config: /Users/kwrooijen/my-app/shadow-cljs.edn  cli version: 2.8.83  node: v10.16.3
[:test] Compiling ...
========= Running Tests =======================
SHADOW import error /Users/kwrooijen/my-app/.shadow-cljs/builds/test/dev/out/cljs-runtime/com.cognitect.transit.handlers.js

/Users/kwrooijen/my-app/out/node-tests.js:1122
  fn.call(goog.global);
     ^
TypeError: util.randomUUID is not a function
    at /Users/kwrooijen/my-app/.shadow-cljs/builds/test/dev/out/cljs-runtime/com/cognitect/transit/handlers.js:36:9
    at Object.goog.scope (/Users/kwrooijen/my-app/out/node-tests.js:1122:6)
    at /Users/kwrooijen/my-app/.shadow-cljs/builds/test/dev/out/cljs-runtime/com/cognitect/transit/handlers.js:27:5
    at global.SHADOW_IMPORT (/Users/kwrooijen/my-app/out/node-tests.js:64:44)
    at /Users/kwrooijen/my-app/out/node-tests.js:2258:1
    at Object.<anonymous> (/Users/kwrooijen/my-app/out/node-tests.js:2:2)
    at Module._compile (internal/modules/cjs/loader.js:778:30)
    at Object..js (internal/modules/cjs/loader.js:789:10)
    at Module.load (internal/modules/cjs/loader.js:653:32)
    at tryModuleLoad (internal/modules/cjs/loader.js:593:12)
===============================================
[:test] Build completed. (168 files, 10 compiled, 0 warnings, 3.54s)

strange. which transit version is this?

from shadow-cljs --cli-info

[com.cognitect/transit-cljs "0.8.256"]
  [com.cognitect/transit-js "0.8.846"]

sorry no clue why this is failing. works fine for me

only guess is that you have some kind of dependency conflict

works totally fine for me locally

maybe try wiping the .shadow-cljs/builds cache

Tried deleting that. I'll make a fresh project and try again. Thanks!

Is it figwheel main with lein?

If you're asking how not to lose state you created using def, you can use defonce instead: https://clojuredocs.org/clojure.core/defonce

since “promises” have similar, but varying interfaces and ideas in different languages and frameworks, I avoid describing other concepts in terms of them. Deferred and promises are tools used for handling asynchronous code. When it comes to asynchronous code, I really recommend CSP (Communicating Sequential Processes) as a foundation as it has a more theoretical basis, http://usingcsp.com/cspbook.pdf. As an aside, both go’s async features and clojure.core.async use CSP as a basis as well

I just read the description, and I think Ahmed is right. Looks like a really useful feature of Deferred is that you can cancel them. You can't do that on promises.

generally, when comparing Deferred to Promise, Promise is about one asynchronous task (although some libraries/frameworks have promises do more). Deferred usually has extra tools for combining multiple asynchronous tasks and handling error states

Relevant tweet: https://twitter.com/dan_abramov/status/1246251834324516868

Many namespaces in Google Closure Library depend on Deffered. They're backbone of asynchrony here IMO.

for the google closure library, yes

there are lots of options for handling asynchrony if you’re using clojurescript though. for example https://github.com/clojure/core.async

I wanted to save Canvas as a PNG image to local filesystem, so I approached goog.fs where I saw Deffered very heavily used.

It seems Deferred already provides with what JS community is celebrating in the twitter thread you shared: https://google.github.io/closure-library/api/goog.async.Deferred.html

yea, that was my point

Probably Deferred was there before JS got Promises. There’s similar things in Python Twisted.

@U7PBP4UVA do you consider Deferred feasible?

Not sure what you mean by feasible in this sense. I only meant that JS promises was kind of a late arrival. goog.async.Deferred was (probably, I never checked) there well before JS got Promises as even a 3rd-party library. These days native JS Promises have direct support in most engines, but the concept isn’t something new.

the wikipedia article is kinda interesting (https://en.wikipedia.org/wiki/Futures_and_promises) > The term promise was proposed in 1976 by https://en.wikipedia.org/wiki/Daniel_P._Friedman and David Wise,https://en.wikipedia.org/wiki/Futures_and_promises#cite_note-1 and Peter Hibbard called it eventual.https://en.wikipedia.org/wiki/Futures_and_promises#cite_note-2 A somewhat similar concept future was introduced in 1977 in a paper by https://en.wikipedia.org/wiki/Henry_Baker_(computer_scientist) and https://en.wikipedia.org/wiki/Carl_Hewitt. > The terms future, promise, delay, and deferred are often used interchangeably, although some differences in usage between future and promise are treated below.

By feasible I mean: what are trade offs of JS Promise when compared with Deferred?

There's https://google.github.io/closure-library/api/goog.Promise.html too. > NOTE: This class was created in anticipation of the built-in Promise type being standardized and implemented across browsers. Now that Promise is available in modern browsers, and is automatically polyfilled by the Closure Compiler, by default, most new code should use native `Promise` instead of `goog.Promise`. However, `goog.Promise` has the concept of cancellation which native Promises do not yet have. So code needing cancellation may still want to use `goog.Promise`. EDIT: Also https://google.github.io/closure-library/api/goog.promise.NativeResolver.html and https://google.github.io/closure-library/api/goog.promise.Resolver.html

Great definition of Promise from https://promisesaplus.com/: > A promise represents the eventual result of an asynchronous operation. The primary way of interacting with a promise is through its `then` method, which registers callbacks to receive either a promise’s eventual value or the reason why the promise cannot be fulfilled.