The article is great. I have to look if i do something similar in my process. And his way to find the bug was similar to mine. … one question what is MFA?
denna
hauleth
Module, function, arguments tuple:
{Foo, :bar, [1,2]}
Which make the handler call it as:
Foo.bar(1,2)
0
benwilson512
Author of Craft GraphQL APIs in Elixir with Absinthe
Module Function arguments. Generally refers to a tuple where each item the tuple provides one of those items in order:
{SomeModule, :function, list_of_args}
0
bjunc
Sorry, shouldn’t have assumed that you knew what MFA meant. As mentioned above, rather than using an anonymous function, you can pass the Module, Function, and Arguments. In the docs, you will often see two variations of supervised / linked processes. One will take an anonymous function, and an alternate option of passing the module, function, and args.
For example:
start_child/3 (anonymous fn) vs start_child/5 (MFA)
This may or may not apply to your specific situation, but it’s something I have experienced myself where I had a queue within a GenServer that was expanding / contracting as work was completed.
0
derek-zhou
Other than inadvertently pulling more than you actually need, is there any other concern using closures vs MFA?
0
hauleth
MFAs (and some captures) can be faster and can be translated into compile time literals, which mean less copying. That is why in telemetry you should use &__MODULE__.func/2 instead of captures of private functions or lambdas.
https://github.com/elixir-lang/elixir/pull/9469#discussion_r341850744
2
gregvaughn
MFA also works better with hot code loading. When a module is re-compiled the anonymous functions get a new opaque identifier even if their contents did not change.
2
derek-zhou
My rule of thumb from other languages is: The closure should not out live the function context where it is defined. Otherwise, there could be hidden cost you may not be willing to pay.
1
bjunc
Not sure I’m aware of notable “concerns” beyond the state being captured by the closure. There are some perf benefits (as mentioned above). There’s also the readability / testability of nesting linked process logic in an anonymous function.
My general rule, is that if the logic is more than a few lines, it’s deserving of being broken out.
You can always refer to the same module in your MFA with __MODULE__. For example:
def foo do
Task.Supervisor.start_child(SomeTaskSupervisor, __MODULE__, :bar, ["baz", "qux"])
end
def bar(arg1, arg2) do
IO.inspect binding(), label: "args"
# args: [arg1: "baz", arg2: "qux"}
end
0
hauleth
Only for public functions, as module.function() is remote call (with all pros and cons of that).
0