How To Implement if...else if...else condition

Any reason why you don’t simply use nested if, if you need a nested if?

And an “else” branch in a cond is simply true.

What you are trying to do might be better as something else (such as cond or multiple function clauses) can you paste your code so we can take a look?

iex> cond do
...>   2 + 2 == 5 ->                                # 1 if expression (equivalent)
...>     "This is never true"                       # 1 
...>   2 * 2 == 3 ->                                # 2 if-else expression (equivalent)
...>     "Nor this"                                 # 2
...>   true ->                                      # 3 else expression (equivalent)
...>     "This is always true (equivalent to else)" # 3
...> end
"This is always true (equivalent to else)"

It’s important to remember that cond, case and even if are expressions , not statements (i.e. not control flow structures) - think: ternary operator in JavaScript, (C, C++, C#, Java) - i.e. they are fundamentally designed to return a value - though the compiler doesn’t yell at you if you ignore the returned value. Functions with multiple clauses work similarly as functions always return values. Many situations can be implemented with either case expressions or multi-clause functions and both support guards which is essentially is a condition that refines the pattern match.

Of course!

def userselect( user ) do
    cond do
      Map.has_key?( user, :id ) ->
        sel_user = User |> Repo.get( user.id )

        case sel_user do
          nil -> { :error, "Something went wrong!" }
          _ -> { :ok, sel_user }
        end
      Map.has_key?( user, :email ) ->
        sel_user = User |> Repo.get_by( email: user.email )

        case sel_user do
          nil -> { :error, "Something went wrong!" }
          _ -> { :ok, sel_user }
        end
      Map.has_key?( user, :username ) ->
        sel_user = User |> Repo.get_by( username: user.username )

        case sel_user do
          nil -> { :error, "Something went wrong!" }
          _ -> { :ok, sel_user }
        end
      true ->
        { :error, "It's immposible to select a user using this parameter." }
    end
  end

def userselect(%{id: id} = user), do: …
def userselect(%{email: email} = user), do: …
def userselect(%{username: username} = user), do: …
def userselect(_), do: …

Since you now have a match on id, email, or username you may be able to even rewrite the “inner” block a bit.

Since all the case are identical, I’d even move them into a helper function, making your blocks look like this:

defp sel_user(nil), do: {:error, "Something went wrong"}
defp sel_user(user), do: {:ok, user}

def userselect(%{id: id}), do: User |> Repo.get(id) |> sel_user()
def userselect(%{email: email}), do: User |> Repo.get(email) |> sel_user()
def userselect(%{username: username}), do: User |> Repo.get(username) |> sel_user()
def userselect(_), do: sel_user(nil)

Next step were to create those function heads from a list using metaprogramming, they are the same except for the key to match on… But to be honest, I’d do that only for more than 5 keys, you don’t gain much for less, maybe even you loose a lot if meta-ing to early

I had a feeling multiple def clauses might be more appropriate

@NobbZ’s code is much more readable/refactorable/maintainable and the preferred way of doing things (according to @pragdave) because each function is responsible only for one thing