layout: getting_started

guide: 19

<div class="toc"></div>

We have already learned Elixir provides double-quoted strings and single-quoted char lists. However, this only covers the surface of structures that have textual representation in the language. Atoms are, for example, another structure which are mostly created via the `:atom` representation.

One of Elixir's goals is extensibility: developers should be able to extend the language to particular domains. Computer science has become such a wide field that it is impossible for a language to tackle many fields as part of its core. Our best bet is to rather make the language extensible, so developers, companies and communities can extend the language to their relevant domains.

In the chapter, we are going to explore sigils, which are one of the mechanisms provided by the language for working with textual representations.

Sigils start with the tilde (`~`) character which is followed by a letter and then a separator. The most common sigil in Elixir is `~r` for [regular expressions](https://en.wikipedia.org/wiki/Regular_Expressions):

Elixir provides Perl-compatible regular expressions (regexes), as implemented by the [PCRE](http://www.pcre.org/) library. Regexes also support modifiers. For example, the `i` modifier makes a regular expression case insensitive:

Check out the [`Regex` module](/docs/stable/elixir/Regex.html) for more information on other modifiers and the supported operations with regular expressions.

So far, all examples have used `/` to delimit a regular expression. However sigils support 8 different separators:

The reasoning in supporting different operators is that different separators can be more convenient to different sigils. For example, using parentheses for regular expressions may be a confusing choice as they can get mixed with the parentheses inside the regex. However, parentheses can be handy for other sigils, as we will see in the next section.

Besides regular expressions, Elixir ships with three other sigils.

The `~s` sigil is used to generate strings, similar to double quotes:

While `~c` is used to generate char lists:

The `~w` sigil is used to generate a list of words separated by white space:

The `~w` sigil also accepts the `c`, `s` and `a` modifiers (for char lists, strings and atoms, respectively) to choose the format of the result:

Besides lowercase sigils, Elixir supports uppercase sigils. While both `~s` and `~S` will return strings, the first one allows escape codes and interpolation while the second does not:

The following escape codes can be used in strings and char lists:

* `\"` – double quote

* `\'` – single quote

* `\\` – single backslash

* `\xDD` - character with hexadecimal representation DD (example: `\x13`)

* `\x{D...}` - character with hexadecimal representation with one or more hexadecimal digits (example: `\x{abc13}`)

Sigils also support heredocs, which is when triple double- or single-quotes are used as separators:

The most common case for heredoc sigils is when writing documentation. For example, if you need to write escape characters in your documentation, it can become error prone as we would need to double-escape some characters:

def convert(...)

```

```elixir

def convert(...)

```

As hinted at the beginning of this chapter, sigils in Elixir are extensible. In fact, the sigil `~r/foo/i` is equivalent to calling the `sigil_r` function with two arguments:

```

That said, we can access the documentation for the `~r` sigil via the `sigil_r` function:

```iex

iex> h sigil_r

...

```

We can also provide our own sigils by simply implementing the proper function. For example, let's implement the `~i(13)` sigil that returns an integer: