Maps are key-value data structures:

iex> map = %{"hello" => :world}

%{"hello" => :world}

iex> map["hello"]

Maps can be pattern matched on:

iex> %{"hello" => world} = map

%{"hello" => :world}

iex> world

Maps also provide special syntax for creating, accessing and updating maps with atom keys:

iex> user = %{name: "john", age: 27}

%{name: "john", age: 27}

iex> user.name

Both access and update syntax above expect the given keys to exist. Trying to access or update a key that does not exist raises an error:

iex> %{ user | address: [] }

** (ArgumentError) argument error

:maps.update(:address, [], %{})

Records can also be created and pattern matched on:

iex> user = User[name: "john"]

User[name: "john", age: 0]

iex> user.name

Now a `User` struct can be created without a need to explicitly list all necessary fields:

iex> user = %User{name: "john"}

%User{name: "john", age: 0}

Trying to create a struct with an unknown key raises an error during compilation:

iex> user = %User{address: []}

** (CompileError) unknown key :address for struct User

Furthermore, every struct has a `__struct__` field which contains the struct name:

iex> user.__struct__

The most common use case of a comprehension are [list comprehensions](https://en.wikipedia.org/wiki/List_comprehension). For example, we can get all the square values of elements in a list as follows:

iex> for n <- [1, 2, 3, 4], do: n * n

[1, 4, 9, 16]

We say the `n <- [1, 2, 3, 4]` part is a comprehension generator. In previous Elixir versions, Elixir supported only lists in generators. In Elixir v0.13.0, any Enumerable is supported (ranges, maps, etc):

iex> for n <- 1..4, do: n * n

[1, 4, 9, 16]

As in previous Elixir versions, there is also support for a bitstring generator. In the example below, we receive a stream of RGB pixels as a binary and break it down into triplets:

iex> pixels = <<213, 45, 132, 64, 76, 32, 76, 0, 0, 234, 32, 15>>

iex> for <<r::8, g::8, b::8 <- pixels>>, do: {r, g, b}

[{213, 45, 132}, {64, 76, 32}, {76, 0, 0}, {234, 32, 15}]

By default, a comprehension returns a list as a result. However the result of a comprehension can be inserted into different data structures by passing the `:into` option. For example, we can use bitstring generators with the `:into` option to easily remove all spaces in a string:

iex> for <<c <- " hello world ">>, c != ?\s, into: "", do: <<c>>

For example, the `IO` module provides streams, that are both `Enumerable` and `Collectable`. You can implement an echo terminal that returns whatever is typed into the shell, but in upcase, using comprehensions:

iex> stream = IO.stream(:stdio, :line)

iex> for line <- stream, into: stream do

...> String.upcase(line) <> "\n"

We have also added support for variables in map keys. Now you can write:

iex> key = :hello

iex> value = "world"

iex> %{key => value}

This release introduces new accessors to make it simpler for developers to traverse nested data structures, traversing and updating data in different ways. For instance, given a user with a list of languages, here is how to deeply traverse the map and convert all language names to uppercase:

iex> user = %{name: "john",

...> languages: [%{name: "elixir", type: :functional},

...> %{name: "c", type: :procedural}]}

A registry may have unique or duplicate keys. Every key-value pair is associated to the process registering the key. Keys are automatically removed once the owner process terminates. Starting, registering and looking up keys is quite straight-forward:

iex> Registry.start_link(:unique, MyRegistry)

iex> {:ok, _} = Registry.register(MyRegistry, "hello", 1)

iex> Registry.lookup(MyRegistry, "hello")

And compiled from `iex`:

Interactive Elixir

iex> c("module_name.ex")

[ModuleName]

**Elixir**

iex> a = 1

iex> a = 2

Public functions in modules are globally available, but in order to use macros, you need to opt-in by requiring the module they are defined in.

iex> Integer.is_odd(3)

** (CompileError) iex:1: you must require Integer before invoking the macro Integer.is_odd/1

(elixir) src/elixir_dispatch.erl:97: :elixir_dispatch.dispatch_require/6

For example, if we want to use the `duplicate/2` function from the `List` module several times, we can import it:

iex> import List, only: [duplicate: 2]

iex> duplicate :ok, 3

An alias in Elixir is a capitalized identifier (like `String`, `Keyword`, etc) which is converted to an atom during compilation. For instance, the `String` alias translates by default to the atom `:"Elixir.String"`:

iex> is_atom(String)

iex> to_string(String)

Aliases expand to atoms because in the Erlang <abbr title="Virtual Machine">VM</abbr> (and consequently Elixir) modules are always represented by atoms. For example, that's the mechanism we use to call Erlang modules:

iex> :lists.flatten([1, [2], 3])

[1, 2, 3]

Elixir also provides `++` and `--` to manipulate lists:

iex> [1, 2, 3] ++ [4, 5, 6]

[1, 2, 3, 4, 5, 6]

iex> [1, 2, 3] -- [2]

String concatenation is done with `<>`:

iex> "foo" <> "bar"

Elixir also provides three boolean operators: `or`, `and` and `not`. These operators are strict in the sense that they expect something that evaluates to a boolean (`true` or `false`) as their first argument:

iex> true and true

iex> false or is_atom(:example)

Providing a non-boolean will raise an exception:

iex> 1 and true

** (BadBooleanError) expected a boolean on left-side of "and", got: 1

`or` and `and` are short-circuit operators. They only execute the right side if the left side is not enough to determine the result:

iex> false and raise("This error will never be raised")

iex> true or raise("This error will never be raised")

Besides these boolean operators, Elixir also provides `||`, `&&` and `!` which accept arguments of any type. For these operators, all values except `false` and `nil` will evaluate to true:

iex> 1 || true

Elixir also provides `==`, `!=`, `===`, `!==`, `<=`, `>=`, `<` and `>` as comparison operators:

iex> 1 == 1

iex> 1 != 2

The difference between `==` and `===` is that the latter is more strict when comparing integers and floats:

iex> 1 == 1.0

iex> 1 === 1.0

In Elixir, we can compare two different data types:

iex> 1 < :atom