Organization and implementation of Elixir

[ijverig]

My question is regarding the implementation of the language:

In Erlang we have element to access tuple elements, setelement to change elements, append_element to append elements to tuples, and so on…

In Elixir we have elem, put_elem and Tuple.append, respectively.

Why some functions like elem and put_elem are part of Kernel in Elixir, while others that seem to be at the same “level” are in proper modules (like Tuple.append)?

For me it’s like saying elem and put_elem are core to the language, and that comes before being into Tuple.

[NobbZ]

elem/2 is guard safe, I think thats the main reason why it is in Kernel.

put_elem is probably in Kernel to line up with put_in/2/3, but I’d like to not see it there as it involves the cost of copying the full tuple.

Tuple.append/2 is probably in its very own module, because it involves the cost of copying should be carefully thought upon before just using it.

These are assumptions based on observations mixed with a bit of personal opinion.

[dom]

The module doc for Tuple has a pretty lengthy explanation.

In short, it’s because having to use functions like Tuple.append/2 is a warning sign that you’re not using tuples as the fixed-size containers they’re meant to be, and so you’re likely to create performance problems, or at least non-idiomatic code.

[peerreynders]

In my view using functions on tuples feels wrong (but there are always exceptions). They seem like intrinsic “values/units” that are constructed with the tuple notation and smashed with destructuring (via pattern-matching).

Strangely with maps I’m quite the opposite - they seem more complex and free form than tuples so I tend towards using functions rather than (yet another) map notation (I guess Clojure made me operator averse/function friendly). I keep having to remind myself:

• that I can pattern match on maps
• and that with map pattern matching ignoring parts is implicit

List are in the middle. I have to be backed into a corner before I use hd/1 or tl/1 preferring the cons notation - probably because that is the bread and butter for pattern matching (for destructuring) - otherwise they are dominated by higher order functions (… and Enum.at/3 makes me cringe).