What is the most idiomatic way to construct structs with complex default values?

I personally don’t think this would be nice as it would mean coming across a wild %Foo{} means there could be side-effects. I’m perfectly happy with status quo where %Foo{} means “static thing I’m allow to manipulate” and Foo.new() means “I’m special, please let me construct myself!”.

I was trying to say “this is an example of what OP was asking for”. It doesn’t work, but it would be nice if it did.

Your example does not compile (I have fixed some compile errors already):

Erlang/OTP 25 [erts-13.0.2] [source] [64-bit] [smp:10:10] [ds:10:10:10] [async-threads:1] [jit] [dtrace]

Interactive Elixir (1.13.4) - press Ctrl+C to exit (type h() ENTER for help)
iex(1)> defmodule Foo do
...(1)>   defstruct [:email, bytes: &random_bytes/0]
...(1)>
...(1)>   defp random_bytes do
...(1)>     :rand.uniform(100)
...(1)>   end
...(1)> end
** (CompileError) iex:2: undefined function random_bytes/0 (there is no such import)
    (elixir 1.13.4) expanding macro: Kernel.defstruct/1
iex(1)>

I think the post is really about “struct default values that are determined at runtime”…

defmodule Foo
  defstruct [:email, bytes: &random_bytes/0]

  defp random_bytes do
    :erlang.rand_bytes(16)
  end
end

Which admittedly would be kinda nice…

Quick note: 99% of the time when you write struct you really mean struct! because

• struct! will raise if required keys from @enforce_keys are omitted
• struct! will raise if given keys that aren’t allowed in the struct

Another pattern that can catch bad keys at compile-time: use a struct literal combined with a function to apply defaults. Something like:

defmodule SessionRequest do
  defstruct [:email, :random_bytes]

  def setup(%__MODULE__{} = session) do
    Map.put_new_lazy(session, :bytes, fn -> random_bytes() end)
  end
end

# at the callsite:
session_request =
  %SessionRequest{
    email: some_email
  }
  |> SessionRequest.setup()

This is a little over-abstracted for the case where SessionRequest only has one field supplied by the user, but would make more sense if there were a dozen:

• the compiler will catch invalid keys in the literal
• if you’ve declared types for the specific keys, Dialyzer may catch errors like assigning a literal string to a key declared to be integer(). It will NOT catch misconfigured use of struct/struct!

I felt this way too until I divorced the word new from “object instantiation”.

I think the official Elixir documentation even says…

Just use data directly:

%__MODULE__{email: email, bytes: random_bytes()}

If that’s not good enough, make a function:

def new(email) do
  %__MODULE__{email: email, bytes: random_bytes()}
end

And finally… metaprogramming (no example… ).

See the “In other words:” part of this section:

We can even mix and match both solutions:

def new(attrs) do
  __MODULE__
  |> struct(attrs)
  |> maybe_with_random_bytes()
end

defp maybe_with_random_bytes(%{bytes: nil} = struct) do
  Map.put(struct, :bytes, random_bytes())
end

defp maybe_with_random_bytes(struct), do: struct

The thing is attrs is an Enumerable.t(), so it can be a map or a keyword. So that is why i do it after i create the struct.

But yea very valid if you want to have the two functions as you showed

Another option would be to just build the default opts with Keyword.put_new_lazy/3. Then you create the struct once without needing to update it, and you still only run the random_bytes() generator when necessary. I don’t know how this would compare performance-wise with the with statement plus the update.

def new(attrs) when is_list(attrs) do
  attrs = Keyword.put_new_lazy(attrs, :bytes, &random_bytes/0)
  struct(__MODULE__, attrs)
end

# optionally if you want to accept both list and map arguments
def new(attrs) when is_map(attrs), do: new(Enum.to_list(attrs))

I always use __MODULE__ just in case I want to change the module name down the line, I don’t have to update anything else in that file.

It can also be done as a case if you are more comfortable with that.

def new(attrs) do
  case struct(__MODULE__, attrs) do
    %{bytes: nil} = struct ->
      %{struct | bytes: random_bytes()}

    struct ->
      struct
  end
end