Asynchrony is not concurrency

One thing that most languages are lacking is expressing lazy return values. -> await f1() + await f2() and to express this concurently requres manually handing of futures.

Which languages do have such a thing?

That's because f2's result could depend on whether f1 has executed.

I suppose Haskell does, as `(+) <$> f1 <*> f2`.

you mean like?

   await Join(f1(), f2())

Although more realistically

   Promise1 = f1(); Promise2 = f2();
   await Join(Promise1, Promise2);

But also, futures are the expression of lazy values so I'm not sure what else you'd be asking for.

Rust does this, if you don’t call await on them. You can then await on the join of both.

Is the "join" syntax part of the language?

no

https://doc.rust-lang.org/std/future/macro.join.html

Then it doesn’t apply in this case.

In there is also ApplicativeDo that works nicely with this.

    do 
      x <- f1
      y <- f2
      return $ x + y

this is evaluated as applicative in same way.

This is what i hand in mind whit "manually handing of futures". In this case you have to write

   Promise1 = f1(); Promise2 = f2();
   v1,v2 = await Join(Promise1, Promise2);
   return v1 + v2

I think this is just too much of synthactic noise.

On the other hand, it is necessary becase some of underlying async calls can be order dependend.

for example

    await sock.rec(1) == 'A' && await sock.rec(1) == 'B'

checks that first received socket byte is A and second is B. This is clearly order dependant that can't be executed concurrently out of order.

Why is having it be syntax necessary or beneficial?

One might say "Rust's existing feature set makes this possible already, why dedicate syntax where none is needed?"

(…and I think that's a reasonably pragmatic stance, too. Joins/selects are somewhat infrequent, the impediments that writing out a join puts on the program relatively light… what problem would be solved?

vs. `?`, which sugars a common thing that non-dedicated syntax can represent (a try! macro is sufficient to replace ?) but for which the burden on the coder is much higher, in terms of code readability & writability.)

why?

I suppose you'd have to make

    SumAsync(F1(),f2());

Buy it's kind of intractable, isn't it? Your language has to assume order dependency or independency and specify the other. Most seem to stick with lexical ordering implies execution order.

I think some use curly brace scoping to break up dependency. I want to say kotlin does something like this.

This is why they say async is a viral pattern but IMO that's because you're adding specificity and function coloring is necessary and good.