How does erlang handle case statements mixed with tail recursion

Let's say I have开发者_Go百科 this code here:

do_recv_loop(State) ->
    receive
    {do,Stuff} ->
        case Stuff of
        one_thing -> 
            do_one_thing(),
            do_recv_loop(State);
        another_thing ->
            do_another_thing(),
            do_recv_loop(State);
        _ ->
            im_dead_now
        end
    {die} -> im_dead_now;
    _ -> do_recv_loop(State)
    end.

Now, in theory this is tail-recursive, as none of the three calls to do_recv_loop require anything to be returned. But will erlang recognize that this is tail recursive and optimize appropriately? I'm worried that the nested structure might make it not able to recognize it.

Yes, it will. Erlang is required to optimize tail calls, and this is clearly a tail call since nothing happens after the function is called.

I used to wish there were a tailcall keyword in Erlang so the compiler could warn me about invalid uses, but then I got used to it.

Yes, it is tail recursive. The main gotcha to be aware of is if you are wrapped inside exceptions. In that case, sometimes the exception needs to live on the stack and that will make something that looks tail-recursive into something deceptively not so.

The tail-call optimization is applicable if the call is in tail-position. Tail position is the "last thing before the function will return". Note that in

fact(0) -> 1;
fact(N) -> N * fact(N-1).

the recursive call to fact is not in tail position because after fact(N-1) is calculated, you need to run the continuation N * _ (i.e., multiply by N).

This I think is relevant because you are asking about how you know if your recursive function is optimized by the compiler. Since you aren't using lists:reverse/1 the below might not apply but for someone else with the exact same question but with a different code example it might be very relevant.

From the The Eight Myths of Erlang Performance in the Erlang Efficiency Guide

In R12B and later releases, there is an optimization that will in many cases reduces the number of words used on the stack in body-recursive calls, so that a body-recursive list function and tail-recursive function that calls lists:reverse/1 at the end will use exactly the same amount of memory.

http://www.erlang.org/doc/efficiency_guide/myths.html#id58884

I think the take away message is that you may have to measure in some cases to see what will be best.

I'm pretty new to Erlang but from what I've gathered, the rule seems to be that in order to be tail-recursive, the function has to do one of two things in any given logical branch:

• not make a recursive call
• return the value of the recursive call and do nothing else after it

That recursive call can be nested into as many if, case, or receive calls as you want as long as nothing actually happens after it.