[ClojureScript] Re: cider clojurescript repl

[daniel sutton]

I used your exact profile.clj and was able to 
`cider-jack-in-clojurescript`. CIDER offered me which type of connection to 
use and I selected nashorn since I see no figwheel dependencies. If you 
want to move to figwheel, you'll need some cljsbuild info.

Try using [cider/piggieback "0.3.5"] along with [lein-figwheel "0.5.16"] 
and ["figwheel-sidecar "0.5.16"]. The update from cemerick -> 
cider/piggieback threw a wrench into things as everything expects the 
former. Figwheel updated to look for both in later versions.

On Tuesday, May 1, 2018 at 6:35:26 AM UTC-5, Johannes wrote:
>
> Hi,
>
> I am looking for a working configuration for Emacs/Cider/ClojureScript 
> Repl. Following the instructions given in the Cider manual 
>  I built a 
> project.clj:
>
> (defproject piggi "0.1.0-SNAPSHOT"
>   :description "FIXME: write description"
>   :url "http://example.com/FIXME";
>   :license {:name "Eclipse Public License"
> :url "http://www.eclipse.org/legal/epl-v10.html"}
>   :dependencies [[org.clojure/clojure "1.9.0"]
>  [org.clojure/clojurescript "1.10.238"]]  
>   :profiles
>   {:dev {:dependencies [[cider/piggieback "0.3.1"]
> [org.clojure/tools.nrepl "0.2.13"]]} 
>:repl-options {:nrepl-middleware [cider.piggieback/wrap-cljs-repl]}})
>
> But, if I issue cider-jack-in-clojurescript I get:
>
> Starting nREPL server via lein update-in :dependencies conj 
> \[org.clojure/tools.nrepl\ \"0.2.12\"\] -- update-in :plugins conj 
> \[cider/cider-nrepl\ \"0.12.0-SNAPSHOT\"\] -- repl :headless... 
>  is undefined error in process sentinel: Could not start nREPL 
> server: WARNING: boolean? already refers to: #’clojure.core/boolean? in 
> namespace: cider.inlined-deps.fipp.v0v6v4.fipp.visit, being replaced by: 
> #’cider.inlined-deps.fipp.v0v6v4.fipp.visit/boolean? Error loading 
> cider.nrepl.middleware.debug: java.lang.ClassNotFoundException: 
> sun.misc.Launcher, compiling:(dynapath/defaults.clj:29:3) Error loading 
> cider.nrepl.middleware.test: java.lang.RuntimeException: Invalid token: 
> ::clojure.test/once-fixtures, 
> compiling:(cider/nrepl/middleware/test.clj:106:57) Exception in thread 
> "main" java.lang.RuntimeException: Unable to resolve var: 
> cider.nrepl.middleware.test/wrap-test in this context, 
> compiling:(/private/var/folders/lj/z8hchxbn7n58vh8bqg8frmr0gq/T/form-init7208710527506290850.clj:1:7918)
>  
> at clojure.lang.Compiler.analyzeSeq(Compiler.java:7010) at 
> clojure.lang.Compiler.analyze(Compiler.java:6773) at 
> clojure.lang.Compiler.analyze(Compiler.java:6729) at 
> clojure.lang.Compiler$InvokeExpr.parse(Compiler.java:3881) at 
> clojure.lang.Compiler.analyzeSeq(Compiler.java:7005) at 
> clojure.lang.Compiler.analyze(Compiler.java:6773) at 
> clojure.lang.Compiler.analyze(Compiler.java:6729) at 
> clojure.lang.Compiler$InvokeExpr.parse(Compiler.java:3881) at 
> clojure.lang.Compiler.analyzeSeq(Compiler.java:7005) at 
> clojure.lang.Compiler.analyze(Compiler.java:6773) at 
> clojure.lang.Compiler.access$300(Compiler.java:38) at 
> clojure.lang.Compiler$LetExpr$Parser.parse(Compiler.java:6368) at 
> clojure.lang.Compiler.analyzeSeq(Compiler.java:7003) at 
> clojure.lang.Compiler.analyze(Compiler.java:6773) at 
> clojure.lang.Compiler.analyze(Compiler.java:6729) at 
> clojure.lang.Compiler$BodyExpr$Parser.parse(Compiler.java:6100) at 
> clojure.lang.Compiler$FnMethod.parse(Compiler.java:5460) at 
> clojure.lang.Compiler$FnExpr.parse(Compiler.java:4022) at 
> clojure.lang.Compiler.analyzeSeq(Compiler.java:7001) at 
> clojure.lang.Compiler.analyze(Compiler.java:6773) at 
> clojure.lang.Compiler.eval(Compiler.java:7059) at 
> clojure.lang.Compiler.eval(Compiler.java:7052) at 
> clojure.lang.Compiler.load(Compiler.java:7514) at 
> clojure.lang.Compiler.loadFile(Compiler.java:7452) at 
> clojure.main$load_script.invokeStatic(main.clj:278) at 
> clojure.main$init_opt.invokeStatic(main.clj:280) at 
> clojure.main$init_opt.invoke(main.clj:280) at 
> clojure.main$initialize.invokeStatic(main.clj:311) at 
> clojure.main$null_opt.invokeStatic(main.clj:345) at 
> clojure.main$null_opt.invoke(main.clj:342) at 
> clojure.main$main.invokeStatic(main.clj:424) at 
> clojure.main$main.doInvoke(main.clj:387) at 
> clojure.lang.RestFn.applyTo(RestFn.java:137) at 
> clojure.lang.Var.applyTo(Var.java:702) at clojure.main.main(main.java:37) 
> Caused by: java.lang.RuntimeException: Unable to resolve var: 
> cider.nrepl.middleware.test/wrap-test in this context at 
> clojure.lang.Util.runtimeException(Util.java:221) at 
> clojure.lang.Compiler$TheVarExpr$Parser.parse(Compiler.java:720) at 
> clojure.lang.Compiler.analyzeSeq(Compiler.java:7003) ... 34 more Subprocess 
> failed error in process sentinel: Could not start nREPL server: WARNING: 
> boolean? already refers to: #’clojure.core/boolean? in namespace: 
> cider.inlined-deps.fipp.v0v6v4.fipp.visit, being replaced by: 
> #’cider.inlined-deps.fi

[ClojureScript] Re: When will the async/await feature in ES8 be introduced in ClojureScript?

[Shogo Ohta]

FYI.

I'm working on a ClojureScript library named kitchen-async 
(https://github.com/athos/kitchen-async) in my spare time, and if you would 
like more syntactic support for Promises than promesa provides (ie. alet 
macro mentioned above), you might find it useful.

I know it's not totally an elegant solution for the issue, but it works 
enough (at least for me) in many practical cases.

Shogo

On Friday, May 25, 2018 at 11:01:10 AM UTC+9, Philos Kim wrote:
>
> I appreciate all the feedback for my question and came to know that the 
> implementation of the async/await feature in ClojureScript is not easy as I 
> expected.
>
> I agree that ClojureScript doesn't need to accept every new feature in JS 
> and I know that core.async is more powerful than the newly introduced 
> async/await feature in JS. However I would like to quote a Korean proverb: 
> "Don't use the knife for slautering a cow, when slautering a cock." A 
> simple use case needs a simple solution, not a magnificent and complex one.
>
> In JS world, the promise comes out to overcome the callback hell and the 
> async/await feature comes out to overcome the verbosity of the promise. Of 
> course, I know that the async/await feature is a syntactic sugar of the 
> promise, so can be used in the promise style in ClojureScript. But What I 
> want to avoid is that verbosity as in JS.
>
> Furthermore the async/await feature is now heavily used in the JS world, 
> especially in nodejs. So I want to use it in ClojureScript at least as JS 
> interop in the similiar way to the JS world, when I use the thrid-party 
> library written using the async/await feature.
>
>

-- 
Note that posts from new members are moderated - please be patient with your 
first post.
--- 
You received this message because you are subscribed to the Google Groups 
"ClojureScript" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojurescript+unsubscr...@googlegroups.com.
To post to this group, send email to clojurescript@googlegroups.com.
Visit this group at https://groups.google.com/group/clojurescript.

[ClojureScript] Re: When will the async/await feature in ES8 be introduced in ClojureScript?

[Philos Kim]

I appreciate all the feedback for my question and came to know that the 
implementation of the async/await feature in ClojureScript is not easy as I 
expected.

I agree that ClojureScript doesn't need to accept every new feature in JS 
and I know that core.async is more powerful than the newly introduced 
async/await feature in JS. However I would like to quote a Korean proverb: 
"Don't use the knife for slautering a cow, when slautering a cock." A 
simple use case needs a simple solution, not a magnificent and complex one.

In JS world, the promise comes out to overcome the callback hell and the 
async/await feature comes out to overcome the verbosity of the promise. Of 
course, I know that the async/await feature is a syntactic sugar of the 
promise, so can be used in the promise style in ClojureScript. But What I 
want to avoid is that verbosity as in JS.

Furthermore the async/await feature is now heavily used in the JS world, 
especially in nodejs. So I want to use it in ClojureScript at least as JS 
interop in the similiar way to the JS world, when I use the thrid-party 
library written using the async/await feature.

-- 
Note that posts from new members are moderated - please be patient with your 
first post.
--- 
You received this message because you are subscribed to the Google Groups 
"ClojureScript" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojurescript+unsubscr...@googlegroups.com.
To post to this group, send email to clojurescript@googlegroups.com.
Visit this group at https://groups.google.com/group/clojurescript.

Re: [ClojureScript] Re: When will the async/await feature in ES8 be introduced in ClojureScript?

[Justin Lee]

One other thing: although there are some things (like the bug I cited) that
could be fixed, the other aspect of exception handling cannot be fixed
without breaking core.async, which, by design, swallows exceptions on the
producer side.  David Nolen has a proposal for the 
wrote:

> good point about the IIFEs, added some notes on what to fixl:
>
>
> https://beta.observablehq.com/@shaunlebron/proposal-generators-and-async-functions-in-clojurescript#blockers
>
> > [core.async] is a much more powerful abstraction which can do a lot of
> things async/await can't and anything that does can easily be achieved with
> core.async and a few helper functions/macros
>
> not quite! core.async doesn't allow you to cancel a go-block (to my
> knowledge), which JS allows.  I added a section on this:
>
>
> https://beta.observablehq.com/@shaunlebron/proposal-generators-and-async-functions-in-clojurescript#coreasync
>
> On Thursday, May 24, 2018 at 4:44:29 PM UTC-5, Thomas Heller wrote:
>>
>> I'm generally in favor of "embracing the host" but both generators and
>> async/await would probably require substantial rewrites of core parts of
>> the compiler. It it not just about adding a small *** or *async* keyword
>> somewhere. The compiler will generally emit anonymous functions at various
>> places to ensure proper scoping and this can pretty easily break
>> async/generator functions. Given that you'd emitting ES6+ anways however
>> you could replace those with proper block-scoped lets though. Of course
>> that is not a reason to not do it, just don't underestimate how much work
>> this would be.
>>
>> I certainly looks like the JS world is adopting async/await but given the
>> rate of change in that ecosystem that might change again when the next
>> thing comes along. Given that the React folks decided to implement a pretty
>> substantial feature based on throwing promises I guess they are here to
>> stay for a while though.
>>
>> I do not think that this compares in any way to core.async however. It is
>> a much more powerful abstraction which can do a lot of things async/await
>> can't and anything that does can easily be achieved with core.async and a
>> few helper functions/macros. Yes, core.async is not perfect either but
>> someone could work on fixing the kinks.
>>
>> I guess I agree that we should eventually support async/await +
>> generators for the sake of full interop but not because of "issues" with
>> core.async.
>>
>>
>> On Thursday, May 24, 2018 at 6:58:38 PM UTC+2, Shaun LeBron wrote:
>>>
>>> thanks for posting this question.  I asked about it a few months ago on
>>> slack and apparently it has come up a few times.  There is resistance (for
>>> good reason), but here's a proposal I put together that might get
>>> discussion going:
>>>
>>>
>>> https://beta.observablehq.com/@shaunlebron/proposal-generators-and-async-functions-in-clojurescript
>>>
>>> in summary, core.async doesn't solve all the problems, can be harder to
>>> debug, and using the promise api directly can be unwieldy.  but there are
>>> arguments against including the extra syntax.
>>>
>>> feedback appreciated!
>>>
>>>
>>> On Wednesday, May 23, 2018 at 11:44:06 PM UTC-5, Philos Kim wrote:

 I wonder when the async/await feature in ES8 will be introduced in
 ClojureScript.

 Of course, I know there is core.async in ClojureScript but I hope that
 the async/await feature in ES8 will be supported in ClojureScript as soon
 as possible.

 Does anyone know when it will be supported?

>>> --
> Note that posts from new members are moderated - please be patient with
> your first post.
> ---
> You received this message because you are subscribed to the Google Groups
> "ClojureScript" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to clojurescript+unsubscr...@googlegroups.com.
> To post to this group, send email to clojurescript@googlegroups.com.
> Visit this group at https://groups.google.com/group/clojurescript.
>

-- 
Note that posts from new members are moderated - please be patient with your 
first post.
--- 
You received this message because you are subscribed to the Google Groups 
"ClojureScript" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojurescript+unsubscr...@googlegroups.com.
To post to this group, send email to clojurescript@googlegroups.com.
Visit this group at https://groups.google.com/group/clojurescript.

[ClojureScript] Re: When will the async/await feature in ES8 be introduced in ClojureScript?

[Shaun LeBron]

good point about the IIFEs, added some notes on what to fixl:

https://beta.observablehq.com/@shaunlebron/proposal-generators-and-async-functions-in-clojurescript#blockers

> [core.async] is a much more powerful abstraction which can do a lot of 
things async/await can't and anything that does can easily be achieved with 
core.async and a few helper functions/macros

not quite! core.async doesn't allow you to cancel a go-block (to my 
knowledge), which JS allows.  I added a section on this:

https://beta.observablehq.com/@shaunlebron/proposal-generators-and-async-functions-in-clojurescript#coreasync

On Thursday, May 24, 2018 at 4:44:29 PM UTC-5, Thomas Heller wrote:
>
> I'm generally in favor of "embracing the host" but both generators and 
> async/await would probably require substantial rewrites of core parts of 
> the compiler. It it not just about adding a small *** or *async* keyword 
> somewhere. The compiler will generally emit anonymous functions at various 
> places to ensure proper scoping and this can pretty easily break 
> async/generator functions. Given that you'd emitting ES6+ anways however 
> you could replace those with proper block-scoped lets though. Of course 
> that is not a reason to not do it, just don't underestimate how much work 
> this would be.
>
> I certainly looks like the JS world is adopting async/await but given the 
> rate of change in that ecosystem that might change again when the next 
> thing comes along. Given that the React folks decided to implement a pretty 
> substantial feature based on throwing promises I guess they are here to 
> stay for a while though.
>
> I do not think that this compares in any way to core.async however. It is 
> a much more powerful abstraction which can do a lot of things async/await 
> can't and anything that does can easily be achieved with core.async and a 
> few helper functions/macros. Yes, core.async is not perfect either but 
> someone could work on fixing the kinks.
>
> I guess I agree that we should eventually support async/await + generators 
> for the sake of full interop but not because of "issues" with core.async. 
>
>
> On Thursday, May 24, 2018 at 6:58:38 PM UTC+2, Shaun LeBron wrote:
>>
>> thanks for posting this question.  I asked about it a few months ago on 
>> slack and apparently it has come up a few times.  There is resistance (for 
>> good reason), but here's a proposal I put together that might get 
>> discussion going:
>>
>>
>> https://beta.observablehq.com/@shaunlebron/proposal-generators-and-async-functions-in-clojurescript
>>
>> in summary, core.async doesn't solve all the problems, can be harder to 
>> debug, and using the promise api directly can be unwieldy.  but there are 
>> arguments against including the extra syntax.
>>
>> feedback appreciated!
>>
>>
>> On Wednesday, May 23, 2018 at 11:44:06 PM UTC-5, Philos Kim wrote:
>>>
>>> I wonder when the async/await feature in ES8 will be introduced in 
>>> ClojureScript.
>>>
>>> Of course, I know there is core.async in ClojureScript but I hope that 
>>> the async/await feature in ES8 will be supported in ClojureScript as soon 
>>> as possible.
>>>
>>> Does anyone know when it will be supported?
>>>
>>

-- 
Note that posts from new members are moderated - please be patient with your 
first post.
--- 
You received this message because you are subscribed to the Google Groups 
"ClojureScript" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojurescript+unsubscr...@googlegroups.com.
To post to this group, send email to clojurescript@googlegroups.com.
Visit this group at https://groups.google.com/group/clojurescript.

[ClojureScript] Re: When will the async/await feature in ES8 be introduced in ClojureScript?

[Thomas Heller]

I'm generally in favor of "embracing the host" but both generators and 
async/await would probably require substantial rewrites of core parts of 
the compiler. It it not just about adding a small *** or *async* keyword 
somewhere. The compiler will generally emit anonymous functions at various 
places to ensure proper scoping and this can pretty easily break 
async/generator functions. Given that you'd emitting ES6+ anways however 
you could replace those with proper block-scoped lets though. Of course 
that is not a reason to not do it, just don't underestimate how much work 
this would be.

I certainly looks like the JS world is adopting async/await but given the 
rate of change in that ecosystem that might change again when the next 
thing comes along. Given that the React folks decided to implement a pretty 
substantial feature based on throwing promises I guess they are here to 
stay for a while though.

I do not think that this compares in any way to core.async however. It is a 
much more powerful abstraction which can do a lot of things async/await 
can't and anything that does can easily be achieved with core.async and a 
few helper functions/macros. Yes, core.async is not perfect either but 
someone could work on fixing the kinks.

I guess I agree that we should eventually support async/await + generators 
for the sake of full interop but not because of "issues" with core.async. 


On Thursday, May 24, 2018 at 6:58:38 PM UTC+2, Shaun LeBron wrote:
>
> thanks for posting this question.  I asked about it a few months ago on 
> slack and apparently it has come up a few times.  There is resistance (for 
> good reason), but here's a proposal I put together that might get 
> discussion going:
>
>
> https://beta.observablehq.com/@shaunlebron/proposal-generators-and-async-functions-in-clojurescript
>
> in summary, core.async doesn't solve all the problems, can be harder to 
> debug, and using the promise api directly can be unwieldy.  but there are 
> arguments against including the extra syntax.
>
> feedback appreciated!
>
>
> On Wednesday, May 23, 2018 at 11:44:06 PM UTC-5, Philos Kim wrote:
>>
>> I wonder when the async/await feature in ES8 will be introduced in 
>> ClojureScript.
>>
>> Of course, I know there is core.async in ClojureScript but I hope that 
>> the async/await feature in ES8 will be supported in ClojureScript as soon 
>> as possible.
>>
>> Does anyone know when it will be supported?
>>
>

-- 
Note that posts from new members are moderated - please be patient with your 
first post.
--- 
You received this message because you are subscribed to the Google Groups 
"ClojureScript" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojurescript+unsubscr...@googlegroups.com.
To post to this group, send email to clojurescript@googlegroups.com.
Visit this group at https://groups.google.com/group/clojurescript.

Re: [ClojureScript] Re: When will the async/await feature in ES8 be introduced in ClojureScript?

[Justin Lee]

Shaun,

Your email came in while I was drafting mine.  Thank you so much for
putting together this proposal.  With the features you propose here, we'd
be able to do complex async code in javascript with even less code and
fewer dependencies, and we could rely on the battle tested transpilers and
polyfills for people who need earlier targets.  I, personally, would love
to see something like this in the language.

Justin

On Thu, May 24, 2018 at 9:58 AM Shaun LeBron 
wrote:

> thanks for posting this question.  I asked about it a few months ago on
> slack and apparently it has come up a few times.  There is resistance (for
> good reason), but here's a proposal I put together that might get
> discussion going:
>
>
> https://beta.observablehq.com/@shaunlebron/proposal-generators-and-async-functions-in-clojurescript
>
> in summary, core.async doesn't solve all the problems, can be harder to
> debug, and using the promise api directly can be unwieldy.  but there are
> arguments against including the extra syntax.
>
> feedback appreciated!
>
>
> On Wednesday, May 23, 2018 at 11:44:06 PM UTC-5, Philos Kim wrote:
>>
>> I wonder when the async/await feature in ES8 will be introduced in
>> ClojureScript.
>>
>> Of course, I know there is core.async in ClojureScript but I hope that
>> the async/await feature in ES8 will be supported in ClojureScript as soon
>> as possible.
>>
>> Does anyone know when it will be supported?
>>
> --
> Note that posts from new members are moderated - please be patient with
> your first post.
> ---
> You received this message because you are subscribed to the Google Groups
> "ClojureScript" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to clojurescript+unsubscr...@googlegroups.com.
> To post to this group, send email to clojurescript@googlegroups.com.
> Visit this group at https://groups.google.com/group/clojurescript.
>

-- 
Note that posts from new members are moderated - please be patient with your 
first post.
--- 
You received this message because you are subscribed to the Google Groups 
"ClojureScript" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojurescript+unsubscr...@googlegroups.com.
To post to this group, send email to clojurescript@googlegroups.com.
Visit this group at https://groups.google.com/group/clojurescript.

Re: [ClojureScript] Re: When will the async/await feature in ES8 be introduced in ClojureScript?

[Justin Lee]

I'm not the OP, but I'll explain why I personally avoid core.async and what
I do to get features that are roughly equivalent to async/await today.

My first issue with core.async is that you have to be very careful on the
producer-side to handle exceptions properly.  If you drop an exception, at
best you'll get a stack-trace dumped to the console that often won't have a
single line that traces back to your code.  Instead, you'll get a pile of
generated library code that you have no experience with.  I ran into this
when JSON.parse throws an exception inside cljs-http, which in my opinion
is just the kind of run-of-the-mill exception that should be easy to debug
(but isn't).

The second issue is that there are still a number of bugs with core.async
surrounding exception handling.  As I was trying to fix the above issues, I
ran into one of them.  https://dev.clojure.org/jira/browse/ASYNC-73

In short, my basic problem with core.async is that it adds a lot of
complexity (and size) to your code, which I'd rather avoid if there are
better alternatives.

The three non-callback ways of dealing with async code in javascript are
(1) promises, (2) generators, (3) async/await.  The first two are es6.  The
last is es-2017.  Because these are now built into the language and are
widely relied upon, the tooling support (e.g. browser and node) are
excellent and all the corner cases have been worked out.

Async/await is sugar that you put on top of generators.  The feel of
async/await is exactly like go-blocks, where "async" is "go" and "await" is
"http://facebook.github.io/regenerator/

So far, though, I've found that async/await is mostly useful in javascript
because of the fact that you have side-effecting statements and complex
syntax where it is convenient to be able to throw an "await" without
refactoring your code.  In clojurescript, you tend to write code in a
non-side-effecting expressions, so I don't find that I need something that
general.

For simple things, I find that just relying on plain promises (using the
promesa library) is enough.  You can do this:

(-> (promise-returning-call)
(then (fn [response] ...))
(catch (fn [error] ...)))

This is simple, it is very close to the host language, and there are no
corner cases that I know of to surprise you.

Sometimes you need to thread the results of an earlier async call to later
calls, which can be clumsy.  I think async/await was largely driven by
solving this problem, but I don't think you really need that generality in
this language.  I have found that as long as you write "clojurescripty"
code, the alet macro from the promesa library is all you need.

(alet [a (get-a)
   b (get-b a)
   c (get-c a b)]
  (do-something c))

Setting all that aside, the clear advantage of being able to target
async/await (or maybe just generators) is that you get the native
implementation and don't have to do all of this code manipulation in user
space.  The tooling is going to be better, the code will be smaller, and
the edge cases are going to be handled.  Maybe you could even write a
core.async fork without all of the IOC helpers (i.e. just translate
directly to async/await).

By the way, I hope I'm not coming off as being critical of the core.async
authors.  This stuff is very hard to get right and not everyone is going to
have the same design requirements.



On Thu, May 24, 2018 at 6:25 AM Nikita Dudnik  wrote:

> Sorry for answering with a question but I have to second Andrew. What's
> wrong with core.async and more importantly how'd you implement async/await
> in clojurescript in terms of syntax?
>
> -
> Nik
>
>
> On Thursday, May 24, 2018 at 6:44:06 AM UTC+2, Philos Kim wrote:
>>
>> I wonder when the async/await feature in ES8 will be introduced in
>> ClojureScript.
>>
>> Of course, I know there is core.async in ClojureScript but I hope that
>> the async/await feature in ES8 will be supported in ClojureScript as soon
>> as possible.
>>
>> Does anyone know when it will be supported?
>>
> --
> Note that posts from new members are moderated - please be patient with
> your first post.
> ---
> You received this message because you are subscribed to the Google Groups
> "ClojureScript" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to clojurescript+unsubscr...@googlegroups.com.
> To post to this group, send email to clojurescript@googlegroups.com.
> Visit this group at https://groups.google.com/group/clojurescript.
>

-- 
Note that posts from new members are moderated - please be patient with your 
first post.
--- 
You received this message because you are subscribed to the Google Groups 
"ClojureScript" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojurescript+unsubscr...@googlegroups.com.
To post to this group, send email to clojurescript@googlegroups.com.
Visit this group at https://groups.google.com/group/clojurescript.

[ClojureScript] Re: When will the async/await feature in ES8 be introduced in ClojureScript?

[Shaun LeBron]

thanks for posting this question.  I asked about it a few months ago on 
slack and apparently it has come up a few times.  There is resistance (for 
good reason), but here's a proposal I put together that might get 
discussion going:

https://beta.observablehq.com/@shaunlebron/proposal-generators-and-async-functions-in-clojurescript

in summary, core.async doesn't solve all the problems, can be harder to 
debug, and using the promise api directly can be unwieldy.  but there are 
arguments against including the extra syntax.

feedback appreciated!


On Wednesday, May 23, 2018 at 11:44:06 PM UTC-5, Philos Kim wrote:
>
> I wonder when the async/await feature in ES8 will be introduced in 
> ClojureScript.
>
> Of course, I know there is core.async in ClojureScript but I hope that the 
> async/await feature in ES8 will be supported in ClojureScript as soon as 
> possible.
>
> Does anyone know when it will be supported?
>

-- 
Note that posts from new members are moderated - please be patient with your 
first post.
--- 
You received this message because you are subscribed to the Google Groups 
"ClojureScript" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojurescript+unsubscr...@googlegroups.com.
To post to this group, send email to clojurescript@googlegroups.com.
Visit this group at https://groups.google.com/group/clojurescript.

[ClojureScript] Re: When will the async/await feature in ES8 be introduced in ClojureScript?

[Nikita Dudnik]

Sorry for answering with a question but I have to second Andrew. What's 
wrong with core.async and more importantly how'd you implement async/await 
in clojurescript in terms of syntax?

-
Nik 

On Thursday, May 24, 2018 at 6:44:06 AM UTC+2, Philos Kim wrote:
>
> I wonder when the async/await feature in ES8 will be introduced in 
> ClojureScript.
>
> Of course, I know there is core.async in ClojureScript but I hope that the 
> async/await feature in ES8 will be supported in ClojureScript as soon as 
> possible.
>
> Does anyone know when it will be supported?
>

-- 
Note that posts from new members are moderated - please be patient with your 
first post.
--- 
You received this message because you are subscribed to the Google Groups 
"ClojureScript" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojurescript+unsubscr...@googlegroups.com.
To post to this group, send email to clojurescript@googlegroups.com.
Visit this group at https://groups.google.com/group/clojurescript.

Re: [ClojureScript] When will the async/await feature in ES8 be introduced in ClojureScript?

[Andrew Oberstar]

Not familiar with async/await myself. What would it provides that you can't
already do in core.async?

Andrew Oberstar

On Wed, May 23, 2018, 11:44 PM Philos Kim  wrote:

> I wonder when the async/await feature in ES8 will be introduced in
> ClojureScript.
>
> Of course, I know there is core.async in ClojureScript but I hope that the
> async/await feature in ES8 will be supported in ClojureScript as soon as
> possible.
>
> Does anyone know when it will be supported?
>
> --
> Note that posts from new members are moderated - please be patient with
> your first post.
> ---
> You received this message because you are subscribed to the Google Groups
> "ClojureScript" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to clojurescript+unsubscr...@googlegroups.com.
> To post to this group, send email to clojurescript@googlegroups.com.
> Visit this group at https://groups.google.com/group/clojurescript.
>

-- 
Note that posts from new members are moderated - please be patient with your 
first post.
--- 
You received this message because you are subscribed to the Google Groups 
"ClojureScript" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to clojurescript+unsubscr...@googlegroups.com.
To post to this group, send email to clojurescript@googlegroups.com.
Visit this group at https://groups.google.com/group/clojurescript.