[Proposal] Make Kernel.tap/2 and Kernel.then/2 macros

[sabi...@gmail.com]

Hi all!

I saw the recent additions of tap/2 and then/2 to the Kernel and I was wondering, would it make sense to make them macros rather than functions?

Since this is pure syntactic sugar for control flow, like `if` or the pipe operator itself, I thought it could be nice to just generate the desired AST instead of adding the runtime overhead of a function call.

But maybe I missed some implication of such a change, and a function is better in this case?

I created a branch to try it out, for the discussion: https://github.com/elixir-lang/elixir/compare/master...sabiwara:macro_tap_then?expand=1

Looking forward to hearing your thoughts!

[José Valim]

Thanks for the proposal!

I am honestly a bit torn. The current implementation is definitely more idiomatic and while there is a cost associated with it, the cost is extremely low. :) I am worried making it a macro will signal to developers they need to worry about these kinds of low-level optimizations, which is not generally true!

--
You received this message because you are subscribed to the Google Groups "elixir-lang-core" group.
To unsubscribe from this group and stop receiving emails from it, send an email to elixir-lang-co...@googlegroups.com.
To view this discussion on the web visit https://groups.google.com/d/msgid/elixir-lang-core/39ffaaed-e880-4ead-87a9-83a210639969n%40googlegroups.com.

[Christopher Keele]

> I am worried making it a macro will signal to developers they need to worry about these kinds of low-level optimizations, which is not generally true!

Devil's advocate, one (of many) reasons why dev's shouldn't need to worry about these kinds of optimizations is because the language is conscientious about doing them for devs!

[sabi...@gmail.com]

Thanks Jose and Christopher for your replies!

> I am worried making it a macro will signal to developers they need to worry about these kinds of low-level optimizations, which is not generally true!

I agree this is a legitimate concern and I totally understand if you prefer to keep this a function.

I'm a bit biased because I spent some time lately on some low-level optimizations, which are indeed not very representative of the typical use cases.

I probably wouldn't even have thought about it if these functions weren't part of Kernel, which seems to be made of many macros already (searching for (macro) in the Kernel docs yield 58 results!).

So it might not be such a strong signal in this particular case?

> Devil's advocate, one (of many) reasons why dev's shouldn't need to worry about these kinds of optimizations is because the language is conscientious about doing them for devs!

I think this is the main argument: if the idiomatic way is also the most performant possible, you don't even have to think about it and to choose between the two.

But this thinking taken to an extreme could lead to much overkill complexity, so the question I suppose is about whether it is relevant or overkill in this particular case?

I honestly wouldn't know :)

[José Valim]

Alright, please send a pull request so we can also collect the feedback of the rest of the Elixir team. :)

--

You received this message because you are subscribed to the Google Groups "elixir-lang-core" group.
To unsubscribe from this group and stop receiving emails from it, send an email to elixir-lang-co...@googlegroups.com.

To view this discussion on the web visit https://groups.google.com/d/msgid/elixir-lang-core/1581c1d4-6d38-418d-ab3b-78c2fe3ed4a0n%40googlegroups.com.

[Fernando Tapia Rico]

One benefit of implementing it with functions is the is_function guards, which provide a better user experience in case of bad arguments :)

[Allen Madsen]

A macro should be able to tell if a function was passed in most cases at runtime.

Allen Madsen
http://www.allenmadsen.com

To view this discussion on the web visit https://groups.google.com/d/msgid/elixir-lang-core/d462bbad-457b-4a6d-9180-03f5feff40b4n%40googlegroups.com.

[Allen Madsen]

I meant compile time.

Allen Madsen
http://www.allenmadsen.com

[Ben Wilson]

Unfortunately it cannot do this in all cases:

fun = &IO.inspect/1

foo

|> tap(fun)

|> blah

`tap` as a macro has no ability to know whether `fun` is a function at compile time.