Pins always operate by value. Pinning a value does not turn the value into a pattern.
benwilson512
Author of Craft GraphQL APIs in Elixir with Absinthe
peerreynders
My gut pick is this one:
subset? =
fn (map1, map2) ->
in_other =
fn {key, value} ->
{:ok, value} == Map.fetch(map2, key)
end
map1
|> Map.to_list()
|> Enum.all?(in_other)
end
as it simply verifies that all the necessary key/value pairs are present and will stop as soon as that is not the case.
In this case I also prefer to use fetch/2 in order the leverage the underlying map functionality rather than relying on in/2’s macro magic even if it makes the code a bit more verbose (so be it).
One thing to be aware of is that the empty set is a subset of any other set - the same is true for empty maps.
3
peerreynders
Pattern Matching — Erlang System Documentation v29.0.2
In a pattern matching, a left-hand side
patternis matched against a right-hand sideterm.
The phrasing suggests to me that patterns are very different from terms - patterns aren’t listed under Data Types.
Pinning ‘pins’ the binding - it expresses that no re-binding of that name should take place; at that point matching succeeds if both values are equal otherwise there will be a :badmatch error.
Erlang doesn’t need pinning because it doesn’t allow re-binding. But a simple name to the left of the match operator (=) means:
- if the name is unbound, bind the name to the right hand side (and return the bound/matched value)
- if the name is bound and the name is bound to a value equal to the right hand side, succeed (and return the matched value)
- if the name is bound and the name is bound to a value not equal to the right hand side, fail (and throw a
badmatcherror)
FYI: Map is an Enumerable so Enum.all?(map1, &(&1 in map2)) should work - I just like to be explicit.
2
kelvinst
I see. Maybe the variable rebinding ability makes this a little confusing behaviour in Elixir.
You’re right, and I’ve noticed that you’re very explicit. That’s good, even more in examples, but I just wanted to show him he can write it in a shorter way. 
2
axelson
Scenic Core Team
@peerreynders Do you like that version mainly for performance over the simpler:
MapSet.subset?(MapSet.new(map1), MapSet.new(map2))
I wonder if there’s a way to convert a map to a pattern. Conceptually it seems possible.
1
peerreynders
Either would be hidden behind a function so concise/simple/explicit/verbose really doesn’t factor into it. I would hope that the fetch solution is pretty good performance/memory wise - but that could be totally wrong - one would have to benchmark the various solutions in a representative environment to actually know.
Conceptually it seems possible.
At this point I doubt it. I can’t find a source but (at least for me) everything seems to hint that patterns are fixed at compile time - so short of writing a module with the injected pattern and compiling and then loading it…
It may have been one of those tradeoffs that allowed the BEAM to heavily optimize pattern matching - but I’m just guessing.
1
axelson
Scenic Core Team
Yeah it would make sense if a pattern is a compile-time construct in which case there would be no good way to use pattern matching for my problem as stated. Although for my current problem I am creating my map statically at compile time so I may be able to send my map to a macro and use that macro to pattern match against a map.
0
peerreynders
Crudely (… must be one of the simplest applications for macros I’ve come across):
defmodule Pattern do
defmacro from(pattern) do
quote do
unquote(pattern)
end
end
end
defmodule Demo do
require Pattern
@demo_map %{a: 1}
def subset?(super_map) do
case super_map do
Pattern.from(@demo_map) ->
true
_ ->
false
end
end
def subset2?(super_map) do
try do
Pattern.from(@demo_map) = super_map
true
catch
:error, {:badmatch, _} ->
false
end
end
def subset3?(Pattern.from(@demo_map) = _super_map), do: true
def subset3?(_), do: false
def a,
do: @demo_map
def with_fun(subset) do
fn {k,v} ->
IO.puts("a ⊆ #{Atom.to_string(k)}: #{subset.(v)}")
end
end
def with_fun({title, list}, fun) do
IO.puts(title)
Enum.each(list, with_fun(fun))
end
end
check_list = [a: Demo.a, b: %{a: 1, b: 2}, c: %{c: 3}, e: %{}]
Demo.with_fun({"--- subset? ", check_list}, &Demo.subset?/1)
Demo.with_fun({"--- subset2? ", check_list}, &Demo.subset2?/1)
Demo.with_fun({"--- subset3? ", check_list}, &Demo.subset3?/1)
$ elixir demo5.exs
--- subset?
a ⊆ a: true
a ⊆ b: true
a ⊆ c: false
a ⊆ e: false
--- subset2?
a ⊆ a: true
a ⊆ b: true
a ⊆ c: false
a ⊆ e: false
--- subset3?
a ⊆ a: true
a ⊆ b: true
a ⊆ c: false
a ⊆ e: false
0
NobbZ
@demo_map is replaced literally with %{a: 1} before the macro is called.
In theory it should be possible to use @demo_map directly at the exact same places where you currently use the macro.
1
NobbZ
Okay, my fault, it is passed in as @demo_map, comes out as @demo_map and then gets expanded to %{a: 1}, still, your macros shouldn’t be necessary…
1