How can I access variable defined in "With" statement from its "else" block?

Hello forum!
I’m trying to retrieve an updated conn, returned in the first line of a “with” statement, when second line failed. But I’m getting some error that says new_conn variable doesn’t exist. In the “do” block it is fine though.
Let me show you what my code looks like:

def some_action(conn, params) do
    with {:ok1, some_result, new_conn} <- some_func(conn, params),
      {:ok2, another_result} <- another_func(some_result)
      new_conn |> redirect(to: some_path(conn, :index)) # new_conn is accessible here
      {:error1, message} -> render(conn, "some_error_template.html")
      # new_conn is not accessible here
      {:error2, message} -> render(new_conn, "other_error_template.html")

Please how do you think I could get new_conn in the “else” block?

I have an idea but I’m wondering if it is not bad to use a function such as Tuple.append/2 to ensure the new_conn is present in the matching tuple…


You can return {:error, conn, message} from your functions.


Ok that way I keep the current code, simple and short. I will just writte one more clause for the function that returns {:error2, message} for it takes one more parameter (conn) and just returns it with its own data.
Thank you ^^

I fell into a similar issue and I don’t want to create new functions that return wanted variables in function.
Let’s take this simple snippet:

iex(1)> with a <- 1,
...(1)> 2 <- 3 do
...(1)> :ok
...(1)> else error ->
...(1)> {:error, binding()}
...(1)> end
{:error, [error: 3]}

You can see that the"a" variable is not bound to the else block context, there’s only the “error” one.

If we go with the solution given in the previous comments, we have to introduce a function that returns “a” but you will easily agree that doing so for a such a simple piece of code is stupid:

iex(5)> f = fn(x) -> {3, x} end   
#Function<6.50752066/1 in :erl_eval.expr/5>
iex(6)> with a <- 1,           
...(6)> 2 <- f.(a) do
...(6)> :ok
...(6)> else error ->
...(6)> {:error, binding()}
...(6)> end
{:error, [error: {3, 1}, f: #Function<6.50752066/1 in :erl_eval.expr/5>]}

I found another solution by using process dictionary:

iex(1)> with a <- 1,  
...(1)> _ <- Process.put(:a, a), 
...(1)> 2 <- 3 do
...(1)> :ok
...(1)> else error ->
...(1)> {:error, error, Process.get(:a)}
...(1)> end
{:error, 3, 1}

…but I’m not 100% happy with it either.

Does anyone have a more elegant solution?


If you care about errors, maybe try using a case block?

1 Like

I don’t care about errors.
As in the original question, I would like to get all variables assigned in the first with clauses (before something went wrong) from the else block.

That means that you do care about errors and should look into using a case block instead of with.

You don’t.

You probably ran into this:

You’re building values.


iex(1)> fun = fn () ->
...(1)>   with a <- 1,
...(1)>        {2,_} <- {3,a} do
...(1)>     :ok
...(1)>   else
...(1)>     {_,a} = error ->
...(1)>       {:error, error, a}
...(1)>     error ->
...(1)>       {:error, error}
...(1)>   end
...(1)> end
#Function<20.127694169/0 in :erl_eval.expr/5>
iex(2)> fun.()
{:error, {3, 1}, 1}

So you just have to build the value that contains all the information that you need for the error.

The code in the OP would then look something like this:

def some_action(conn, params) do
    with {:ok1, some_result, new_conn} <- some_func(conn, params),
      {{:ok2, another_result},_} <- {another_func(some_result), new_conn}
      new_conn |> redirect(to: some_path(conn, :index)) # new_conn is accessible here
      {:error1, message} -> render(conn, "some_error_template.html")
      {{:error2, message}, new_conn} -> render(new_conn, "other_error_template.html")

Hum, very informative … ^^

thanks @peerreynders

based on this thread, I ended by creating a kind of accumulator that gathers all results got during the multiple clauses

this more generic solution looks like:

with {{:ok, res1}, acc} <- {fun1(), []},
     {{:ok, res2}, acc} <- {fun2(), acc ++ [res1]},
     {{:ok, resN}, acc} <- {funN(), acc ++ [resN-1]} do
      # do some stuff...
    {error, acc} ->
     # error contains the result of funP
     # acc contains the results of fun1 to funP-1
     # do some other stuff...



i too am a bit surprized the bindings in the do arent accessable in the else, given the my interpretation of the purpose of the with.

so … is @ntalfer solution still the “best” one? the only other way ive found after a bit of research is to implement some sort of railway oriented version, which is certainly non-trivial just to get access to the bindings.

The issue is scoping: in the example above, what is res4 bound to when fun2() returns {:error, :nope}?

AFAIK, Elixir expects to be able to determine which bindings are in scope at each point statically at compile-time.

1 Like

thx for the reply!

id say: unbound or a function (to be) call(ed)? or am i missing something?! :wink: