Returning a constant with an anonymous function with the capture operator &

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.