Control flow structures vs Pattern Matching

Hello,

I came to make a provocation about a way of writing code.

I’m writing a small private project to shorten urls and I came across a change in the writing of a case.

I saw that when writing the case in my function I felt that the function seemed complex to understand and read. I thought about changing the case to use Pattern Matching of the functions.

leaving this code:

defp validate_url(changeset, field, opts \\ []) do
    validate_change(changeset, field, fn _, value ->
      case URI.parse(value) do
        %URI{scheme: nil} ->
          "is missing a scheme (e.g. https)"

        %URI{host: nil} ->
          "is missing a host"

        %URI{host: host} ->
          case :inet.gethostbyname(Kernel.to_charlist(host)) do
            {:ok, _} -> nil
            {:error, _} -> "invalid host"
          end
      end
      |> case do
        error when is_binary(error) -> [{field, Keyword.get(opts, :message, error)}]
        _ -> []
      end
    end)
  end

for this:

  defp validate_url(changeset, field, opts \\ []) do
    validate_change(changeset, field, fn _, value ->
      value
      |> URI.parse()
      |> handle_parse()
      |> handle_error_parse()
    end)
  end

  defp handle_error_parse(error) when is_binary(error), do: [{field, Keyword.get(opts, :message, error)}]
  defp handle_error_parse(_), do: []

  defp handle_parse(%URI{scheme: nil}), do: "is missing a scheme (e.g. https)"
  defp handle_parse(%URI{host: nil}), do: "is missing a host"

  defp handle_parse(%URI{host: host}) do
    host
    |> Kernel.to_charlist()
    |> :inet.gethostbyname()
    |> handle_hostbyname()
  end

  defp handle_hostbyname({:ok, _}), do: nil
  defp handle_hostbyname({:error, _}), do: "invalid host"

I’m preferring to use Pattern Matching instead of case and other control flow structures.

what do you think?