What exactly happens when you have sequential clauses? And if you had 2 non-sequential followed by 2 clauses dependent upon those? It seems its just syntactic sugar for doing something like:

with pid1 <- Task.start(fn -> long_running_task() end),
     pid2 <- Task.start(fn -> long_running_task2() end),
     {:ok, data1} <- Task.await(pid1),
     {:ok, data2} <- Task.await(pid2) do
  {:ok, data1, data2}
else
  {:error, n} ->
    {:error, n}
end

IMHO I’d just prefer to see the tasks being spawned rather than using this library. It seems like its an attempt to implement JavaScript’s async keyword when Elixir already handles asynchronous communication much better than JavaScript does.

Tasks are spawned as soon as all the tasks that it depends on are resolved, so you can do something like this:

def show(conn, %{"id" => id}) do
   async with {:ok, post} <- Blog.get_post(id),
            {:ok, author} <- Users.get_user(post.author_id),
            {:ok, posts_by_the_same_author} <- Blog.get_posts(author),
            {:ok, similar_posts} <- Blog.get_similar_posts(post),
            {:ok, comments} <- Blog.list_comments(post),
            {:ok, comments} <- Blog.preload(comments, :author) do
    conn
    |> assign(:post, post)
    |> assign(:author, author)
    |> assign(:posts_by_the_same_author, posts_by_the_same_author)
    |> assign(:similar_posts, similar_posts)
    |> assign(:comments, comments)
    |> render("show.html")
  end
end

Of course you can do it with Task.start |> Task.await if you sort them correctly, but it seems like a really cool syntactic sugar.

I think it depends on what you are doing in the with. In that specific case of Map.fetch/2, it will probably take longer with the overhead of spawning additional processes. However, I could potentially see this as being useful if you have longer running clauses.

With that said, you should be careful when using something like this. It is possible that you actually want all of the previous clauses to run before running the following. Even if it doesn’t rely on the result of the previous (I’m sorry if that doesn’t make sense).

A question for anyone that knows about this library. If multiple clauses fail, which value gets returned?