Erlang function call syntax


I’ve done some Erlang a long time ago and now I’m returning to the platform via Elixir. One the few things syntax-wise that I feel is sub-optimal is how you call Erlang functions, i.e., :module.function(...). It just looks a bit odd to me, although I do understand why it is this way.

Wouldn’t it be cool if we could use the same transformation done in keyword lists ([{:foo => 1}] being the same as [foo: 1]) and call module:function(...) instead, just like in Erlang? :slight_smile:

I have an alternative for you:

alias :module, as: Module


Keyword lists are lists of tuples, so it’s [{:foo, 1}], [foo: 1] == [{:foo, 1}]. A bit confusing yeah, so my vote is leave it be and add no sugar, it’s not healthy :smiley:

Yeah, I should have said “inspired by” and not “the same” transformation done for keyword lists.

I have an alternative for you:

It would actually be pretty nice if all Erlang functions came wrapped in an Erl module or something.

Erlang does have quoting:

iex(53)> :merl.quote("dothing(x) -> x.")       
{:function, 1, :dothing, 1,
 [{:clause, 1, [{:atom, 1, :x}], [], [{:atom, 1, :x}]}]}

I’m not sure what the Elixir parser would do with this AST though.

Why and how would you do that in case of non-core modules? Like poolboy?

1 Like

Well in that case you wouldn’t, of course, unless there’s something that adds the alias mentioned by @Qqwy automatically.

I still think being able to call poolboy:foo(...) instead of would make erlang calls feel less second-class.

It’s not like this is super important, it’s just an idea I had that I thought would be neat.

1 Like

The point is that the current syntax is in par with the whole rest of the language, as is the same as :'Elixir.Foo'.bar() (with exception for the aliases). So adding new call syntax would mean that Foo:bar() also would became valid call. While this could simplify some things (it would provide difference between function call and map access) I think it would be too confusing, especially as foo. bar() is valid syntax and foo: bar() will not be.