I have implemented the Roc lang `<-` operator using macros

Of course there’s no way that a 5 lines macro could replace the work being done on a compiler at the language level.

That wasn’t even the point.

As far as I understood what Roc does is “simply” avoid the callback hell, by ensuring that each call will wait until completion before the next one is started. The compiler can have a broader look on code at large, so has more information to optimize the calls, but what is doing is exactly “start and then await”, which is not bad per se. The calling process is blocked anyway when you await on something, in any language, or the order of the execution could not be guaranteed.
That doesn’t exclude that A is run concurrently with another computation somewhere else.

The indentation visible in the image you posted is used to scope the variables, every indentation in Roc creates a new scope (at least that was my understanding)

I don’t understand the error bubbling remarks: if the function being called return an error tuple, the error will be returned, if it raise an exception, the exception can be caught.

with gets a little help from the compiler

defmacro with(args), do: error!([args])

defmacrop error!(args) do
    quote do
      _ = unquote(args)

      message =
        "Elixir's special forms are expanded by the compiler and must not be invoked directly"

      :erlang.error(RuntimeError.exception(message))
    end
  end

Anyway, it was simply an exercise in metaprogramming to explore the possibility, I really thought it was not possible in Elixir, but I was wrong.

That’s why it’s posted in chat/discussions

IMO this doesn’t quite capture the whole thing going on with ->; it’s missing the sequencing aspect of it.

From the “A Taste of Roc” talk:

Screen Shot 2021-12-06 at 12.52.49 PM1042×425 24.8 KB

This is the desugared form of:

username <- await (File.read "username.txt")
res <- await (Http.get "foo.com/\(username)")
File.write "response.txt" res

The presentation didn’t say it explicitly (at least not in the part I watched) but in addition to the above I assume Roc’s await is also doing some Result-monad gyrations to ensure that error values bubble out, ala Elixir’s with.

Note that starting a task and then immediately awaiting it in Elixir is kind of useless - the calling process is blocked while the Task executes and crashes if the task crashes. The “start then await” pattern is more of a Node idiom where await is the way to hand control back to the runtime.

If you are interested in research in this area then you might also find the Alan language interesting.