Control flow structures vs Pattern Matching

This is one of those cases of “Which do you prefer?” Your answer to that is the right one

Personally I prefer multi-head functions whenever it’s possible, but that’s just me. I maybe wouldn’t start every function name with handle_ as it feels a bit noisy but, again, that’s just me.

I believe I heard once pattern matching is fast. So there’s that. but don’t listen to me, dummy here.

PS, pattern matching essentially is control flow (among other things). It’s right there on the Erlang homepage

A function with an anonymous function as an argument with a case inside that pipes into another case?

to add something constructive: did you consider using with

https://medium.com/swlh/elixir-tip-case-vs-with-28b04c4e522a

IMO chained cases like this are better off as withs:

  defp validate_url(changeset, field, opts \\ []) do
    validate_change(changeset, field, fn _, value ->
      with {:ok, uri} <- parse_url(value),
           :ok <- check_host(url) do
        []
      else
        {:error, message} ->
          [{field, Keyword.get(opts, :message, error)}]
      end
    end
  end

  defp parse_url(value) do
    case URI.parse(value) do
      %URI{scheme: nil} ->
        {:error, "is missing a scheme (e.g. https)"}

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

      uri ->
        {:ok, uri}
    end
  end

  defp check_host(%URI{host: host}) do
    case :inet.gethostbyname(to_charlist(host)) do
      {:ok, _hostent} -> :ok
      {:error, _posix} -> {:error, "invalid host"}
    end
  end

A particular thing I like about this approach is that changeset-related bindings stay in validate_url, versus having to be passed along to functions like handle_error_parse.

both approaches are using pattern matching, my understanding is that a case statement and the equivalent pattern matching on function heads will compile to essentially the same byte code. i’ve done some very limited benchmarking and didn’t see any performance trade off for either approach

I personally prefer case over multiple function heads (sidenote: both use pattern matching!). But I’d do this:

defp validate_url_field(changeset, field, opts \\ []) do
  validate_change(changeset, field, fn _, value ->
    case validate_url(value) do
      :ok -> []
      {:error, message} -> [{field, Keyword.get(opts, :message, message)}]
    end
  end)
end

defp validate_url(string) do
  case URI.parse(string) do
    %URI{scheme: nil} ->
      {:error, "is missing a scheme (e.g. https)"}

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

    %URI{host: host} ->
      case :inet.gethostbyname(Kernel.to_charlist(host)) do
        {:ok, _} -> :ok
        {:error, _} -> {:error, "invalid host"}
      end
  end
end

I prefer the multiple function heads. Because then i have scan lesser code to understand it.
The parent function looks pretty too.

Only by reading the main function, i would know what is being done.
(assuming sensible naming, which is hard as they say)

I prefer understanding a program top to bottom. Especially , in a team. That is, don’t make me touch the details unless i have to.

I am on the fence on this one. Sometimes I think the code is cleaner looking with a single function head that has a single case statement…

Especially if the function has other heads that deal with other things. Sometimes the combinatory explosion flatting is just too much.