Typespec for map w/both required and optional keys

Perhaps do it with the value.

@type parmas :: %{foo: String.t, bar: integer() | nil}

Or maybe:

@type optional_integer :: integer() | nil
@type parmas :: %{foo: String.t, bar: optional_integer()}

You already have the key :atom marked as optional. So what do you want more?

I actually want optional(:bar) => integer() but AFAICT from the docs I have to specify the key_type not the key.

@type parmas :: %{foo: String.t, bar: integer() | nil}

Is close, but that still looks like :bar is a required key even if the value of :bar is nil. Those seem like different things.

If I pattern matched the function args, :bar would not be present:

def do_thing(%{foo: foo)), do...

Literals are their own type. So optional(:bar) is exactly that.

Ah, yes! I see that now. Makes sense. Thanks!

%{
  account_number: String.t(),
  optional(:counterparty_id) => integer(),
  receiver_account_number: String.t() unless :counterparty_id set
}

Since I have your attention () is there a way to specify something is required if another key is not present? In this case, you can either have a :counterparty_id or several :receiver_* pairs.

No, neither the typespec syntax nor dialyzers checks can deal with mutual exclusion of keys.

Yep, use the union operator |.

I.E. you specify the whole structure twice with each variation, like:

%{
  account_number: String.t(),
  :counterparty_id => integer(),
} | %{
  account_number: String.t(),
  receiver_account_number: String.t()
}

It’s a bit of a pain and combinatorially explosive, but it works.

A potential stumbling block: even though the keys look like atoms, you can’t mix the x: and => when using optional. I assume this is because optional(:bar) resolves to a non-atom type.

You might get the somewhat cryptic error:

@type params :: %{
  foo: String.t(),
  optional(:bar) => integer() # "syntax error before: optional"
}

You must convert to:

@type params :: %{
  foo => String.t(),
  optional(:bar) => integer()
}

E: see below, or

@type params :: %{
  optional(:bar) => integer(),
  foo: String.t()
}