Chaining Validations with With

In the previous lesson, you used try/rescue to turn exceptions into {:ok, value} or {:error, reason}. Today, you will learn how to chain multiple such checks with the with statement. This helps you stop early on the first error and keeps your code clear.

defmodule UserValidator do
  def validate_and_create(params) do
    with {:ok, name} <- validate_name(params[:name]),
         {:ok, email} <- validate_email(params[:email]),
         {:ok, age} <- validate_age(params[:age]) do
      {:ok, %{name: name, email: email, age: age}}
    else
      {:error, reason} -> {:error, reason}
    end
  end

What it does:

• Each line in with pattern-matches on {:ok, value}. If a line returns {:error, reason}, the with stops and jumps to else.
• name, email, and age are bound only if the previous step succeeded.
• The else block returns the first error unchanged, keeping a consistent contract.

Note: You can add multiple patterns in else to transform different error shapes if needed. Here, a single {:error, reason} clause is enough.

  defp validate_name(nil), do: {:error, "Name is required"}
  defp validate_name(name) when is_binary(name) and byte_size(name) < 2, do: {:error, "Name too short"}
  defp validate_name(name) when is_binary(name), do: {:ok, name}
  defp validate_name(_), do: {:error, "Name must be a string"}

What it does:

• Matches nil first for a clear “required” error.
• Uses guards to ensure the input is a binary (string) and checks length.
• Returns {:ok, name} only when it is a valid string.
• The final clause catches non-string types with a helpful message.

Design tip:

• Order matters. Place the most specific checks first, then the general catch-all last.

  defp validate_email(nil), do: {:error, "Email is required"}
  defp validate_email(email) when is_binary(email) do
    if String.contains?(email, "@") do
      {:ok, email}
    else
      {:error, "Invalid email format"}
    end
  end
  defp validate_email(_), do: {:error, "Email must be a string"}

  defp validate_age(nil), do: {:error, "Age is required"}
  defp validate_age(age) when is_integer(age) and age >= 18, do: {:ok, age}
  defp validate_age(_), do: {:error, "Must be 18 or older"}
end

What it does:

• Email:
  • Requires a string and checks for a basic "@" presence.
  • Differentiates between “missing,” “wrong type,” and “bad format.”
• Age:
  • Requires an integer and enforces a minimum value.
  • Returns a uniform {:error, reason} on any invalid input.

Notes:

• Keeping all validators returning the same tuple shapes makes with simple and predictable.
• Use guards (is_binary/1, is_integer/1) to fail fast and keep error messages clear.

You learned how with chains multiple validations and short-circuits on the first error while keeping a clean {:ok, value} | {:error, reason} flow. You also saw how to design small validator functions with guards and clear messages so that orchestration is simple.

You are ready to put this pattern into action. Head to the practice section and apply with to build tidy, reliable validation pipelines.