Elixir language reference

Where can I find a proper Elixir language reference manual? Need it for courses. The web site is very much a tutorial, as are the books.

56 comments

6 7251 56

2017-08-01 22:37:15 UTC

First Post!

minhajuddin

These seem to have all the reference documentation:

http://elixir-lang.org/docs/stable/elixir/Kernel.html

Post #1

Most Liked

michalmuskala

In 1.5 the docs gained some new pages (and expanded some of the old ones):

Syntax reference: Syntax reference – Elixir v1.5.0-rc.0
Operators: Operators – Elixir v1.5.0-rc.0
Guards: Guards – Elixir v1.5.0-rc.0
Unicode syntax: Unicode Syntax – Elixir v1.5.0-rc.0

This forms a large part what I would understand as a “language reference”.

Together with the:

Special forms documentation: Kernel.SpecialForms – Elixir v1.5.0-rc.0
Default imported functions: Kernel – Elixir v1.5.0-rc.0

This covers most, if not all, things you’d be facing using Elixir day-to-day.

Post #17

josevalim

Creator of Elixir

We can easily break that page in two. We can start with the Syntax reference and then have an AST reference that goes over the same sections but containing AST information. This way you get the benefit of both in the same page but you can still learn the syntax without reading through the AST bits.

Post #36

rvirding

Creator of Erlang

I think you need a reference manual for the language. Now most of what most people (me anyway ) would consider language constructs are described in Kernel and Kernel.SpecialForms as if they are function/macro calls, not as language constructs. I know that this is what they really are, and that sometimes this is important, but for describing “the language” this does not make sense. Yes, there are tutorials and books that are good but somewhere I need a reference of the language, or at least what I perceive as being “the language”.

The Erlang reference manual is not too bad in this respect. It is not a formal language description but it systematically goes through all the language constructs. I can find each construct, or group of constructs, and see what they should look like and what they do. For example I can see all the arithmetic operators grouped together with a simple description of what each does. I can also see the relative priorities. You can also link into the module documentation when necessary.

I think being able to group constructs is a useful thing with a reference manual. For example I could see everything about defining macros in one place and get better feeling for how they work together. Or everything about modules in one place.

Another problem with Kernel and Kernel.SpecialForms is that they differentiate between functions and macros which is generally not that interesting for users. It is correct and relevant when describing these modules but not when describing the language. For me the user it is not interesting that case is a macro.

I think the difference between a tutorial/book and a reference manual is that the reference manual is a more structured description while the tutorial/book are often more example driven. You need both but for different things.

I hope this wasn’t too garbled.

Post #14

Last Post!

OvermindDL1

Just an aside, if really should not be a special form or parsed with the syntax or anything of the sort in Elixir, it could easily be just a macro like:

defmacro if(cond_ast, bodies) do
  then_body = bodies[:do]
  else_body = bodies[:else]
  quote do
    cond do
      unquote(cond_ast) -> unquote(then_body)
      true -> unquote(else_body)
    end
  end
end

Or something of that sort. There’s no reason for it to be anything but a macro in Kernel, oh and look it is (although it does some weird stuff like special case the random atom nil and such… *cough* still not a fan of nil being special at all), but yea it is not syntax, nor is def as it is just a macro as well.

The point of this is, since they are macro’s then the user could override them to make them do something else (like how I override def in my defguard library to allow you to define super-guards like is_struct (I still think my style (though complete) of defguard should be built-in to elixir) (I might be in a lisp’y mood…)), but because of that syntax coloring them special may not always make sense, like say in a DSEL.

What I really really hate being special-form’d are things like with and for, both of those could have been done in other more traditionally ‘macro’ ways without the comma-splosion, but since they are special-formed then syntax coloring on them can be specialized…

Post #57