Add support for Elixir

[GoogleCodeExporter]

Add syntax highlighting support for Elixir: http://elixir-lang.org

Original issue reported on code.google.com by di...@heyboyo.com on 22 Nov 2013 at 8:41

[sheharyarn]

Bump! I hope this gets implemented soon! 😩

[ibizaman]

In the meantime, I find the Python prettyfier does a great job for Elixir.

[sheharyarn]

The only reason I keep coming back here is to see Elixir Syntax Highlighting on Stackoverflow (which uses this library).

[mikesamuel]

Is there a grammar for Elixir handy? Is it's syntax similar to any other language?

[OvermindDL1]

Is there a grammar for Elixir handy? Is it's syntax similar to any other language?

It is 'fairly' similar to Ruby, it is basically an immutable, functional Ruby without the weird monkey-patching stuff. Could probably start with that. It is a very macro-driven language, has few to no keywords, though some like def are fairly ubiquitous for function definition and defmodule for defining a module and such, but technically even those are macros and may change what they mean depending on if another macro context or not. I guess it would be best to describe it as a Lisp Macro system of a language with a Ruby syntax... Intensely powerful, though keywords can be even project dependent. I can get you a list of the 'global' ones though, but things should be colorized based on context and usage as well, not just simple regex.

[mikesamuel]

I don't care about the distinction between reserved keywords and macro names. If the elixir community benefits from something being presented as a keyword, then put it on the keyword list.

Saying it's similar to Ruby doesn't help me much since the canonical ruby grammar is 12k lines of dense yacc.

Is # comment a line comment? What about

=begin
...
=end

blocks?

What are string delimiters?
Is there any syntax for variable interpolation within a string?

Are ' allowed in identifiers?

Are there any facilities for embedding a language? Not just a macro invocation, but ways of changing the lexical conventions?

Are there any naming conventions that are widely followed especially ones that could distinguish types from variables reasonably reliably? Like UpperCamelCase types in Java.

What file extensions are typically used for Elixir sources? Are the lexical conventions the same for all of those?

[OvermindDL1]

As in it was 'based' on ruby, but simplified to remove cruft.

Is # comment a line comment? What about

=begin
...
=end
blocks?

Thank god no, just # to end of line.

What are string delimiters?
Is there any syntax for variable interpolation within a string?

A few kinds for a few different string types:
"binary string here" = " are binary string delimiters
'charlist string here' = ' are charlist string delimiters
"Interpolations is #{"supported in these blocks"}" = #{..code} allows for arbitrary code within a string, as long as it returns a binary/charlist of the same type as the outer type
"Escapes\nare supported too" = \ escapes of the usual C variety are supported.

Charlist is a list of integral characters:
[72, 105] = 'Hi'

Binary is a UTF-8 encoded binary:
<<72, 105>> = "Hi"

Strings can naturally be multi-line. However for ease of embedding " or ' in a string, or both, you can triple up " or ', such as:

"""a biniary string""" = "a binary string"
'''a charlist string''' = 'a charlist string'
"""both support multi-
line""" = "both support multi-
line"

There are also sigil's, they start with ~ then have a single character, if the single character is upper-case then no escaping or interpolation is performed, if lower-case then it is, the sigil can have a unique set of delimiters in the supported list of <>, {}, [], (), ||, //, "", or '', and after the closing delimiter can have a set of options. You cannot embed a delimiter set within itself, so something like ~s( this is an ( invalid ) string) since it terminates at the first ). The character if:
c/C = Creates a charlist, thus ~c{Hello World} =Hello World, and C turns off interpolation/escaping s/S = Creates a binary, thus~s(Hello World) = "Hello World", etc...
w/W = Creates a list of binary words separated by spaced, thus ~w[Hello World] = ["Hello", "World"]
r/R = Create a regex from the string, thus ~r/foo/iu = Regex.compile("foo", "iu")

Users can create their own sigils using any identifier character not used from above.

Are ' allowed in identifiers?

Nope.

Are there any facilities for embedding a language? Not just a macro invocation, but ways of changing the lexical conventions?

Other than macro's strings can also be processed via macros, thus yes you can define any language, can embed python if you want, so for example someone could define this:

# ~P Could call something like `Python.compile(codeString)` and could output elixir AST for example
output = ~P{
  def greet(name):
      print 'Hello', name
}
output.greet("world")

However those are always delimited by one of the above string delimiters, where """ unique code here """ or ''' stuff ''' is the most common format. And yes some of these exist, an template system one is built into elixir for example, compiles the template to fast executable AST at compile-time, usually used for html templates and such.

Are there any naming conventions that are widely followed especially ones that could distinguish types from variables reasonably reliably? Like UpperCamelCase types in Java.

Language enforced actually. First of all the language is dynamically, not statically typed. Basically you have:
Identifiers start with [a-zA-Z], followed by any number of [a-zA-Z0-9@_], followed by an optional ! or ? (or nothing).
Atoms = They always start with : or end with : if they are used as a key, or they are upper-case. If upper-case initial character they are an identifier but with optional dots . anywhere between the beginning and end characters excepting ! or ? at the end (as they are not available standalone). In essence :atom is an atom, Atom is a different atom (equal to :"Atom"), if used as a key in a map or so the : can be at the end like ${key: value} = %{:key => value}, and any identifier starting with an upper-case character is an Atom, unquestionably. An Atom is a program-wide unique enumeration, :atom will always equal :atom but will never equal a :different atom, highly efficient, used everywhere (simple integer comparison at run-time). Atoms can support arbitrary characters if they are wrapped in delimiters like :"this atom has spaces".
Modules are just atoms with dots between them, so MyModule.SubModule is just an atom, but with a dot followed by a lowercase lettered identifier, like MyModule.SubModule.myFunc references a function on the MyModule.SubModule module named myFunc.
Function reference: To point to a function (for anonymous application or so) the arity of the function followed the reference of the function, thus MyModule.SubModule.myFunc/2 says that you are pointing to the specific function of myFunc that takes two arguments.
A function reference or anonymous function is called via dot syntax on an identifier that starts with a lower-case character. There is no namespace overlap between bindings and function names, thus something.() calls an anonymous function on the binding something, and something() calls the local function something. If something is referenced without () it is always a binding/variable.

What file extensions are typically used for Elixir sources? Are the lexical conventions the same for all of those?

*.ex is an elixir source file.
*.exs is an elixir script that can be executed directly.
*.eex is the template format as its own file for convenience, it uses a file extension before it to define a base type, so "something.html.eex" is an eex template for the html format, or "something.text.eex" or "something.whatever.eex", etc....

Those are the only source files to worry about that are built in with Elixir.

More information about its parser is available in the parser description itself, it is an easy to parse language overall though, this is the actual parser itself (yrl format, kind of like yacc): https://github.com/elixir-lang/elixir/blob/master/lib/elixir/src/elixir_parser.yrl

The Atom editor plugin has grammars as well that work decently (and is simple): https://github.com/elixir-lang/language-elixir/tree/master/grammars

The Intellij plugin has a lex parser that can be used for reference at (although it is not quite accurate: https://github.com/KronicDeth/intellij-elixir/blob/master/src/org/elixir_lang/Elixir.flex

[nietaki]

I submitted a PR for adding Elixir support, feel free to have a look: #478

[nietaki]

This can probably be closed once #478 gets included in a release.