Learning Elixir: My side-project (opens in new tab)

The moment that the lightbulb went on for me was when I ran `iex -S mix` in my Phoenix project and fired up erlang's observer to see its processes. I realized that phoenix is just a supervision tree made up of different microservices, much more complicated than the toy projects I'd built, but still relied on the same OTP tools and patterns. And once you understand that, it becomes trivial to use OTP to expand the functionality that Phoenix gives you out of the box.

I think what you're trying to say (and I agree if you are) is that Phoenix and Elixir are great, but you are missing out on what makes Elixir so powerful (Erlang/OTP and BEAM) if you stop there.

At the end of the day, they are both built on the same foundational concepts. You might find that you need to look up Erlang docs or find an Erlang SO answer so might as well learn the basic Erlang syntax as well. Then you have access to a larger community. Listen to Erlang Factory or Joe Armstrong's videos and so on.

[1]: https://pragprog.com/book/wwgraphql/craft-graphql-apis-in-el...

E.g

############

# no args

def my_func() do: (something) end

# an array arg, assigning the first to "head and the rest to "tail"

def my_func([ head | tail ]) do: (something) end

# two args, so you'd call this my_func/2 instead of my_func/1.

def my_func([], %{key: val}) do: (something) end

# definition with a guard clause, so it checks the value of the arg when determining whether it matches

def my_func(val) when (val > 10) do: (something) end

# wildcard matcher for any single arg passed

def my_func(_) do: (something) end

############

Pattern matching was my gateway drug for getting into Elixir, and it's just the tip of the iceberg when it comes to what makes the language great to work with. It's particularly elegant when pattern matching responses from HTTP requests, using switch statements. No need to put try catch blocks around everything, just pattern match against a tuple with :ok and a tuple with :error

  right_age(X) when X >= 16, X =< 104 ->
    true;
  right_age(_) ->
    false.

But if you don't mind me nerd-sniping you ... someone's done something a bit crazier recently.

It's called Elmchemy[1], which lets you write Elm that compiles to elixir. Recent blog post[2].

---

[1] https://github.com/wende/elmchemy

[2] https://hackernoon.com/elmchemy-write-type-safe-elixir-code-...

def backlog(board_id) when is_integer(board_id), do: something

and

def backlog(board_id) when is_list(board_id), do: some_list_thing

    function foo: [int: bar] do
      bar * bar
    end

It doesn't let you do things like:

"for (int bar) and 0 <= bar <= 3" while the "when" guard construct can do that. Moreover it lets you have multiple function heads as well. So you can defined multiple for (int bar) with different conditions. Or even a "foo" with a string bar.

The point I think he was trying to make was that Lisp's syntax is less restrictive, but that seemed to get confused by:

- mentioning the some people say it has no syntax (which it definitely does have)

- saying macros can create new syntax (which they can't in Lisp)

Elixir macros are approximately the same as Lisp macros (apart from not being able to take a variable number of arguments).

This is a straight port of that macro into Elixir:

  defp kl_i([k, v | t]) do
    quote do
      [
        {unquote(Macro.escape(k)), unquote v}
        | unquote kl_i t
      ]
    end
  end
  defp kl_i([]), do: quote do: []
  defmacro kl(l), do: kl_i l
  
  # usage
  IO.inspect kl [a, 2 + 7, b, 6]
  # => [{{:a, [line: 16], nil}, 9}, {{:b, [line: 16], nil}, 6}]

  defp escape_key({v1, v2}), do: {escape_key(v1), escape_key(v2)}
  defp escape_key({:{}, pos, els}) when is_list(pos), do: {:{}, pos, Enum.map(els, &escape_key/1)}
  defp escape_key(els) when is_list(els), do: Enum.map(els, &escape_key/1)
  defp escape_key({sym, pos, nil}) when is_list(pos), do: Macro.escape sym

That plus extensive use of list comprehensions when working with arrays.