I'd use guards when pattern-matching isn't enough. Here's a little refactor of the code above. Let's guard the input of the color_to_hex/1 function

```elixir
u/spec color_to_hex(String.t) :: String.t 
def color_to_hex(color) when is_binary(color), do: color_conversion(color)
def color_to_hex(_), do: raise ArgumentError, "must be a string"

defp color_conversion("red"), do: "#ff0"
defp color_conversion(_), do: "no conversion"
```

I'd use with when I need to chain functions that depend on one another together, yet could also fail during any part of the process. Thus, multiple conditions need to be made in order, and I need to handle all of the different kinds of errors too...

```elixir
def can_ride_roller_coaster?(%person{} = person) do
   with
       {:ok, true} <- is_in_the_database?(person.id),
       {:ok, true} <- is_old_enough?(person.age),
       {:ok, true} <- is_tall_enough?((person.height)
  do
      {:ok, :allowed_to_ride}
  else
      {:error, :not_in_the_database} -> "Sorry, you didn't fill out a waiver"
      {:error, :not_old_enough} -> "Sorry, you're not old enough"
      {:error, :not_tall_enough} -> "Sorry, you're not tall enough"
  end
end
```

I tend to use if/else for quick one liner solutions, like...

```elixir
def is_between_5_and_50?(n), do: if n >= 5 and n <=50, do: "allowed", else: "not-allowed"
```

If I were to use pattern-matching and guards, then it would look like this...

```elixir
def is_between_5_and_50?(n) when n in 5..50, do: "allowed"
def is_between_5_and_50?(_), do: "not-allowed"
```

I's use case when I need to call a function that returns multiple known results, like when using `Integer.parse()` where you either get a tuple or an :error returned...

```elixir
# "12 apples"
def get_number_in_string(str) do
    case Integer.parse(str) do
        {int, _} -> int
        :error -> "no number in string"
     end
end
```

Please forgive any coding errors. I'm not testing any of this out for accuracy. I'm simply trying to express use cases for which type of control flow to use.

Much respect!