Functional Domain Programming for Elixir?

Perhaps you could use structs?

@spec read(UncheckedOrder.t()) :: VerifiedOrder.t()
def read(%UncheckedOrder{} = order) do
  # ...
end
# ...

@spec send(VerifiedOrder.t()) :: DispatchedOrder.t()
def send(%VerifiedOrder{} = order) do
  # ...
end
# ...

?

That is a bit of my problem with many resources about functional programming - they cover static typing instead, which makes it not particularly well transferable to Elixir (or Clojure, or some others). In this case use different structs, as @RudManusachi mentioned, but in my experience this will quickly start to feel weird and overengineered (at least that’s my experience, but maybe I did that wrong and someone could share a success story of this approach in Elixir).

IMO Elixir needs to find its own way to do functional modeling, DDD etc, because copying from Scala or F# won’t work. I wrote something about this few years ago, but this is just scratching the surface (and not necessarily the only direction).

Maybe like this?

  defmodule Order do
    @type t( status) ::
      %__MODULE__{
        id: Ecto.UUID.t(),
        status: status
      }

    defstruct [ :id, :status]
  end

  @spec send_order( Order.t( :verified)) :: :ok | { :error, :unverified_order}
  def send_order( order)

  def send_order( %{ status: :verified}) do
    :ok
  end

  def send_order( %{ status: _}) do
    { :error, :unverified_order}
  end

What is the problem with using just data with a specific structure and pattern matching? It achieves exactly the same thing and I would say for basic cases it’s easier to read.

The functions can be exactly as @DaAnalyst mentioned, but it doesn’t mean that you necessarily need a struct.

That’s exactly what many of us do but the sentiment expressed in many such discussions is that sometimes there occurs a “struct bloat” or “too many different types of maps we’re matching on in function heads”-bloat. Which I’ve also seen happening. There are ways around it, of course.

One problem I find with this approach is refactoring. Something like “find all occurences of this map shape” and rename a key there. Or make sure certain key is only of type integer etc.

Yeah, that’s why I prefer to just add more structs. It gets annoying but it’s more future-proof.