undefined | Better HN

0 pointsaetherson9y ago0 comments

Sure, like this:

  %__MODULE__{buffer | size: buffer.size + 1, queue: :queue.in(item, buffer.queue)}

So that involves a bunch of operators that are very specialized to Elixir -- the %, the | are both very unclear in my opinion. And the __MODULE__ construction is clumsy.

Or worse:

  {:ok, {
      :ets.lookup_element(buffer.ets, pull_index, 2),
      %__MODULE__{buffer |
        size: buffer.size - 1,
        pull_index: rem(pull_index + 1, buffer.max_size)
      }
    }}

Same problem as above, plus the nested set structures that Erlang loves, but which rapidly become super difficult to decipher. Oh, and also the overloading of atoms to work like pseudo-objects.

0 comments

5 comments · 3 top-level

ShaneWilton9y ago· 2 in thread

I agree that your second code example is difficult to read, but I think that is more a result of a lot of logic being inlined into one call, than it is a property of the language.

% and | are going to be unclear if you're an outsider looking in on the language, but that is true for any sort of specialization. I'd be interested to know what languages you find to be readable, because I can all but guarantee that there's aspects of that language that I'd find arcane -- not because they are, but because I don't know the language.

I'm not terribly interested in discussing whether a language is readable or not, because a lot of that is going to come down to subjective opinion, but at the end of the day, I find that Elixir lets me quickly write maintainable code.

I'm not entirely sure what you mean by "overloading of atoms to work like pseudo-objects", do you mind elaborating?

aethersonOP9y ago

Probably too late to reply, but I mean things like :ets.method or :queue.whatever.

karmajunkie9y ago

What you might be missing is that modules names are just atoms, and thats how you get to erlang libraries/applications in elixir. In "MyApp.whatever" MyApp is also an atom. It's not any kind of overloading or object fakeout at all. The use of __MODULE__ just refers to the current module, and its use is quite common.

It's perfectly idiomatic and straightforward to read if you've written enough erlang or elixir to recognize the syntactic elements without the translation hiccup. At this point I find Elixir code a great deal easier to read than a lot of ruby, php, or C++ code I've had to work with in the past. While it may not really be your cup of tea, you can't fairly accuse it of something that has more to go with the reader than the writer.

1 more reply

qaq9y ago

While if you play a bit with Elixir it will likely grow on you, there is nothing preventing you from writing it as something like

element = :ets.lookup_element(buffer.ets, pull_index, 2)

pi = rem(pull_index + 1, buffer.max_size)

buffer = %Buffer.Ets{buffer | size: buffer.size - 1, pull_index: pi}

{:ok, {element, buffer}}

xiaoma9y ago

Many languages use a {obj | prop: new_value} update syntax. Elm is another example.

j / k navigate · click thread line to collapse