You may be already using the Capture Operator
& for capturing functions or quickly creating anonymous function.
For this later case, you may also know that it’s not possible to use it for creating an anonymous function that return a constant or a literal or in other words without using a placeholder in the capture expression as explained in the doc:
The only restrictions when creating anonymous functions is that at least one placeholder must be present, i.e. it must contain at least
&1 , and that block expressions are not supported:
# No placeholder, fails to compile.
# Block expression, fails to compile.
However it might be useful sometimes to return an atom or a constant or any literal.
Well you can bypass the parameter using
|| (the or operator):
&(:foo || &1)
&(true || &1)
&(42 || &1)
And if you want to return no matter what
nil, well you can do it too, just use
&& (the and operator):
&(false || &1)
&(nil || &1)
Have a good day everyone…
Why not but I think that, most of the time, if I have to write
&(:foo || &1), I might as well write
fn -> :foo end. Maybe in some syntactic context,
&(...) is more readable than
fn -> ... end. I don’t know, I guess it depends on the use case. Anyway, thanks for sharing.
I completely agree.
I find it useful just for visual consistency when I’m using
&(...) in all the other clauses.
But as you implicitly said, in fact in this case it might be less readable regarding the intent.
So yeah… Might stick with the
fn _ -> :foo end
These will never return
&1 so I really don’t see the point.
If I understand correctly, it’s a trick to use the capture operator even when one does not want to use any of the placeholders, so it is intentional that
&1 is never used. It is there just because otherwise the anonymous function would not compile.
If on one hand I like the creative thinking around that, I would avoid this as it is confusing. As already stated,
fn -> :foo end is much clearer and almost as short.
More generally, after an initial enthusiasm, I switched to almost never use the capture operator for anonymous functions. I find
fn -> ... end a lot clearer, and saving a few characters not worth. On the other hand, I find the capture operator for named functions (like
&Module.function/3) very useful.
Indeed it’s exactly that.
And at the end of the day I agree with you too.
As I answered to @lkuty it’s correct that this little trick might be indeed more “tricky” and hide some intent…
Exactly like how @dimitarvp fell in the trap… It appears that without focus the code is more obscure and the intent become indeed hidden.
As you know and can saw on some google discussion it’s not possible to capture with 0 arity and I had like the author of that thread some use-case candidate.
Sorry if I was confusing…
But I thought that with the very sentence right above this code snippet (and in fact all the explanation of the entire post) that the goal to return not the first argument
&1 but precisely the constant was clear…
So you just proved that this indeed lacks of readability.
For others reading I wanted to note that
fn _ -> :foo is the equivalent of
&(:foo || &1) (not
fn -> :foo). Depending on how you’re using the anonymous function the different arities could make a significant difference. There is no way to create a 0-arity anonymous function using the
& capture syntax.
Yes, that’s also why I prefer the thunk style
fn -> :foo end.