What do you think of AsyncWith?

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?

Yes! this was just an example.. I’m using it to call multiple endpoints which doesn’t require to be sequential.
You can use the else as same as the with clause for failed ones.

opts = %{width: 10, height: 15}
async with {:ok, width} <- Map.fetch(opts, :width)
       {:ok, height} <- Map.fetch(opts, :height) do
    {:ok, width * height}
else
    {:error, n} -> 
        ... do what you want... 
end

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.

How similar is AsyncWith to Zousan.eval ?

AsyncWith reminds me a bit of Zousan.eval for javascript but I’m not sure if or how AsyncWith handles multiple dependencies.

How would the following code look like with AsyncWith? Particularly the line with deps: [ “userRenderer”, “favs” ]

Zousan.eval(
        { name: "username", value: "glenn" },
        { name: "user", value: getUser, deps: [ "username" ] },
        { name: "favs", value: getFavorites, deps: [ "user" ] },
        { name: "userRenderer", value: renderUser, deps: [ "user" ] },
        { value: renderUserFavs, deps: [ "userRenderer", "favs" ] }
    )