Workarounds for lack of varargs in Erlang

Question

Completely new to Erlang. I'm trying to define some functions for function composition, such as compose, juxt and pipe but running into the fact that Erlang doesn't have (to my knowledge) varargs so it's difficult to write just one version of such functions that will work for all inputs.

So far my best idea is to hardcode functions of different arities up to a reasonable number, as well as providing a version that takes a list for anything bigger, like this:

pipe (X, Fs) when is_list(Fs) -> lists:foldl(fun (F, Acc) -> F(Acc) end, X, Fs);
pipe (X, F) -> F(X).
pipe (X, F, G) -> G(F(X)).
pipe (X, F, G, H) -> H(G(F(X))).
pipe (X, F, G, H, I) -> I(H(G(F(X)))).
pipe (X, F, G, H, I, J) -> J(I(H(G(F(X))))).
pipe (X, F, G, H, I, J, K) -> K(J(I(H(G(F(X)))))).
pipe (X, F, G, H, I, J, K, L) -> L(K(J(I(H(G(F(X))))))).

which works, but I'm curious if there's a better way?

score 5 · Accepted Answer · edited May 23 '17 at 11:57

5

The problem is that Erlang functions are uniquely identified by Name/Arity; io:format/1 and io:format/2, for instance, are two different functions. Hence, variadic functions simply don't fit into Erlang.

The cleanest solution is probably what you suggested. Another option is to write a custom parse transform (a module that rewrites the AST after parsing but before compilation) to catch and transform calls to the specific functions you want, letting others pass through unmolested. The transform could intercept calls like pipe(A1, A2, A3, ..., An) and rewrite them to pipe([A1, A2, A3, ..., An]).

Be warned though: Parse transforms can be difficult to get right, and they must be explicitly referenced in every module that needs to use the features they provide. An example of parse transforms put to good use is Basho's Lager logging library.

edited May 23 '17 at 11:57

Community

1
1

answered Mar 19 '13 at 22:31

Martin Törnwall

9,299
2
28
35

Thanks, parse transforms sound interesting, I will take a look. – Russell Mar 19 '13 at 22:38
2

If you do go down the parse transform route, remember that with great power comes great responsibility. – Martin Törnwall Mar 19 '13 at 22:41
1

Looking at it I doubt I will, I think my hard-coded solution will be enough to cover most cases and it's hard to justify something like parse transforms for edge cases.. but they look interesting to learn about. – Russell Mar 19 '13 at 22:44
1

https://github.com/uwiger/parse_trans is helpful if you go down the parse transform route – cashmere Mar 20 '13 at 03:38

score 1 · Answer 2 · answered Mar 20 '13 at 08:55

I wonder why the list notation is not good for you, because it gives a very short and easy implementation, similar to the io:format/2.

pipe (X, Fs) when is_list(Fs) -> lists:foldl(fun (F, Acc) -> F(Acc) end, X, Fs).
fibnext([A,B]) -> [A+B,A].


1> F = fun(X) -> my_module:fibnext(X) end.
#Fun<erl_eval.6.82930912>
2> my_module:pipe([1,1],lists:duplicate(12,F)).      
[377,233]
3>

Workarounds for lack of varargs in Erlang

2 Answers2