Structs: pattern matching on nil values

Or just straight out by testing the nil case first: match?(%A{a: nil}, %A{})

Or !!%A{}.a … looks a bit like swearing.

Wouldn’t work in a match context though? ^.^;

Oh, I thought the goal was to get a false.

Thanks for the suggestions. Indeed, !! won’t work within a function signature unfortunately.

It provides tons of value if you include a pattern on those members, or if you include those members in a guard.

Let’s filter all As that are empty

as |> Enum.filter(&match?(%A{a: []}, &1))

Ultimately the whole point of match? is that it works exactly like:

case value do
  %A{a: a} -> true
  _ -> false
end

If you want some other characteristic then you want some other function.

We are more than happy to try to help provide the most idiomatic way to achieve whatever your goal is in this situation. Just understand that suggestions that involve breaking changes to core functions are unlikely to gain a lot of traction.

Ben, thanks a lot for your detailed answer. I was probably not clear enough about it, but I am not interested in match? per se but rather in the design decision behind pattern matching implementation for structs. Given that I understand how structs are implemented I see that pattern matching works in a most straightforward way.

That is entirely dictated by the BEAM VM itself.

As for structs, they act very much like ‘records’ from Erlang.

And to do something like having match?(%A{a: a}, %A{}) return false then it would have to have a guard, and guards introduce a non-trivial hit in processing time (doing <<_:binary>> is faster than doing s when is_binary(s) for one example), which is dreadfully important at times.

Not necessarily. One could forbid keeping nil values in structs but keep the set of possible keys somewhere else (which, in turn, might be useful for defining the order of keys for instance).

Interesting, I would not have guessed. Did you learn it by trying to optimize some code or by learning BEAM internals?

How would you do that?

A struct is just a map, so worst-case someone could just Map.put(someStruct, :theKey, nil)…

I came from the erlang world with a lot of network parsing, I’ve been working with the BEAM off and on for ~15 years I think now (early 2000’s). ^.^