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

I was recently made aware of a new programming language, the Roc language that is still in early development stage, but looks very interesting on many aspects, especially the fact that it took a lot of ideas from Elixir.

In particular it uses the <- operator as syntax sugar over async operations, for example

a <- File.read(filename)

is automatically tranlsated to

a = Task.async(fn -> File.reade(filename) end) |> Task.await()

and I was wondering if I could implement the same behaviour using Elixir macros.

Turns out it was easier than I thought.

I don’t know if anyone is going to ever find this useful, but here it is, in all its glory.

defmodule Roc do
  defmacro a <- b do
    quote do
      retval = case unquote(b) do
        t = %Task{} -> Task.await(t)
        f when is_function(f) -> Task.async(f) |> Task.await()
        _ -> raise ArgumentError, message: "parameter b must be a Task or a function"  
      var!(unquote(a)) = retval

and can be used this way

c <- Task.async(fn -> :return_value end)

d <- fn -> :function end

try do
  _e <- 2
  ex -> IO.inspect(ex)

IO.inspect({c, d})

%ArgumentError{message: "parameter b must be a Task or a function"}
{:return_value, :function}

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

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:

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.

1 Like

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"


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 :slight_smile: :slight_smile:

1 Like