Episode 5: Code Style Debate

analyze/1 written using if expression:

analyze(N) ->
  if
    N rem 15 == 0 ->
      fizzbuzz;
    N rem 5 == 0 ->
      buzz;
    N rem 3 == 0 ->
      fizz;
    true ->
      N
  end.

analyze/1 written using pattern matching and guards:

analyze(N) when N rem 3 =:= 0 andalso N rem 5 =:= 0 -> fizzbuzz;
analyze(N) when N rem 3 =:= 0 -> fizz;
analyze(N) when N rem 5 =:= 0 -> buzz;
analyze(N) -> N.

generate_sequence/2 written using a case expression:

generate_sequence(Pid, N) ->
  case is_number(N) of
    false ->
      exit({badarg, N});
    true ->
      Pid ! {generate, self(), N},
      receive
        {ok, Result} ->
          Result
        after 1000 ->
          {error, timeout}
      end
  end.

generate_sequence/2 written using pattern matching and guards:

generate_sequence(Pid, N) when is_integer(N) ->
  Pid ! {generate, self(), N},
  receive
    {ok, Result} ->
      Result
    after 1000 ->
      {error, timeout}
  end;
generate_sequence(_, N) -> exit({badarg, N}).

generate_fizzbuzz_list/1 written using explicit recursion:

generate_fizzbuzz_list(N) ->
  generate_fizzbuzz_list(1, N, []).

generate_fizzbuzz_list(Pos, N, Accum) when Pos =< N ->
  generate_fizzbuzz_list(Pos + 1, N, lists:append(Accum, [analyze(Pos)]));
generate_fizzbuzz_list(Pos, N, Accum) when Pos > N->
  Accum.

generate_fizzbuzz_list/1 written using list comprehensions:

generate_fizzbuzz_list(N) ->
  [analyze(Value) || Value <- lists:seq(1, N)].

What do you think?