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

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?

Thanks!

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

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.

So

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}
iex(3)>

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}
    do
      new_conn |> redirect(to: some_path(conn, :index)) # new_conn is accessible here
    else
      {:error1, message} -> render(conn, "some_error_template.html")
      {{:error2, message}, new_conn} -> render(new_conn, "other_error_template.html")
    end
 end

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...
else 
    {error, acc} ->
     # error contains the result of funP
     # acc contains the results of fun1 to funP-1
     # do some other stuff...
end

thanks!

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.