* Streams
* Actual macros
* Mutable variables (not data, of course)
Those would be kind of a pain to do in Erlang, maybe with parse transforms.
I personally prefer Erlang better. I like its syntax and immutable variables. Haven't hit a need to need macros too badly yet.
Everywhere pretty much. Learn a bit more how it works. Here is a good resource:
http://elixir-lang.org/getting-started/introduction.html
Here is an example:
iex(1)> x=1
1
iex(2)> x=2
2
To compare here is Erlang:
1> X=1.
1
2> X=2.
** exception error: no match of right hand side value 2
Again, Elixir does not create mutation where in Erlang there was none. There is no mutation.
They decided to allow rebinding so that you wouldn't end up with a whole bunch of stupid temporary variables, which is exactly what you have to do in Erlang.
You are probably trying to say that Elixir and Erlang have immutable data. But that's what that's called "immutable data". Precisely because the variables can be mutated or not separately from the data.
> a whole bunch of stupid temporary variables, which is exactly what you have to do in Erlang.
Well we should tell Joe that it's stupid. Maybe he'll change his mind.
Other languages, like Ruby, do not work this way. If you reassign an instance variable, the memory that is storing that value actually does change.
Here, compare the same sequence of operations in Ruby and Elixir, first Ruby:
bash>> irb
>> a = {a: 5}
=> {:a=>5}
>> b = a
=> {:a=>5}
>> a[:a] = 10
=> 10
>> b
=> {:a=>10}
bash>> iex
Erlang/OTP 18 [erts-7.1] [source] [64-bit] [smp:8:8] [async-threads:10] [hipe] [kernel-poll:false] [dtrace]
Interactive Elixir (1.1.0) - press Ctrl+C to exit (type h() ENTER for help)
iex(1)> a = %{a: 5}
%{a: 5}
iex(2)> b = a
%{a: 5}
iex(3)> a = %{a | a: 10} # updates a mapping
%{a: 10}
iex(4)> b
%{a: 5}
I think we are talking about two different things when we say "variables". When I say "variable" I mean x, y, a, b etc. That is the variable. It has a value, you can see it in the shell (repl) or when printing it. Look at what happens to variable x:
iex(1)> x=1
1
iex(2)> x=2
2
Compare to Erlang:
1> X=1.
1
2> X=2.
** exception error: no match of right hand side value 2
What you showed in your example is how data is immutable in Elixir but not in Ruby.
> The advantage of this is concurrency, etc. etc.
Actually most data, except larger binaries, are copied between processes anyway. So concurrency advantage is mostly theoretical. In the future they could be switched to reference counting for other things. But that is a hidden implementation detail anyway.