docs/master/Kernel.html

<!DOCTYPE html>
<html>
  <head>
    <title>Kernel</title>
    <meta charset="utf-8">
    <link rel="stylesheet" href="css/style.css" type="text/css" media="screen" charset="utf-8" />

    <script type="text/javascript" charset="utf-8">
      relpath = '';
      if (relpath != '') relpath += '/';
    </script>

    <script type="text/javascript" charset="utf-8" src="js/jquery.js"></script>
    <script type="text/javascript" charset="utf-8" src="js/app.js"></script>
  </head>

  <body>
    <script type="text/javascript" charset="utf-8">
      if (window.top.frames.main) document.body.className = 'frames';
    </script>

    <div id="content">
      <h1>
        Kernel
        
      </h1>

      
        <div id="moduledoc" class="docstring">
          <p><code>Kernel</code> provides the default macros and functions
Elixir imports into your environment. Those macros and functions
can be skipped or cherry-picked via the <code>import</code> macro. For
instance, if you want to tell Elixir to not import the <code>case</code>
macro, you can do:</p>

<pre><code>import Kernel, except: [case: 2]
</code></pre>

<p>Elixir also has special forms that are always imported and
cannot be skipped. These are described in <code>Kernel.SpecialForms</code>.</p>

<p>Some of the functions described in this module are simply
a proxy to its Erlang counterpart. Although they are documented
here for convenience, you can access their original documentation
at <a href="http://www.erlang.org/doc/man/erlang.html">http://www.erlang.org/doc/man/erlang.html</a>.</p>

        </div>
      

      <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3" target="_blank" class="view_source">Source</a>

      

      

      
        <h2>Functions summary</h2>
        <ul class="summary">
          <li>
  <span class="summary_signature">
    <a href="#abs/1">abs/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#apply/2">apply/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#apply/3">apply/3</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#atom_to_binary/2">atom_to_binary/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#atom_to_list/1">atom_to_list/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#binary_part/3">binary_part/3</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#binary_to_atom/2">binary_to_atom/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#binary_to_existing_atom/2">binary_to_existing_atom/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#binary_to_list/1">binary_to_list/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#binary_to_list/3">binary_to_list/3</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#binary_to_term/1">binary_to_term/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#binary_to_term/2">binary_to_term/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#bit_size/1">bit_size/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#bitstring_to_list/1">bitstring_to_list/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#byte_size/1">byte_size/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#exit/1">exit/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#float/1">float/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#float_to_list/1">float_to_list/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#function_exported?/3">function_exported?/3</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#hd/1">hd/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#integer_to_list/1">integer_to_list/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#integer_to_list/2">integer_to_list/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#iolist_size/1">iolist_size/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#iolist_to_binary/1">iolist_to_binary/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#is_alive/0">is_alive/0</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#is_atom/1">is_atom/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#is_binary/1">is_binary/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#is_bitstring/1">is_bitstring/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#is_boolean/1">is_boolean/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#is_float/1">is_float/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#is_function/1">is_function/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#is_function/2">is_function/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#is_integer/1">is_integer/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#is_list/1">is_list/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#is_number/1">is_number/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#is_pid/1">is_pid/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#is_port/1">is_port/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#is_reference/1">is_reference/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#is_tuple/1">is_tuple/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#length/1">length/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#list_to_atom/1">list_to_atom/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#list_to_binary/1">list_to_binary/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#list_to_bitstring/1">list_to_bitstring/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#list_to_existing_atom/1">list_to_existing_atom/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#list_to_float/1">list_to_float/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#list_to_integer/1">list_to_integer/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#list_to_integer/2">list_to_integer/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#list_to_pid/1">list_to_pid/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#list_to_tuple/1">list_to_tuple/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#macro_exported?/3">macro_exported?/3</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#make_ref/0">make_ref/0</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#max/2">max/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#min/2">min/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#node/0">node/0</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#node/1">node/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#pid_to_list/1">pid_to_list/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#raise/1">raise/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#raise/2">raise/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#round/1">round/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#self/0">self/0</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#size/1">size/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#spawn/1">spawn/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#spawn/3">spawn/3</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#spawn_link/1">spawn_link/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#spawn_link/3">spawn_link/3</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#term_to_binary/1">term_to_binary/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#term_to_binary/2">term_to_binary/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#throw/1">throw/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#tl/1">tl/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#trunc/1">trunc/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#tuple_size/1">tuple_size/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#tuple_to_list/1">tuple_to_list/1</a>
  </span>
</li>

        </ul>
      

      
        <h2>Macros summary</h2>
        <ul class="summary">
          <li>
  <span class="summary_signature">
    <a href="#!/1">!/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#!=/2">!=/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#!==/2">!==/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#&amp;&amp;/2">&amp;&amp;/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#*/2">*/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#+/2">+/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#++/2">++/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#-/2">-/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#--/2">--/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#../2">../2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#//2">//2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#/&gt;/2">/&gt;/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#&lt;/2">&lt;/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#&lt;-/2">&lt;-/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#&lt;=/2">&lt;=/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#&lt;&gt;/2">&lt;&gt;/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#==/2">==/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#===/2">===/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#=~/2">=~/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#&gt;/2">&gt;/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#&gt;=/2">&gt;=/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#@/1">@/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#__B__/2">__B__/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#__C__/2">__C__/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#__R__/2">__R__/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#__b__/2">__b__/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#__c__/2">__c__/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#__r__/2">__r__/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#access/2">access/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#and/2">and/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#atom_to_binary/1">atom_to_binary/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#binary_to_atom/1">binary_to_atom/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#binary_to_existing_atom/1">binary_to_existing_atom/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#binary_to_float/1">binary_to_float/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#binary_to_integer/1">binary_to_integer/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#binary_to_integer/2">binary_to_integer/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#case/2">case/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#cond/1">cond/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#def/2">def/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#def/4">def/4</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#defdelegate/2">defdelegate/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#defexception/4">defexception/4</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#defimpl/3">defimpl/3</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#defmodule/2">defmodule/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#defoverridable/1">defoverridable/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#defp/2">defp/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#defp/4">defp/4</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#defprotocol/2">defprotocol/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#defrecord/4">defrecord/4</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#defrecordp/2">defrecordp/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#destructure/2">destructure/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#div/2">div/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#elem/2">elem/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#float_to_binary/1">float_to_binary/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#function/1">function/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#if/2">if/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#in/2">in/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#inspect/2">inspect/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#integer_to_binary/1">integer_to_binary/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#integer_to_binary/2">integer_to_binary/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#is_exception/1">is_exception/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#is_range/1">is_range/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#is_record/2">is_record/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#is_regex/1">is_regex/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#match?/2">match?/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#nil?/1">nil?/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#not/1">not/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#or/2">or/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#receive/1">receive/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#rem/2">rem/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#setelem/3">setelem/3</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#to_binary/1">to_binary/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#to_char_list/1">to_char_list/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#try/1">try/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#unless/2">unless/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#use/2">use/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#var!/1">var!/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#xor/2">xor/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#||/2">||/2</a>
  </span>
</li>

        </ul>
      

      

      
        <div id="functions_details" class="details_list">
          <h2>Functions</h2>
          <div class="detail">
  <p class="signature" id="abs/1">
    <strong>abs(number)</strong>
  </p>
  <div class="docstring"><p>Returns an integer or float which is the arithmetical absolute value of <code>number</code>.</p>

<p>Allowed in guard tests.</p>

<h2>Examples</h2>

<pre><code>abs(-3.33) #=&gt; 3.33
abs(-3)    #=&gt; 3
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L303" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="apply/2">
    <strong>apply(fun, args)</strong>
  </p>
  <div class="docstring"><p>Invokes the given <code>fun</code> with the array of arguments <code>args</code>.</p>

<h2>Examples</h2>

<pre><code>apply fn x -&gt; x * 2 end, [2]
#=&gt; 4
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L317" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="apply/3">
    <strong>apply(module, fun, args)</strong>
  </p>
  <div class="docstring"><p>Invokes the given <code>fun</code> from <code>module</code> with the array of arguments <code>args</code>.</p>

<h2>Examples</h2>

<pre><code>apply List, reverse, [[1,2,3]]
#=&gt; [3,2,1]
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L331" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="atom_to_binary/2">
    <strong>atom_to_binary(atom, encoding)</strong>
  </p>
  <div class="docstring"><p>Returns a binary which corresponds to the text representation of <code>atom</code>.
If <code>encoding</code> is latin1, there will be one byte for each character in the text
representation. If <code>encoding</code> is utf8 or unicode, the characters will be encoded
using UTF-8 (meaning that characters from 16#80 up to 0xFF will be encoded in
two bytes).</p>

<h2>Examples</h2>

<pre><code>atom_to_binary(:elixir, :utf8) #=&gt; &quot;elixir&quot;
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L348" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="atom_to_list/1">
    <strong>atom_to_list(atom)</strong>
  </p>
  <div class="docstring"><p>Returns a string which corresponds to the text representation of <code>atom</code>.</p>

<h2>Examples</h2>

<pre><code>atom_to_list(:elixir) #=&gt; &#39;elixir&#39;
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L361" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="binary_part/3">
    <strong>binary_part(binary, start, length)</strong>
  </p>
  <div class="docstring"><p>Extracts the part of the binary starting at <code>start</code> with length <code>length</code>.
Binaries are zero-indexed.</p>

<p>If start or length references in any way outside the binary, an
<code>ArgumentError</code> exception is raised.</p>

<p>Allowed in guard tests.</p>

<h2>Examples</h2>

<pre><code>binary_part &quot;foo&quot;, 1, 2 #=&gt; &quot;oo&quot;
</code></pre>

<p>A negative length can be used to extract bytes at the end of a binary:</p>

<pre><code>binary_part &quot;foo&quot;, 3, -1 #=&gt; 1
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L384" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="binary_to_atom/2">
    <strong>binary_to_atom(binary, encoding)</strong>
  </p>
  <div class="docstring"><p>Returns the atom whose text representation is <code>binary</code>. If <code>encoding</code> is latin1,
no translation of bytes in the binary is done. If <code>encoding</code> is utf8 or unicode,
the binary must contain valid UTF-8 sequences; furthermore, only Unicode
characters up to 0xFF are allowed.</p>

<h2>Examples</h2>

<pre><code>binary_to_atom(&quot;elixir&quot;, :utf8) #=&gt; :elixir
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L400" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="binary_to_existing_atom/2">
    <strong>binary_to_existing_atom(binary, encoding)</strong>
  </p>
  <div class="docstring"><p>Works like <code>binary_to_atom/2</code>, but the atom must already exist.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L408" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="binary_to_list/1">
    <strong>binary_to_list(binary)</strong>
  </p>
  <div class="docstring"><p>Returns a list of integers which correspond to the bytes of <code>binary</code>.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L416" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="binary_to_list/3">
    <strong>binary_to_list(binary, start, stop)</strong>
  </p>
  <div class="docstring"><p>As binary<em>to</em>list/1, but returns a list of integers corresponding to the bytes
from position <code>start</code> to position <code>stop</code> in <code>binary</code>. Positions in the binary
are numbered starting from 1.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L426" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="binary_to_term/1">
    <strong>binary_to_term(binary)</strong>
  </p>
  <div class="docstring"><p>Returns an Erlang term which is the result of decoding the binary
object <code>binary</code>, which must be encoded according to the Erlang external
term format.</p>

<h2>Examples</h2>

<pre><code>binary_to_term(term_to_binary(&quot;foo&quot;)) #=&gt; &quot;foo&quot;
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L441" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="binary_to_term/2">
    <strong>binary_to_term(binary, options)</strong>
  </p>
  <div class="docstring"><p>As <code>binary_to_term/1</code>, but accepts a safe option useful when receiving
binaries from an untrusted source.</p>

<p>When enabled, it prevents decoding data that may be used to attack the
Erlang system. In the event of receiving unsafe data, decoding fails
with a badarg error.</p>

<p>Currently, this prevents creation of new atoms directly, creation of
new atoms indirectly (as they are embedded in certain structures like pids,
refs, funs, etc), and creation of new external function references. None
of those resources are currently garbage collected, so unchecked creation
of them can exhaust available memory.</p>

<h2>Examples</h2>

<pre><code>binary_to_term(term_to_binary(&quot;foo&quot;), [:safe])
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L465" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="bit_size/1">
    <strong>bit_size(bitstring)</strong>
  </p>
  <div class="docstring"><p>Returns an integer which is the size in bits of <code>bitstring</code>.</p>

<p>Allowed in guard tests.</p>

<h2>Examples</h2>

<pre><code>bit_size(&lt;&lt;433|16,3|3&gt;&gt;) #=&gt; 19
bit_size(&lt;&lt;1,2,3&gt;&gt;) #=&gt; 24
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L481" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="bitstring_to_list/1">
    <strong>bitstring_to_list(bitstring)</strong>
  </p>
  <div class="docstring"><p>Returns a list of integers which correspond to the bytes of <code>bitstring</code>. If the
number of bits in the binary is not divisible by 8, the last element of the list will
be a bitstring containing the remaining bits (1 up to 7 bits).</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L491" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="byte_size/1">
    <strong>byte_size(bitstring)</strong>
  </p>
  <div class="docstring"><p>Returns an integer which is the number of bytes needed to contain <code>bitstring</code>.
(That is, if the number of bits in Bitstring is not divisible by 8, the resulting
number of bytes will be rounded up.)</p>

<p>Allowed in guard tests.</p>

<h2>Examples</h2>

<pre><code>byte_size(&lt;&lt;433|16,3|3&gt;&gt;) #=&gt; 3
byte_size(&lt;&lt;1,2,3&gt;&gt;) #=&gt; 3
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L509" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="exit/1">
    <strong>exit(reason)</strong>
  </p>
  <div class="docstring"><p>Stops the execution of the calling process with the given reason.
Since evaluating this function causes the process to terminate,
it has no return value.</p>

<h2>Examples</h2>

<pre><code>exit(:normal)
exit(:seems_bad)
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L525" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="float/1">
    <strong>float(number)</strong>
  </p>
  <div class="docstring"><p>Converts the given number to a float. Allowed in guard clauses.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L533" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="float_to_list/1">
    <strong>float_to_list(number)</strong>
  </p>
  <div class="docstring"><p>Returns a char list which corresponds to the text representation of the given float.</p>

<h2>Examples</h2>

<pre><code>float_to_list(7.0)
#=&gt; &#39;7.00000000000000000000e+00&#39;
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L547" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="function_exported?/3">
    <strong>function_exported?(module, function, arity)</strong>
  </p>
  <div class="docstring"><p>Returns true if the <code>module</code> is loaded and contains a
public <code>function</code> with the given <code>arity</code>, otherwise false.</p>

<p>In case a tuple module is given, the <code>arity</code> is automatically
increased by one.</p>

<p>Notice that this function does not load the module in case
it is not loaded. Check <code>Code.ensure_loaded/1</code> for more
information.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2812" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="hd/1">
    <strong>hd(list)</strong>
  </p>
  <div class="docstring"><p>Returns the head of a list, raises badarg if the list is empty.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L555" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="integer_to_list/1">
    <strong>integer_to_list(number)</strong>
  </p>
  <div class="docstring"><p>Returns a char list which corresponds to the text representation of the given integer.</p>

<h2>Examples</h2>

<pre><code>integer_to_list(7)
#=&gt; &#39;7&#39;
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L569" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="integer_to_list/2">
    <strong>integer_to_list(number, base)</strong>
  </p>
  <div class="docstring"><p>Returns a char list which corresponds to the text representation of the
given integer in the given case.</p>

<h2>Examples</h2>

<pre><code>integer_to_list(1023, 16).
#=&gt; &quot;3FF&quot;
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L584" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="iolist_size/1">
    <strong>iolist_size(item)</strong>
  </p>
  <div class="docstring"><p>Returns the size of an iolist.</p>

<h2>Examples</h2>

<pre><code>iolist_size([1,2|&lt;&lt;3,4&gt;&gt;])
#=&gt; 4
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L598" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="iolist_to_binary/1">
    <strong>iolist_to_binary(item)</strong>
  </p>
  <div class="docstring"><p>Returns a binary which is made from the integers and binaries in iolist.</p>

<h2>Examples</h2>

<pre><code>bin1 = &lt;&lt;1,2,3&gt;&gt;
bin2 = &lt;&lt;4,5&gt;&gt;
bin3 = &lt;&lt;6&gt;&gt;

iolist_to_binary([bin1,1,[2,3,bin2],4|bin3])
#=&gt; &lt;&lt;1,2,3,1,2,3,4,5,4,6&gt;&gt;
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L616" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="is_alive/0">
    <strong>is_alive()</strong>
  </p>
  <div class="docstring"><p>Returns true if the local node is alive; that is,
if the node can be part of a distributed system.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L625" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="is_atom/1">
    <strong>is_atom(term)</strong>
  </p>
  <div class="docstring"><p>Returns true if <code>term</code> is an atom; otherwise returns false.</p>

<p>Allowed in guard tests.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L635" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="is_binary/1">
    <strong>is_binary(term)</strong>
  </p>
  <div class="docstring"><p>Returns true if <code>term</code> is a binary; otherwise returns false.</p>

<p>A binary always contains a complete number of bytes.</p>

<p>Allowed in guard tests.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L647" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="is_bitstring/1">
    <strong>is_bitstring(term)</strong>
  </p>
  <div class="docstring"><p>Returns true if <code>term</code> is a bitstring (including a binary); otherwise returns false.</p>

<p>Allowed in guard tests.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L657" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="is_boolean/1">
    <strong>is_boolean(term)</strong>
  </p>
  <div class="docstring"><p>Returns true if <code>term</code> is either the atom <code>true</code> or the atom <code>false</code> (i.e. a boolean);
otherwise returns false.</p>

<p>Allowed in guard tests.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L668" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="is_float/1">
    <strong>is_float(term)</strong>
  </p>
  <div class="docstring"><p>Returns true if <code>term</code> is a floating point number; otherwise returns false.</p>

<p>Allowed in guard tests.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L678" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="is_function/1">
    <strong>is_function(term)</strong>
  </p>
  <div class="docstring"><p>Returns true if <code>term</code> is a function; otherwise returns false.</p>

<p>Allowed in guard tests.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L688" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="is_function/2">
    <strong>is_function(term, arity)</strong>
  </p>
  <div class="docstring"><p>Returns true if <code>term</code> is a function that can be applied with <code>arity</code> number of arguments;
otherwise returns false.</p>

<p>Allowed in guard tests.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L699" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="is_integer/1">
    <strong>is_integer(term)</strong>
  </p>
  <div class="docstring"><p>Returns true if <code>term</code> is an integer; otherwise returns false.</p>

<p>Allowed in guard tests.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L709" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="is_list/1">
    <strong>is_list(term)</strong>
  </p>
  <div class="docstring"><p>Returns true if <code>term</code> is a list with zero or more elements; otherwise returns false.</p>

<p>Allowed in guard tests.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L719" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="is_number/1">
    <strong>is_number(term)</strong>
  </p>
  <div class="docstring"><p>Returns true if <code>term</code> is either an integer or a floating point number;
otherwise returns false.</p>

<p>Allowed in guard tests.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L730" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="is_pid/1">
    <strong>is_pid(term)</strong>
  </p>
  <div class="docstring"><p>Returns true if <code>term</code> is a pid (process identifier); otherwise returns false.</p>

<p>Allowed in guard tests.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L740" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="is_port/1">
    <strong>is_port(term)</strong>
  </p>
  <div class="docstring"><p>Returns true if <code>term</code> is a port identifier; otherwise returns false.</p>

<p>Allowed in guard tests.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L750" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="is_reference/1">
    <strong>is_reference(term)</strong>
  </p>
  <div class="docstring"><p>Returns true if <code>term</code> is a reference; otherwise returns false.</p>

<p>Allowed in guard tests.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L760" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="is_tuple/1">
    <strong>is_tuple(term)</strong>
  </p>
  <div class="docstring"><p>Returns true if <code>term</code> is a tuple; otherwise returns false.</p>

<p>Allowed in guard tests.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L770" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="length/1">
    <strong>length(list)</strong>
  </p>
  <div class="docstring"><p>Returns the length of <code>list</code>.</p>

<p>Allowed in guard tests.</p>

<h2>Examples</h2>

<pre><code>length([1,2,3,4,5,6,7,8,9]) #=&gt; 9
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L784" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="list_to_atom/1">
    <strong>list_to_atom(char_list)</strong>
  </p>
  <div class="docstring"><p>Returns the atom whose text representation is <code>char_list</code>.</p>

<h2>Examples</h2>

<pre><code>list_to_atom(&#39;elixir&#39;) #=&gt; :elixir
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L796" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="list_to_binary/1">
    <strong>list_to_binary(char_list)</strong>
  </p>
  <div class="docstring"><p>Returns a binary which is made from the content of <code>char_list</code>.</p>

<h2>Examples</h2>

<pre><code>list_to_binary(&#39;Elixir&#39;) #=&gt; &quot;Elixir&quot;
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L808" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="list_to_bitstring/1">
    <strong>list_to_bitstring(bitstring_list)</strong>
  </p>
  <div class="docstring"><p>Returns a bitstring which is made from the integers and bitstrings in <code>bitstring_list</code>.
(the last tail in <code>bitstring_list</code> is allowed to be a bitstring.)</p>

<h2>Examples</h2>

<pre><code>bin1 = &lt;&lt;1,2,3&gt;&gt;
bin2 = &lt;&lt;4,5&gt;&gt;
bin3 = &lt;&lt;6,7|4&gt;&gt;

list_to_bitstring([bin1,1,[2,3,bin2],4|bin3])
#=&gt; &lt;&lt;1,2,3,1,2,3,4,5,4,6,7|4&gt;&gt;
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L827" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="list_to_existing_atom/1">
    <strong>list_to_existing_atom(char_list)</strong>
  </p>
  <div class="docstring"><p>Returns the atom whose text representation is <code>char_list</code>, but only if there already
exists such atom.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L836" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="list_to_float/1">
    <strong>list_to_float(char_list)</strong>
  </p>
  <div class="docstring"><p>Returns the float whose text representation is <code>char_list</code>.</p>

<h2>Examples</h2>

<pre><code>list_to_float(&#39;2.2017764e+0&#39;) #=&gt; 2.2017764
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L848" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="list_to_integer/1">
    <strong>list_to_integer(char_list)</strong>
  </p>
  <div class="docstring"><p>Returns an integer whose text representation is <code>char_list</code>.</p>

<h2>Examples</h2>

<pre><code>list_to_integer(&#39;123&#39;) #=&gt; 123
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L860" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="list_to_integer/2">
    <strong>list_to_integer(char_list, base)</strong>
  </p>
  <div class="docstring"><p>Returns an integer whose text representation in base <code>base</code> is <code>char_list</code>.</p>

<h2>Examples</h2>

<pre><code>list_to_integer(&#39;3FF&#39;, 16) #=&gt; 1023
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L872" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="list_to_pid/1">
    <strong>list_to_pid(char_list)</strong>
  </p>
  <div class="docstring"><p>Returns a pid whose text representation is <code>char_list</code>.</p>

<h2>Warning:</h2>

<p>This function is intended for debugging and for use in the Erlang
operating system.</p>

<p>It should not be used in application programs.</p>

<h2>Examples</h2>

<pre><code>list_to_pid(&#39;&lt;0.41&gt;&#39;) #=&gt; &lt;0.4.1&gt;
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L890" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="list_to_tuple/1">
    <strong>list_to_tuple(list)</strong>
  </p>
  <div class="docstring"><p>Returns a tuple which corresponds to <code>list</code>. <code>list</code> can contain any Erlang terms.</p>

<h2>Examples</h2>

<pre><code>list_to_tuple([:share, [:elixir, 163]]). #=&gt; {:share, [:elixir, 163]}
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L902" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="macro_exported?/3">
    <strong>macro_exported?(module, macro, arity)</strong>
  </p>
  <div class="docstring"><p>Returns true if the <code>module</code> is loaded and contains a
public <code>macro</code> with the given <code>arity</code>, otherwise false.</p>

<p>Notice that this function does not load the module in case
it is not loaded. Check <code>Code.ensure_loaded/1</code> for more
information.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2830" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="make_ref/0">
    <strong>make_ref()</strong>
  </p>
  <div class="docstring"><p>Returns an almost unique reference.</p>

<p>The returned reference will re-occur after approximately 2^82 calls;
therefore it is unique enough for practical purposes.</p>

<h2>Examples</h2>

<pre><code>make_ref()
#=&gt; #Ref&lt;0.0.0.135&gt;
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L919" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="max/2">
    <strong>max(first, second)</strong>
  </p>
  <div class="docstring"><p>Return the biggest of the two given terms according to
Erlang&#39;s term ordering. If the terms compare equal, the
first one is returned.</p>

<h2>Examples</h2>

<pre><code>max(1, 2) #=&gt; 2
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L934" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="min/2">
    <strong>min(first, second)</strong>
  </p>
  <div class="docstring"><p>Return the smallest of the two given terms according to
Erlang&#39;s term ordering. If the terms compare equal, the
first one is returned.</p>

<h2>Examples</h2>

<pre><code>min(1, 2) #=&gt; 1
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L949" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="node/0">
    <strong>node()</strong>
  </p>
  <div class="docstring"><p>Returns an atom representing the name of the local node.
If the node is not alive, nonode@nohost is returned instead.</p>

<p>Allowed in guard tests.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L960" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="node/1">
    <strong>node(arg)</strong>
  </p>
  <div class="docstring"><p>Returns the node where the given argmuent is located.
The argument can be a pid, a reference, or a port.
If the local node is not alive, nonode@nohost is returned.</p>

<p>Allowed in guard tests.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L972" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="pid_to_list/1">
    <strong>pid_to_list(pid)</strong>
  </p>
  <div class="docstring"><p>Returns a char list which corresponds to the text representation of pid.
This function is intended for debugging and for use in the Erlang operating
system. It should not be used in application programs.</p>

<h2>Warning:</h2>

<p>This function is intended for debugging and for use in the Erlang
operating system.</p>

<p>It should not be used in application programs.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L989" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="raise/1">
    <strong>raise(msg)</strong>
  </p>
  <div class="docstring"><p>Raises an error.</p>

<p>If the argument is a binary, it raises RuntimeError with the message.
If anything else, becomes a call to raise(argument, []).</p>

<h2>Examples</h2>

<pre><code>raise &quot;Given values do not match&quot;

try do
  1 + :foo
rescue
  x in [BadargError] -&gt;
    IO.puts &quot;that was expected&quot;
    raise x
end
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2761" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="raise/2">
    <strong>raise(exception, args)</strong>
  </p>
  <div class="docstring"><p>Raises an error.</p>

<p>It calls <code>.exception</code> on the given argument passing
the args in order to retrieve the appropriate exception
structure.</p>

<p>Any module defined via <code>defexception</code> automatically
defines <code>exception(args)</code> that returns a new instance
of the record and a <code>exception(args, current)</code> that
updates the current exception.</p>

<p>Re-raising an exception will retrieve the previous
stacktrace so it keps the properties of the original
exception.</p>

<h2>Examples</h2>

<pre><code>raise ArgumentError, message: &quot;Sample&quot;
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2791" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="round/1">
    <strong>round(number)</strong>
  </p>
  <div class="docstring"><p>Returns an integer by rounding the given number.
Allowed in guard tests.</p>

<h2>Examples</h2>

<pre><code>round(5.5) #=&gt; 6
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1003" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="self/0">
    <strong>self()</strong>
  </p>
  <div class="docstring"><p>Returns the pid (process identifier) of the calling process.
Allowed in guard clauses.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1012" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="size/1">
    <strong>size(arg)</strong>
  </p>
  <div class="docstring"><p>Returns the size of the given argument, which must be a tuple
or a binary. If possible, please use tuple<em>size or binary</em>size.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1021" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="spawn/1">
    <strong>spawn(fun)</strong>
  </p>
  <div class="docstring"><p>Spawns the given function and returns its pid.</p>

<p>Check the modules <code>Process</code> and <code>Node</code> for other functions
to handle processes, including spawning functions in nodes.</p>

<h2>Examples</h2>

<pre><code>current = Process.self
child   = spawn(fn -&gt; current &lt;- { Process.self, 1 + 2 } end)

receive
  { ^child, 3 } -&gt; IO.puts &quot;Received 3 back&quot;
end
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1042" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="spawn/3">
    <strong>spawn(module, fun, args)</strong>
  </p>
  <div class="docstring"><p>Spawns the given module and function passing the given args
and returns its pid.</p>

<p>Check the modules <code>Process</code> and <code>Node</code> for other functions
to handle processes, including spawning functions in nodes.</p>

<h2>Examples</h2>

<pre><code>spawn(SomeModule, :function, [1,2,3])
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1059" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="spawn_link/1">
    <strong>spawn_link(fun)</strong>
  </p>
  <div class="docstring"><p>Spawns the given function, links it to the current process and returns its pid.</p>

<p>Check the modules <code>Process</code> and <code>Node</code> for other functions
to handle processes, including spawning functions in nodes.</p>

<h2>Examples</h2>

<pre><code>current = Process.self
child   = spawn_link(fn -&gt; current &lt;- { Process.self, 1 + 2 } end)

receive
  { ^child, 3 } -&gt;
    IO.puts &quot;Received 3 back&quot;
end
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1081" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="spawn_link/3">
    <strong>spawn_link(module, fun, args)</strong>
  </p>
  <div class="docstring"><p>Spawns the given module and function passing the given args,
links it to the current process and returns its pid.</p>

<p>Check the modules <code>Process</code> and <code>Node</code> for other functions
to handle processes, including spawning functions in nodes.</p>

<h2>Examples</h2>

<pre><code>spawn_link(SomeModule, :function, [1,2,3])
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1098" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="term_to_binary/1">
    <strong>term_to_binary(term)</strong>
  </p>
  <div class="docstring"><p>Returns a binary data which is the result of encoding the given term
according to the Erlang external term format.</p>

<p>This can be used for a variety of purposes, for example, writing a term
to a file in an efficient way, or sending an Erlang term to some type
of communications channel not supported by distributed :</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1111" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="term_to_binary/2">
    <strong>term_to_binary(term, opts)</strong>
  </p>
  <div class="docstring"><p>The same as <code>term_to_binary/1</code> but also supports two options:</p>

<ul>
<li>compressed: the level of compression to be used from 0 to 9;</li>
<li>minor<em>version: used to control the details of encoding. Can be 0 or 1,
please read <a href="http://www.erlang.org/doc/man/erlang.html#term">http://www.erlang.org/doc/man/erlang.html#term</a></em>to_binary-2
for more details</li>
</ul>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1125" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="throw/1">
    <strong>throw(term)</strong>
  </p>
  <div class="docstring"><p>A non-local return from a function. Check try/2 for more information.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1133" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="tl/1">
    <strong>tl(list)</strong>
  </p>
  <div class="docstring"><p>Returns the tail of a list. Raises ArgumentError if the list is empty.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1141" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="trunc/1">
    <strong>trunc(number)</strong>
  </p>
  <div class="docstring"><p>Returns an integer by the truncating the given number.
Allowed in guard clauses.</p>

<h2>Examples</h2>

<pre><code>trunc(5.5) #=&gt; 5
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1155" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="tuple_size/1">
    <strong>tuple_size(tuple)</strong>
  </p>
  <div class="docstring"><p>Returns the size of a tuple.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1163" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="tuple_to_list/1">
    <strong>tuple_to_list(tuple)</strong>
  </p>
  <div class="docstring"><p>Converts a tuple to a list.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1171" target="_blank" class="view_source">Source</a>
</div>
        </div>
      

      
        <div id="macros_details" class="details_list">
          <h2>Macros</h2>
          <div class="detail">
  <p class="signature" id="!/1">
    <strong>!arg</strong>
  </p>
  <div class="docstring"><p>It receives any argument and returns true if it is false
or nil. Returns false otherwise. Not allowed in guard
clauses.</p>

<h2>Examples</h2>

<pre><code>!1        #=&gt; false
![1,2,3]  #=&gt; false
!false    #=&gt; true
!nil      #=&gt; true
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L168" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="!=/2">
    <strong>left != right</strong>
  </p>
  <div class="docstring"><p>Returns true if the two items are not equal.</p>

<p>This operator considers 1 and 1.0 to be equal. For strict
comparison, use <code>!==</code> instead.</p>

<p>As Erlang, Elixir can compare any term. Allowed in guard clauses.</p>

<h2>Examples</h2>

<pre><code>1 != 2
#=&gt; true
1 != 1.0
#=&gt; false
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L253" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="!==/2">
    <strong>left !== right</strong>
  </p>
  <div class="docstring"><p>Returns true if the two items are strictly not equal.
As Erlang, Elixir can compare any term. Allowed in guard clauses.</p>

<h2>Examples</h2>

<pre><code>1 !== 2
#=&gt; true

1 !== 1.0
#=&gt; true
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L283" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="&amp;&amp;/2">
    <strong>left &amp;&amp; right</strong>
  </p>
  <div class="docstring"><p>Provides a short-circuit operator that executes the second
expression only if the first one evalutes to true (i.e. it is
not nil nor false). Returns the first expression otherwise.</p>

<h2>Examples</h2>

<pre><code>true &amp;&amp; true         #=&gt; true
nil &amp;&amp; true          #=&gt; nil
true &amp;&amp; 1            #=&gt; 1
false &amp;&amp; error(:bad) #=&gt; false
</code></pre>

<p>Notice that, differently from Erlang <code>and</code> operator,
this operator accepts any expression as arguments,
not only booleans, however it is not allowed in guards.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2595" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="*/2">
    <strong>left * right</strong>
  </p>
  <div class="docstring"><p>Arithmetic multiplication. Allowed in guard clauses.</p>

<h2>Examples</h2>

<pre><code>1 * 2 #=&gt; 2
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L50" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="+/2">
    <strong>left + right</strong>
  </p>
  <div class="docstring"><p>Arithmetic plus. Allowed in guard clauses.</p>

<h2>Examples</h2>

<pre><code>1 + 2 #=&gt; 3
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L30" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="++/2">
    <strong>left ++ right</strong>
  </p>
  <div class="docstring"><p>Concatenates two lists. Allowed in guard clauses.</p>

<h2>Examples</h2>

<pre><code>[1] ++ [2,3]
#=&gt; [1,2,3]

&#39;foo&#39; ++ &#39;bar&#39;
#=&gt; &#39;foobar&#39;
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L90" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="-/2">
    <strong>left - right</strong>
  </p>
  <div class="docstring"><p>Arithmetic minus. Allowed in guard clauses.</p>

<h2>Examples</h2>

<pre><code>1 - 2 #=&gt; -1
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L40" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="--/2">
    <strong>left -- right</strong>
  </p>
  <div class="docstring"><p>Removes the first occorrence of an item on the left
for each item on the right. Allowed in guard clauses.</p>

<h2>Examples</h2>

<pre><code>[1,2,3] -- [1,2]
#=&gt; [3]

[1,2,3,2,1] -- [1,2,2]
#=&gt; [3,1]
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L105" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="../2">
    <strong>first .. last</strong>
  </p>
  <div class="docstring"><p>Returns a range with the specified start and end.
Includes both ends.</p>

<h2>Examples</h2>

<pre><code>0 in 1..3 #=&gt; false
1 in 1..3 #=&gt; true
2 in 1..3 #=&gt; true
3 in 1..3 #=&gt; true
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2575" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="//2">
    <strong>left / right</strong>
  </p>
  <div class="docstring"><p>Arithmetic division. Differently from other languages,
the result is always a float. Use div and rem if you want
a natural division or the remainder. Allowed in guard clauses.</p>

<h2>Examples</h2>

<pre><code>1 / 2 #=&gt; 0.5
2 / 1 #=&gt; 2.0
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L63" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="/&gt;/2">
    <strong>left /&gt; right</strong>
  </p>
  <div class="docstring"><p><code>/&gt;</code> is called the pipeline operator as it is useful
to write pipeline style expressions. This operator
tntroduces the expression on the left as the first
argument to the expression on the right.</p>

<h2>Examples</h2>

<pre><code>[1,[2],3] /&gt; List.flatten /&gt; Enum.map(&amp;1 * 2)
#=&gt; [2,4,6]
</code></pre>

<p>The expression above is simply translated to:</p>

<pre><code>Enum.map(List.flatten([1,[2],3]), &amp;1 * 2)
</code></pre>

<p>Please be aware of operator precendence, when using
this operator. For example, the following expression:</p>

<pre><code>String.graphemes &quot;Hello&quot; /&gt; Enum.reverse
</code></pre>

<p>Is translated to:</p>

<pre><code>String.graphemes(&quot;Hello&quot; /&gt; Enum.reverse)
</code></pre>

<p>Which will result in an error as Enum.Iterator protocol
is not defined for binaries. Adding explicit parenthesis
is recommended:</p>

<pre><code>String.graphemes(&quot;Hello&quot;) /&gt; Enum.reverse
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2717" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="&lt;/2">
    <strong>left &lt; right</strong>
  </p>
  <div class="docstring"><p>Return true if left is less than right.
As Erlang, Elixir can compare any term. Allowed in guard clauses.</p>

<h2>Examples</h2>

<pre><code>1 &lt; 2
#=&gt; true
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L180" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="&lt;-/2">
    <strong>pid &lt;- msg</strong>
  </p>
  <div class="docstring"><p>Sends a message to the process identified on the left.
A process can be identified bu its PID or, if it is registered,
by an atom.</p>

<h2>Examples</h2>

<pre><code>process = Process.self
process &lt;- { :ok, &quot;Sending myself a message&quot; }
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L76" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="&lt;=/2">
    <strong>left &lt;= right</strong>
  </p>
  <div class="docstring"><p>Return true if left is less than or equal to right.
As Erlang, Elixir can compare any term. Allowed in guard clauses.</p>

<h2>Examples</h2>

<pre><code>1 &lt;= 2
#=&gt; true
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L204" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="&lt;&gt;/2">
    <strong>left &lt;&gt; right</strong>
  </p>
  <div class="docstring"><p>Concatenates two binaries.</p>

<h2>Examples</h2>

<pre><code>&quot;foo&quot; &lt;&gt; &quot;bar&quot; #=&gt; &quot;foobar&quot;
</code></pre>

<p>The <code>&lt;&gt;</code> operator can also be used in guard clauses as
long as the first part is a literal binary:</p>

<pre><code>&quot;foo&quot; &lt;&gt; x = &quot;foobar&quot;
x #=&gt; &quot;bar&quot;
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2558" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="==/2">
    <strong>left == right</strong>
  </p>
  <div class="docstring"><p>Returns true if the two items are equal.</p>

<p>This operator considers 1 and 1.0 to be equal. For strict
comparison, use <code>===</code> instead.</p>

<p>As Erlang, Elixir can compare any term. Allowed in guard clauses.</p>

<h2>Examples</h2>

<pre><code>1 == 2
#=&gt; false

1 == 1.0
#=&gt; true
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L235" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="===/2">
    <strong>left === right</strong>
  </p>
  <div class="docstring"><p>Returns true if the two items are strictly equal.
As Erlang, Elixir can compare any term. Allowed in guard clauses.</p>

<h2>Examples</h2>

<pre><code>1 === 2
#=&gt; false

1 === 1.0
#=&gt; false
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L268" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="=~/2">
    <strong>left =~ right</strong>
  </p>
  <div class="docstring"><p>Matches the term on the left against the regular expression
on the right. It returns nil if not match happened or the
first match otherwise.</p>

<h2>Examples</h2>

<pre><code>&quot;abcd&quot; =~ %r/c(d)/  #=&gt; 2
&quot;abcd&quot; =~ %r/e/     #=&gt; nil
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2680" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="&gt;/2">
    <strong>left &gt; right</strong>
  </p>
  <div class="docstring"><p>Return true if left is more than right.
As Erlang, Elixir can compare any term. Allowed in guard clauses.</p>

<h2>Examples</h2>

<pre><code>1 &gt; 2
#=&gt; false
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L192" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="&gt;=/2">
    <strong>left &gt;= right</strong>
  </p>
  <div class="docstring"><p>Return true if left is more than or equal to right.
As Erlang, Elixir can compare any term. Allowed in guard clauses.</p>

<h2>Examples</h2>

<pre><code>1 &gt;= 2
#=&gt; false
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L216" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="@/1">
    <strong>@expr</strong>
  </p>
  <div class="docstring"><p>This macro is a shortcut to read and add attributes to the module
being compiled. Elixir module attributes are similar to Erlang&#39;s with
some differences. The canonical example for attributes is annotating
that a module implements the OTP behavior called <code>gen_server</code>:</p>

<pre><code>defmodule MyServer do
  @behavior :gen_server
  # ... callbacks ...
end
</code></pre>

<p>Elixir supports by default all Erlang module attributes but any developer
can also add custom attributes:</p>

<pre><code>defmodule MyServer do
  @my_data 13
  IO.inspect @my_data #=&gt; 13
end
</code></pre>

<p>Differently from Erlang, such attributes are not stored in the module by
default since it is common in Elixir to use such attributes to store
temporary data. A developer can configure an attribute to behave closer
to Erlang by calling <code>Module.register_attribute/2</code>.</p>

<p>Finally notice that attributes can also be read inside functions:</p>

<pre><code>defmodule MyServer do
  @my_data 11
  def first_data, do: @my_data
  @my_data 13
  def second_data, do: @my_data
end

MyServer.first_data #=&gt; 11
MyServer.second_data #=&gt; 13
</code></pre>

<p>It is important to note that reading an attribute takes a snapshot of
its current value. In other words, the value is read at compilation
time and not at runtime. Check the module <code>Module</code> for other functions
to manipulate module attributes.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2264" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="__B__/2">
    <strong>__B__(string, list2)</strong>
  </p>
  <div class="docstring"><p>Handles the sigil %B. It simples returns a binary
without escaping characters and without interpolations.</p>

<h2>Examples</h2>

<pre><code>%B(foo)      #=&gt; &quot;foo&quot;
%B(f#{o}o)  #=&gt; &quot;f\#{o}o&quot;
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3024" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="__C__/2">
    <strong>__C__(arg1, list2)</strong>
  </p>
  <div class="docstring"><p>Handles the sigil %C. It simply returns a char list
without escaping characters and without interpolations.</p>

<h2>Examples</h2>

<pre><code>%C(foo)      #=&gt; &#39;foo&#39;
%C(f#{o}o)  #=&gt; &#39;f\#{o}o&#39;
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3052" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="__R__/2">
    <strong>__R__(arg1, options)</strong>
  </p>
  <div class="docstring"><p>Handles the sigil %R. It returns a Regex pattern without escaping
nor interpreting interpolations.</p>

<h2>Examples</h2>

<pre><code>Regex.match? %R(f#{1,3}o), &quot;f#o&quot;  #=&gt; true
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3106" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="__b__/2">
    <strong>__b__(arg1, list2)</strong>
  </p>
  <div class="docstring"><p>Handles the sigil %b. It returns a binary as if it was double quoted
string, unescaping characters and replacing interpolations.</p>

<h2>Examples</h2>

<pre><code>%b(foo)       #=&gt; &quot;foo&quot;
%b(f#{:o}o)  #=&gt; &quot;foo&quot;
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3038" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="__c__/2">
    <strong>__c__(arg1, list2)</strong>
  </p>
  <div class="docstring"><p>Handles the sigil %c. It returns a char list as if it was a single
quoted string, unescaping characters and replacing interpolations.</p>

<h2>Examples</h2>

<pre><code>%c(foo)       #=&gt; &#39;foo&#39;
%c(f#{:o}o)  #=&gt; &#39;foo&#39;
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3069" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="__r__/2">
    <strong>__r__(arg1, options)</strong>
  </p>
  <div class="docstring"><p>Handles the sigil %r. It returns a Regex pattern.</p>

<h2>Examples</h2>

<pre><code>Regex.match? %r(foo), &quot;foo&quot;  #=&gt; true
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L3086" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="access/2">
    <strong>access(element, args)</strong>
  </p>
  <div class="docstring"><p>Access the given element using the qualifier according
to the <code>Access</code> protocol. All calls in the form <code>foo[bar]</code>
are translated to <code>access(foo, bar)</code>.</p>

<p>The usage of this protocol is to access a raw value in a
keyword list.</p>

<pre><code>sample = [a: 1, b: 2, c: 3]
sample[:b] #=&gt; 2
</code></pre>

<h2>Atoms</h2>

<p>Whenever invoked on an atom, the access protocol is expanded
at compilation time rather than on runtime. This feature is used
by records to allow a developer to match against an specific part
of a record:</p>

<pre><code>def increment(State[counter: counter, other: 13] = state) do
  state.counter(counter + 1)
end
</code></pre>

<p>In the example above, we use the Access protocol to match the
counter field in the record <code>State</code>. Considering the record
definition is as follows:</p>

<pre><code>defrecord State, counter: 0, other: nil
</code></pre>

<p>The clause above is translated to:</p>

<pre><code>def increment({ State, counter, 13 } = state) do
  state.counter(counter + 1)
end
</code></pre>

<p>The same pattern can be used to create a new record:</p>

<pre><code>def new_state(counter) do
  State[counter: counter]
end
</code></pre>

<p>The example above is slightly faster than <code>State.new(counter: :counter)</code>
because the record is expanded at compilation time and not at runtime.
If a field is not specified on creation, it will have its default value.</p>

<p>Finally, as in Erlang, Elixir also allows the following syntax:</p>

<pre><code>new_uri = State[_: 1]
</code></pre>

<p>In this case <strong>all</strong> fields will be set to <code>1</code>. Notice that,
as in Erlang, in case an expression is given, it will be
evaluated multiple times:</p>

<pre><code>new_uri = State[_: IO.puts &quot;Hello&quot;]
</code></pre>

<p>In this case, <code>&quot;Hello&quot;</code> will be printed twice (one per each field).</p>

<h2>Examples</h2>

<pre><code>a = { :a, :b, :c }
a[1] #=&gt; :a
access a, 1 #=&gt; :a
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2897" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="and/2">
    <strong>left and right</strong>
  </p>
  <div class="docstring"><p>Boolean and. Arguments needs to necessarily be booleans.
Allowed in guard clauses.</p>

<h2>Examples</h2>

<pre><code>true and false
#=&gt; false
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L129" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="atom_to_binary/1">
    <strong>atom_to_binary(some_atom)</strong>
  </p>
  <div class="docstring"><p>Returns a binary which corresponds to the text representation
of <code>some_atom</code> in UTF8 encoding.</p>

<h2>Examples</h2>

<pre><code>atom_to_binary :my_atom #=&gt; &quot;my_atom&quot;
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2538" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="binary_to_atom/1">
    <strong>binary_to_atom(some_binary)</strong>
  </p>
  <div class="docstring"><p>Returns the atom whose text representation is
<code>some_binary</code> in UTF8 encoding.</p>

<h2>Examples</h2>

<pre><code>binary_to_atom &quot;my_atom&quot; #=&gt; :my_atom
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2508" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="binary_to_existing_atom/1">
    <strong>binary_to_existing_atom(some_binary)</strong>
  </p>
  <div class="docstring"><p>Works like <code>binary_to_atom</code> but the atom must exist.</p>

<h2>Examples</h2>

<pre><code>:my_atom                          #=&gt; :my_atom
binary_to_existing_atom &quot;my_atom&quot; #=&gt; :my_atom
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2523" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="binary_to_float/1">
    <strong>binary_to_float(some_binary)</strong>
  </p>
  <div class="docstring"><p>Returns a float whose text representation is <code>some_binary</code>.</p>

<h2>Examples</h2>

<pre><code>binary_to_float &quot;2.2017764e+0&quot; #=&gt; 2.2017764
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2448" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="binary_to_integer/1">
    <strong>binary_to_integer(some_binary)</strong>
  </p>
  <div class="docstring"><p>Returns a integer whose text representation is <code>some_binary</code>.</p>

<h2>Examples</h2>

<pre><code>binary_to_integer &quot;123&quot; #=&gt; 123
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2419" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="binary_to_integer/2">
    <strong>binary_to_integer(some_binary, base)</strong>
  </p>
  <div class="docstring"><p>Returns an integer whose text representation in base <code>base</code>
is <code>some_binary</code>.</p>

<h2>Examples</h2>

<pre><code>binary_to_integer(&quot;3FF&quot;, 16) #=&gt; 1023
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2434" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="case/2">
    <strong>case(condition, blocks)</strong>
  </p>
  <div class="docstring"><p>Matches the given condition against the match clauses.</p>

<h2>Examples</h2>

<pre><code>case thing do
  { :selector, i, value } when is_integer(i) -&gt;
    value
  value -&gt; value
end
</code></pre>

<p>In the example above, we compare <code>thing</code> with each given
match clause and execute the first one that matches. If no
clause matches, an error is raised.</p>

<p>Since Elixir variables can be assigned more than once, variables
in a match clause will always be assigned instead of matching with
its previous values. For example:</p>

<pre><code>i = 1
case 10 do
  i -&gt; i * 2
end
</code></pre>

<p>The example above will return 20, because <code>i</code> is assigned to 10
and then multiplied by 2. If you desire to match the value of <code>i</code>
against the given condition, you need to use the <code>^</code> operator:</p>

<pre><code>i = 1
case 10 do
  ^i -&gt; i * 2
end
</code></pre>

<p>The example above will actually fail because 10 does not match 1.</p>

<p>Finally, <code>case</code> accepts an <code>else:</code> branch as a fallback if none
of the clauses match:</p>

<pre><code>case thing do
  { :selector, i, value } when is_integer(i) -&gt;
    value
  _ -&gt;
    thing
end
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2067" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="cond/1">
    <strong>cond(list1)</strong>
  </p>
  <div class="docstring"><p>Execute the first clause where the condition returns true,
raises an error otherwise.</p>

<h2>Examples</h2>

<pre><code>cond do
  1 + 1 == 2 -&gt;
    &quot;This will never match&quot;
  2 * 2 != 4 -&gt;
    &quot;Nor this&quot;
  true -&gt;
    &quot;This will&quot;
end
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2330" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="def/2">
    <strong>def(name, list2)</strong>
  </p>
  <div class="docstring"><p>Defines a function with the given name and contents.</p>

<h2>Examples</h2>

<pre><code>defmodule Foo do
  def bar, do: :baz
end

Foo.bar #=&gt; :baz
</code></pre>

<p>A function that expects arguments can be defined as follow:</p>

<pre><code>defmodule Foo do
  def sum(a, b) do
    a + b
  end
end
</code></pre>

<p>In the example above, we defined a function <code>sum</code> that receives
two arguments and sum them.</p>

<h2>Dynamic generation with atoms</h2>

<p>Elixir follows the same rule as Erlang when it comes to
function invocations. Calling a function is the same thing
as &quot;invoking at atom&quot;. That said, we could invoke a function
named sum in these two equivalent ways:</p>

<pre><code>sum(1, 2)
:sum.(1, 2)
</code></pre>

<p>We can also use the atom format to define functions:</p>

<pre><code>defmodule Foo do
  def :sum.(a, b) do
    a + b
  end
end
</code></pre>

<p>In general, a developer never needs to use the format above
except when he wants to dynamically define functions with macros.
In such scenarios, the name needs to be given dynamically via
the unquoting mechanism.</p>

<p>Imagine a macro that receives keywords and defines a function
for each entry in the keyword, using the key as function name
and the value as the value returned by the function:</p>

<pre><code>defmacro defkv(keywords) do
  Enum.map keywords, fn {k,v} -&gt;
    quote do
      def unquote(k).() do
        unquote(v)
      end
    end
  end
end
</code></pre>

<p>This macro could be invoked as:</p>

<pre><code>defkv one: 1, two: 2
</code></pre>

<p>Notice in the example above, we define the function as <code>def unquote(k).()</code>
because each entry <code>k</code> is a an atom and invoking <code>def unquote(k)()</code>
would be invalid Elixir syntax.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1285" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="def/4">
    <strong>def(name, args, guards, list4)</strong>
  </p>
  <div class="docstring"><p>This macro allows a function to be defined more explicitly
by accepting the name, args and guards as different entries.</p>

<p>Differently from <code>def/2</code>, the macro arguments are evaluated
and therefore requires quoting.</p>

<p>The <code>name</code> must be an atom, the <code>arguments</code> a list where each
element represents another argument and <code>guards</code> a list of
clauses, where each clause is disjunct.</p>

<h2>Examples</h2>

<p>The most common mistake when using this macro is to pass the
arguments without quoting:</p>

<pre><code>def :some_function, [first_arg, second_arg], is_list(first_arg) do
  # ...
end
</code></pre>

<p>However, the example above will fail because it will attempt to
evaluate <code>[first_arg, second_arg]</code> and fail because the variable
<code>first_arg</code> is not defined. Therefore, we need to use quote:</p>

<pre><code>name   = :some_function
args   = quote(do: [first_arg, second_arg])
guards = quote(do: is_list(first_arg))
exprs  = quote(do: ...)

def name, args, guards, do: exprs
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1319" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="defdelegate/2">
    <strong>defdelegate(funs, opts)</strong>
  </p>
  <div class="docstring"><p>Defines the given functions in the current module that will
delegate to the given <code>target</code>. Functions defined with
<code>defdelegate</code> are public and are allowed to be invoked
from external. If you find yourself wishing to define a
delegation as private, you should likely use import
instead.</p>

<p>Delegation only works with functions, delegating to macros
is not supported.</p>

<h2>Options</h2>

<ul>
<li><p><code>:to</code> - The expression to delegate to. Any expression
is allowed and its results will be calculated on runtime;</p></li>
<li><p><code>:as</code> - The function to call on the target given in <code>:to</code>.
This parameter is optional and defaults to the name being
delegated.</p></li>
<li><p><code>:append_first</code> - If true, when delegated, first argument
passed to the delegate will be relocated to the end of the
arguments when dispatched to the target. The motivation behind
this is a disparity between conventions used in Elixir and :
Elixir&#39;s convention is to pass the &quot;handle&quot; as a first argument,
while in Erlang the convention is to pass it as the last argument</p></li>
</ul>

<h2>Examples</h2>

<pre><code>defmodule MyList do
  defdelegate reverse(list), to: :lists
  defdelegate [reverse(list), map(callback, list)], to: :lists
  defdelegate other_reverse(list), to: :lists, as: :reverse
end

MyList.reverse([1,2,3])
#=&gt; [3,2,1]

MyList.other_reverse([1,2,3])
#=&gt; [3,2,1]
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2978" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="defexception/4">
    <strong>defexception(name, fields, opts // [], do_block // [])</strong>
  </p>
  <div class="docstring"><p>Defines an exception.</p>

<p>Exceptions are simply records and therefore <code>defexception/4</code> has
the same API and similar behavior to <code>defrecord/4</code> with two notable
differences:</p>

<p>1) Differently from records, exceptions are documented by default;</p>

<p>2) Exceptions <strong>must</strong> implement <code>message/1</code> as API that return a
   binary as result;</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1505" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="defimpl/3">
    <strong>defimpl(name, opts, do_block // [])</strong>
  </p>
  <div class="docstring"><p>Defines an implementation for the given protocol. See
<code>defprotocol/2</code> for examples.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1717" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="defmodule/2">
    <strong>defmodule(name, list2)</strong>
  </p>
  <div class="docstring"><p>Defines a module given by name with the given contents.</p>

<p>It returns the module name, the module binary and the
block contents result.</p>

<h2>Examples</h2>

<pre><code>defmodule Foo do
  def bar, do: :baz
end

Foo.bar #=&gt; :baz
</code></pre>

<h2>Nesting</h2>

<p>Nesting a module inside the other affects its name:</p>

<pre><code>defmodule Foo do
  defmodule Bar do
  end
end
</code></pre>

<p>In the example above, two modules <code>Foo</code> and <code>Foo.Bar</code>. The
second can be accessed as <code>Bar</code> inside <code>Foo</code> in the same
lexical scope. If the module Bar is moved away to another
file, it needs to be referenced via the full name or an
alias need to be set with the help of <code>Kernel.SpecialForms.alias/2</code>.</p>

<h2>Dynamic names</h2>

<p>Elixir module names can be dynamically generated. This is very
useful for macros. For instance, one could write:</p>

<pre><code>defmodule binary_to_atom(&quot;Foo#{1}&quot;, :utf8) do
  # contents ...
end
</code></pre>

<p>Elixir will accept any module name as long as the expression
returns an atom.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1216" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="defoverridable/1">
    <strong>defoverridable(tuples)</strong>
  </p>
  <div class="docstring"><p>Makes the given functions in the current module overridable.
An overridable function is lazily defined, allowing a
developer to customize it.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1726" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="defp/2">
    <strong>defp(name, list2)</strong>
  </p>
  <div class="docstring"><p>Defines a function that is private. Private functions
can only be accessible from the same module it is defined.</p>

<p>Check <code>def/2</code> for more information</p>

<h2>Examples</h2>

<pre><code>defmodule Foo do
  def bar do
    sum(1, 2)
  end

  defp sum(a, b), do: a + b
end
</code></pre>

<p>In the example above, <code>sum</code> is private and accessing it
through <code>Foo.sum</code> will raise an error.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1340" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="defp/4">
    <strong>defp(name, args, guards, list4)</strong>
  </p>
  <div class="docstring"><p>The same as <code>def/4</code> but generates a private function.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1345" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="defprotocol/2">
    <strong>defprotocol(name, list2)</strong>
  </p>
  <div class="docstring"><p>Defines the current module as a protocol and specifies the API
that should be implemented.</p>

<h2>Examples</h2>

<p>In Elixir, only <code>false</code> and <code>nil</code> are considered falsy values.
Everything else evaluates to true in <code>if</code> clauses. Depending
on the application, it may be important to specify a <code>blank?</code>
protocol that returns a boolean for other data types that should
be considered <code>blank?</code>. For instance, an empty list or an empty
binary could be considered blanks.</p>

<p>We could implement this protocol as follow:</p>

<pre><code>defprotocol Blank do
  @doc &quot;Returns true if data is considered blank/empty&quot;
  def blank?(data)
end
</code></pre>

<p>Now that the protocol is defined, we can implement it. We need
to implement the protocol for each Elixir type. For example:</p>

<pre><code># Numbers are never blank
defimpl Blank, for: Number do
  def blank?(number), do: false
end

# Just empty list is blank
defimpl Blank, for: List do
  def blank?([]), do: true
  def blank?(_),  do: false
end

# Just the atoms false and nil are blank
defimpl Blank, for: Atom do
  def blank?(false), do: true
  def blank?(nil),   do: true
  def blank?(_),     do: false
end
</code></pre>

<p>And we would have to define the implementation for all types.
The types available are:</p>

<ul>
<li>Record</li>
<li>Tuple</li>
<li>Atom</li>
<li>List</li>
<li>BitString</li>
<li>Number</li>
<li>Function</li>
<li>PID</li>
<li>Port</li>
<li>Reference</li>
<li>Any</li>
</ul>

<h2>Selecting implementations</h2>

<p>Implementing the protocol for all default types can be cumbersome.
Even more, if you consider that Number, Function, PID, Port and
Reference are never going to be blank, it would be easier if we
could simply provide a default implementation.</p>

<p>This can be achieved in Elixir as follows:</p>

<pre><code>defprotocol Blank do
  @only [Atom, Tuple, List, BitString, Any]
  def blank?(data)
end
</code></pre>

<p>If the protocol is invoked with a data type that is not an Atom,
nor Tuple, nor List, nor BitString, Elixir will now dispatch to
Any. That said, the default behavior could be implemented as:</p>

<pre><code>defimpl Blank, for: Any do
  def blank?(_), do: false
end
</code></pre>

<p>Now, all data types that we have not specified will be
automatically considered non blank.</p>

<h2>Protocols + Records</h2>

<p>The real benefit of protocols comes when mixed with records. For instance,
imagine we have a module called <code>RedBlack</code> that provides an API to create
and manipulate Red-Black trees. This module represents such trees via a
record named <code>RedBlack.Tree</code> and we want this tree to be considered blank
in case it has no items. To achieve this, the developer just needs to
implement the protocol for <code>RedBlack.Tree</code>:</p>

<pre><code>defimpl Blank, for: RedBlack.Tree do
  def blank?(tree), do: RedBlack.empty?(tree)
end
</code></pre>

<p>In the example above, we have implemented <code>blank?</code> for <code>RedBlack.Tree</code>
that simply delegates to <code>RedBlack.empty?</code> passing the tree as argument.
This implementation doesn&#39;t need to be defined inside the <code>RedBlack</code>
tree or inside the record, but anywhere in the code.</p>

<p>Finally, since records are simply tuples, one can add a default protocol
implementation to any record by defining a default implementation for tuples.</p>

<h2>Types</h2>

<p>As in records, defining a protocol automatically defines a type named <code>t</code>,
which can be used as:</p>

<pre><code>@spec present?(Blank.t) :: boolean
def present?(blank) do
  not Blank.blank?(blank)
end
</code></pre>

<p>The <code>@spec</code> above expresses that all types allowed to implement the
given protocol are valid argument types for the given function.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1709" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="defrecord/4">
    <strong>defrecord(name, fields, opts // [], do_block // [])</strong>
  </p>
  <div class="docstring"><p>Defines a record.</p>

<p>A record is a tagged tuple which contains one or more elements
and the first element is a module. This macro defines a module
that generates accessors to manipulate the record at both
compilation and runtime.</p>

<h2>Examples</h2>

<pre><code>defrecord FileInfo, atime: nil, accesses: 0
</code></pre>

<p>The line above will define a module named <code>FileInfo</code> which
contains a function named <code>new</code> that returns a new record
and other functions to read and set the values in the
record:</p>

<pre><code>file_info = FileInfo.new(atime: now())
file_info.atime         #=&gt; Returns the value of atime
file_info.atime(now())  #=&gt; Updates the value of atime
</code></pre>

<p>A record is simply a tuple where the first element is the record
module name. We can get the record raw representation as follow:</p>

<pre><code>inspect FileInfo.new, raw: true
#=&gt; { FileInfo, nil, nil }
</code></pre>

<p>Besides defining readers and writers for each attribute, Elixir also
defines an <code>update_#{attribute}</code> function to update the value. Such
functions expect a function as argument that receives the current
value and must return the new one. For example, every time the file
is accessed, the accesses counter can be incremented with:</p>

<pre><code>file_info.update_accesses(fn(old) -&gt; old + 1 end)
</code></pre>

<p>Which can be also written as:</p>

<pre><code>file_info.update_accesses(&amp;1 + 1)
</code></pre>

<h2>Access syntax</h2>

<p>Records in Elixir can be expanded at compilation time to provide
pattern matching and faster operations. For example, the clause
below will only match if a <code>FileInfo</code> is given and the number of
accesses is zero:</p>

<pre><code>def enforce_no_access(FileInfo[accesses: 0]), do: :ok
</code></pre>

<p>The clause above will expand to:</p>

<pre><code>def enforce_no_access({ FileInfo, _, 0 }), do: :ok
</code></pre>

<p>The downside of using such syntax is that, every time the record
changes, your code now needs to be recompiled (which is usually
not a concern since Elixir build tools by default recompiles the
whole project whenever there is a change).</p>

<p>Finally, keep in mind that Elixir triggers some optimizations whenever
the access syntax is used. For example:</p>

<pre><code>def no_access?(FileInfo[] = file_info) do
  file_info.accesses == 0
end
</code></pre>

<p>Is translated to:</p>

<pre><code>def no_access?({ FileInfo, _, _ } = file_info) do
  elem(file_info, 1) == 0
end
</code></pre>

<p>Which provides faster get and set times for record operations.</p>

<h2>Documentation</h2>

<p>By default records are not documented and have <code>@moduledoc</code> set to false.</p>

<h2>Types</h2>

<p>Every record defines a type named <code>t</code> that can be accessed in typespecs.
For example, assuming the <code>Config</code> record defined above, it could be used
in typespecs as follow:</p>

<pre><code>@spec handle_config(Config.t) :: boolean()
</code></pre>

<p>Inside the record definition, a developer can define his own types too:</p>

<pre><code>defrecord Config, counter: 0, failures: [] do
  @type kind :: term
  record_type counter: integer, failures: [kind]
end
</code></pre>

<p>When defining a type, all the fields not mentioned in the type are
assumed to have type <code>term</code>.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1441" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="defrecordp/2">
    <strong>defrecordp(name, fields)</strong>
  </p>
  <div class="docstring"><p>Defines a record with a set of private macros to manipulate it.</p>

<p>A record is a tagged tuple which contains one or more elements
and the first element is a module. This macro defines a set of
macros private to the current module to manipulate the record
exclusively at compilation time.</p>

<p><code>defrecordp</code> must be used instead of <code>defrecord</code> when there is
no interest in exposing the record as a whole. In many ways,
it is similar to Erlang records, since it is only available at
compilation time.</p>

<h2>Examples</h2>

<pre><code>defmodule User do
  defrecordp :user, [name: &quot;José&quot;, age: &quot;25&quot;]
end
</code></pre>

<p>In the example above, a set of macros named <code>user</code> but with different
arities will be defined to manipulate the underlying record:</p>

<pre><code># To create records
user()        #=&gt; { User, &quot;José&quot;, 25 }
user(age: 26) #=&gt; { User, &quot;José&quot;, 26 }

# To get a field from the record
user(record, :name) #=&gt; &quot;José&quot;

# To get many fields from the record
user(record, [:name, :age]) #=&gt; [&quot;José&quot;, 25]

# To update the record
user(record, age: 26) #=&gt; { User, &quot;José&quot;, 26 }

# To convert the record to keywords
user(record) #=&gt; [name: &quot;José&quot;, age: 25]

# To match against the record
user(name: name) = record
name #=&gt; &quot;José&quot;
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1488" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="destructure/2">
    <strong>destructure(left, right)</strong>
  </p>
  <div class="docstring"><p>Allows you to destructure two lists, assigning each
term in the right to the left. Differently from pattern
matching via <code>=</code>, if the sizes of the left and right
lists don&#39;t match,, structuring simply stops instead
of raising an error.</p>

<h2>Examples</h2>

<pre><code>destructure [x,y,z], [1,2,3,4,5]
x #=&gt; 1
y #=&gt; 2
z #=&gt; 3
</code></pre>

<p>Notice in the example above, even though the right
size has more entries than the left, structuring works
fine. If the right size is smaller, the remaining items
are simply assigned to nil:</p>

<pre><code>destructure [x,y,z], [1]
x #=&gt; 1
y #=&gt; nil
z #=&gt; nil
</code></pre>

<p>The left side supports any expression you would use
on the left side of a match:</p>

<pre><code>x = 1
destructure [^x,y,z], [1,2,3]
</code></pre>

<p>The example above will only work if x matches
the first value from the right side. Otherwise,
it will raise a CaseClauseError.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2398" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="div/2">
    <strong>div(left, right)</strong>
  </p>
  <div class="docstring"><p>Provides an integer division macro according to Erlang semantics.
Raises an error if one of the arguments is not an integer.
Can be used in guard tests.</p>

<h2>Examples</h2>

<pre><code>div 5, 2 #=&gt; 2
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1879" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="elem/2">
    <strong>elem(tuple, index)</strong>
  </p>
  <div class="docstring"><p>Define elem to get Tuple element according to Elixir conventions
(i.e. it expects the tuple as first argument, zero-index based).</p>

<p>It is implemented as a macro so it can be used in guards.</p>

<h2>Example</h2>

<pre><code>tuple = { :foo, :bar, 3 }
elem(tuple, 1) #=&gt; :bar
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1841" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="float_to_binary/1">
    <strong>float_to_binary(some_float)</strong>
  </p>
  <div class="docstring"><p>Returns a binary which corresponds to the text representation
of <code>some_float</code>.</p>

<h2>Examples</h2>

<pre><code>float_to_binary 7.0 #=&gt; &quot;7.00000000000000000000e+00&quot;
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2493" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="function/1">
    <strong>function(args)</strong>
  </p>
  <div class="docstring"><p>Returns an anonymous function based on the given arguments.</p>

<h2>Examples</h2>

<pre><code>sum = function do
  (x, y) -&gt; x + y
end

sum.(1, 2) #=&gt; 3
</code></pre>

<p>Notice that a function needs to be invoked using the dot between
the function and the arguments.</p>

<p>Multiple clauses can be specified as in <code>case</code>, <code>receive</code> and
similar macros:</p>

<pre><code>sum = function do
  x, y when y &gt; 0 -&gt; x + y
  x, y -&gt; x - y
end

sum.(1, 2) #=&gt; 3
</code></pre>

<h2>Shortcut syntax</h2>

<p>In order to reduce verbosity, functions in Elixir can be written
using a shortcut syntax via <code>fn</code>:</p>

<pre><code>Enum.map [1,2,3], fn x -&gt;
  x * 2
end
</code></pre>

<p>Not only the example is shorter, it solves ambiguity issues. Since
<code>do/end</code> always matches the furthest call, if we used the <code>function</code>
macro as below:</p>

<pre><code>Enum.map [1,2,3], function do
  x -&gt; x * 2
end
</code></pre>

<p>It would be parsed as:</p>

<pre><code>Enum.map([1,2,3], function) do
  x -&gt; x * 2
end
</code></pre>

<p>The stab shortcut syntax has the proper precedence:</p>

<pre><code>Enum.map [1,2,3], fn
  x -&gt; x * 2
end
</code></pre>

<p>Which is handled as:</p>

<pre><code>Enum.map([1,2,3], fn
  x -&gt; x * 2
end)
</code></pre>

<h2>Function retrieval</h2>

<p>The <code>function</code> macro can also be used to retrieve local or remote
functions:</p>

<pre><code>f = function(:is_atom, 2)
f.(:foo) #=&gt; true

f = function(List, :flatten, 1)
f.([1,[2],3]) #=&gt; [1,2,3]
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2019" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="if/2">
    <strong>if(condition, clauses)</strong>
  </p>
  <div class="docstring"><p>Provides an <code>if</code> macro. This macro expects the first argument to
be a condition and the rest are keyword arguments.</p>

<h2>One-liner examples</h2>

<pre><code>if(foo, do: bar)
</code></pre>

<p>In the example above, bar will be returned if foo evalutes to
true (i.e. it is not false nor nil). Otherwise, nil will be returned.</p>

<p>An else option can be given to specify the opposite:</p>

<pre><code>if(foo, do: bar, else: bar)
</code></pre>

<h2>Blocks examples</h2>

<p>Elixir also allows you to pass a block to the if macro. The first
example above would be translated to:</p>

<pre><code>if foo do
  bar
end
</code></pre>

<p>Notice that do/end becomes delimiters. The second example would
then translate do:</p>

<pre><code>if foo do
  bar
else
  baz
end
</code></pre>

<p>If you want to compare more than two clauses, you can use the <code>cond/1</code>
macro.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2302" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="in/2">
    <strong>left in right</strong>
  </p>
  <div class="docstring"><p>Returns true if the element on the left is equal (==) to
any of the items in the right. For now, it only accepts
a list as the right argument.</p>

<h2>Examples</h2>

<pre><code>x = 1
x in [1,2,3] #=&gt; true
</code></pre>

<p>This macro simply translates the expression above to:</p>

<pre><code>x == 1 or x == 2 or x == 3
</code></pre>

<h2>Clauses</h2>

<p>Whenever used inside a function or a case clause, you can
optionally omit the variable declaration, for example:</p>

<pre><code>case 3 do
  x when x in [1,2] -&gt; x * 2
  _ -&gt; 0
end
</code></pre>

<p>Could be rewritten as:</p>

<pre><code>case 3 do
  x in [1,2] -&gt; x * 2
  _ -&gt; 0
end
</code></pre>

<p>In this case, Elixir will automatically expand it and define
the variable for us.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2667" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="inspect/2">
    <strong>inspect(arg, opts // [])</strong>
  </p>
  <div class="docstring"><p>Inspect the given arguments according to the Binary.Inspect protocol.</p>

<h2>Options</h2>

<p>The following options are supported:</p>

<ul>
<li><p>:raw - tuples are not formatted as the inspect protocol, they are
always shown as tuples, defaults to false;</p></li>
<li><p>:limit - the limit of items that are shown in tuples, bitstrings and
lists. Do not apply to strings;</p></li>
</ul>

<h2>Examples</h2>

<pre><code>inspect(:foo)
#=&gt; &quot;:foo&quot;
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1798" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="integer_to_binary/1">
    <strong>integer_to_binary(some_integer)</strong>
  </p>
  <div class="docstring"><p>Returns a binary which corresponds to the text representation
of <code>some_integer</code>.</p>

<h2>Examples</h2>

<pre><code>integer_to_binary 123 #=&gt; &quot;123&quot;
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2463" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="integer_to_binary/2">
    <strong>integer_to_binary(some_integer, base)</strong>
  </p>
  <div class="docstring"><p>Returns a binary which corresponds to the text representation
of <code>some_integer</code> in base <code>base</code>.</p>

<h2>Examples</h2>

<pre><code>integer_to_binary 77 #=&gt; &quot;77&quot;
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2478" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="is_exception/1">
    <strong>is_exception(thing)</strong>
  </p>
  <div class="docstring"><p>Check if the given structure is an exception.</p>

<h2>Examples</h2>

<pre><code>is_exception(Error.new) #=&gt; true
is_exception(1)         #=&gt; false
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1533" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="is_range/1">
    <strong>is_range(thing)</strong>
  </p>
  <div class="docstring"><p>Check if the given argument is a range.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1588" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="is_record/2">
    <strong>is_record(thing, kind)</strong>
  </p>
  <div class="docstring"><p>Check if the given structure is a record. It is basically
a convenient macro that checks the structure is a tuple and
the first element matches the given kind.</p>

<h2>Examples</h2>

<pre><code>defrecord Config, sample: nil

is_record(Config.new, Config) #=&gt; true
is_record(Config.new, List)   #=&gt; false
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1562" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="is_regex/1">
    <strong>is_regex(thing)</strong>
  </p>
  <div class="docstring"><p>Check if the given argument is a regex.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1579" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="match?/2">
    <strong>match?(left, right)</strong>
  </p>
  <div class="docstring"><p>A convenient macro that checks if the right side matches
the left side. The left side is allowed to be a match pattern.</p>

<h2>Examples</h2>

<pre><code>match?(1, 1) #=&gt; true
match?(1, 2) #=&gt; false
match?({1,_}, {1,2}) #=&gt; true
</code></pre>

<p>Match can also be used to filter or find a value in an enumerable:</p>

<pre><code>list = [{:a,1},{:b,2},{:a,3}]
Enum.filter list, match?({:a, _}, _)
</code></pre>

<p>Guard clauses can also be given to the match:</p>

<pre><code>list = [{:a,1},{:b,2},{:a,3}]
Enum.filter list, match?({:a, x } when x &lt; 2, &amp;1)
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1932" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="nil?/1">
    <strong>nil?(x)</strong>
  </p>
  <div class="docstring"><p>Checks if the given argument is nil or not.
Allowed in guard clauses.</p>

<h2>Examples</h2>

<pre><code>nil? 1    #=&gt; false
nil? nil  #=&gt; true
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1907" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="not/1">
    <strong>not arg</strong>
  </p>
  <div class="docstring"><p>Boolean not. Argument needs to necessarily be a boolean.
Allowed in guard clauses.</p>

<h2>Examples</h2>

<pre><code>not false
#=&gt; true
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L153" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="or/2">
    <strong>left or right</strong>
  </p>
  <div class="docstring"><p>Boolean or. Arguments needs to necessarily be booleans.
Allowed in guard clauses.</p>

<h2>Examples</h2>

<pre><code>true or false
#=&gt; true
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L117" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="receive/1">
    <strong>receive(args)</strong>
  </p>
  <div class="docstring"><p>The current process will hang until it receives a message
from other processes that matches the given clauses.</p>

<h2>Examples</h2>

<pre><code>receive do
  { :selector, i, value } when is_integer(i) -&gt;
    value
  value when is_atom(value) -&gt;
    value
  _ -&gt;
    IO.puts :stderr, &quot;Unexpected message received&quot;
end
</code></pre>

<p>The match clauses above follows the same rules as <code>case/2</code>.</p>

<p>An optional after clause can be given in case the message was not
received after the specified period of time:</p>

<pre><code>receive do
  { :selector, i, value } when is_integer(i) -&gt;
    value
  value when is_atom(value) -&gt;
    value
  _ -&gt;
    IO.puts :stderr, &quot;Unexpected message received&quot;
after
  5000 -&gt;
    IO.puts :stderr, &quot;No message in 5 seconds&quot;
end
</code></pre>

<p>The <code>after</code> clause can be specified even if there are no match clauses.
There are two special cases for the timout value given to after</p>

<ul>
<li><p><code>:infinity</code> - The process should wait indefinitely for a matching
message, this is the same as not using a timeout.</p></li>
<li><p>0 - if there is no matching message in the mailbox, the timeout
will occur immediately.</p></li>
</ul>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2221" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="rem/2">
    <strong>rem(left, right)</strong>
  </p>
  <div class="docstring"><p>Provides an integer remainder macro according to Erlang semantics.
Raises an error if one of the arguments is not an integer.
Can be used in guard tests.</p>

<h2>Examples</h2>

<pre><code>rem 5, 2 #=&gt; 1
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1893" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="setelem/3">
    <strong>setelem(tuple, index, value)</strong>
  </p>
  <div class="docstring"><p>Define setelem to set Tuple element according to Elixir conventions
(i.e. it expects the tuple as first argument, zero-index based).</p>

<p>It is implemented as a macro so it can be used in guards.</p>

<h2>Example</h2>

<pre><code>tuple = { :foo, :bar, 3 }
setelem(tuple, 0, :baz) #=&gt; { :baz, :bar, 3 }
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1861" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="to_binary/1">
    <strong>to_binary(arg)</strong>
  </p>
  <div class="docstring"><p>Convert the argument to a string according to the Binary.Chars protocol.
This is the function invoked when there is string interpolation.</p>

<h2>Examples</h2>

<pre><code>to_binary(:foo)
#=&gt; &quot;foo&quot;
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1812" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="to_char_list/1">
    <strong>to_char_list(arg)</strong>
  </p>
  <div class="docstring"><p>Convert the argument to a list according to the List.Chars protocol.</p>

<h2>Examples</h2>

<pre><code>to_char_list(:foo)
#=&gt; &#39;foo&#39;
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1825" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="try/1">
    <strong>try(args)</strong>
  </p>
  <div class="docstring"><p>Execute the given expressions and catch any error, exit
or throw that may have happened.</p>

<h2>Examples</h2>

<pre><code>try do
  do_something_that_may_fail(some_arg)
rescue
  ArgumentError -&gt;
    IO.puts &quot;Invalid argument given&quot;
catch
  value -&gt;
    IO.puts &quot;caught #{value}&quot;
after
  IO.puts &quot;This is printed regardless if it failed or succeed&quot;
end
</code></pre>

<p>The rescue clause is used to handle exceptions, while the catch
clause can be used to catch thrown values. Both catch and rescue
clauses work based on pattern matching.</p>

<p>Note that calls inside <code>try</code> are not tail recursive since the VM
needs to keep the stacktrace in case an exception happens.</p>

<h2>Rescue clauses</h2>

<p>Besides relying on pattern matching, rescue clauses provides some
conveniences around exceptions that allows one to rescue an
exception by its name. All the following formats are valid rescue
expressions:</p>

<pre><code>try do
  UndefinedModule.undefined_function
rescue
  UndefinedFunctionError -&gt; nil
end

try do
  UndefinedModule.undefined_function
rescue
  [UndefinedFunctionError] -&gt; nil
end

# rescue and assign to x
try do
  UndefinedModule.undefined_function
rescue
  x in [UndefinedFunctionError] -&gt; nil
end

# rescue all and assign to x
try do
  UndefinedModule.undefined_function
rescue
  x -&gt; nil
end
</code></pre>

<h2>Catching exits and Erlang errors</h2>

<p>The catch clause works exactly the same as in erlang. Therefore,
one can also handle exits/errors coming from Erlang as below:</p>

<pre><code>try do
  exit(1)
catch
  :exit, 1 -&gt; IO.puts &quot;Exited with 1&quot;
end

try do
  error(:sample)
catch
  :error, :sample -&gt;
    IO.puts &quot;sample error&quot;
end
</code></pre>

<p>Although the second form should be avoided in favor of raise/rescue
control mechanisms.</p>

<h2>Variable visibility</h2>

<p>Since an expression inside <code>try</code> may not have been evaluted
due to an exception, any variable created inside <code>try</code> cannot
be accessed externaly. For instance:</p>

<pre><code>try do
  x = 1
  do_something_that_may_fail(same_arg)
  :ok
catch
  _, _ -&gt; :failed
end

x #=&gt; Cannot access `x`
</code></pre>

<p>In the example above, <code>x</code> cannot be accessed since it was defined
inside the <code>try</code> clause. A common practice to address this issue
is to return the variables defined inside <code>try</code>:</p>

<pre><code>x =
  try do
    x = 1
    do_something_that_may_fail(same_arg)
    x
  catch
    _, _ -&gt; :failed
  end
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2178" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="unless/2">
    <strong>unless(clause, options)</strong>
  </p>
  <div class="docstring"><p>Provides a unless macro that executes the expression
unless a value evalutes to true. Check <code>if</code> for examples
and documentation.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2356" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="use/2">
    <strong>use(module, args // [])</strong>
  </p>
  <div class="docstring"><p><code>use</code> is a simple mechanism for using a given module into
the current context.</p>

<h2>Examples</h2>

<p>For example, in other to write tests using the ExUnit framework,
a developers should use the <code>ExUnit.Case</code> module:</p>

<pre><code>defmodule AssertionTest do
  use ExUnit.Case, async: true

  def test_always_pass do
    true = true
  end
end
</code></pre>

<p>By calling <code>use</code>, a hook called <code>__using__</code> will be invoked in
<code>ExUnit.Case</code> which will then do the proper setup.</p>

<p>Simply put, <code>use</code> is simply a translation to:</p>

<pre><code>defmodule AssertionTest do
  require ExUnit.Case
  ExUnit.Case.__using__([sync: true])

  def test_always_pass do
    true = true
  end
end
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L1764" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="var!/1">
    <strong>var!(var)</strong>
  </p>
  <div class="docstring"><p>When used inside quoting, marks that the variable should not
be hygienezed. Check <code>Kernel.SpecialForms.quote/1</code> for more
information.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L290" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="xor/2">
    <strong>left xor right</strong>
  </p>
  <div class="docstring"><p>Boolean xor. Arguments needs to necessarily be booleans.
Allowed in guard clauses.</p>

<h2>Examples</h2>

<pre><code>true xor false
#=&gt; true
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L141" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="||/2">
    <strong>left || right</strong>
  </p>
  <div class="docstring"><p>Provides a short-circuit operator that executes the second
expression only if the first one does not evalute to true (i.e. it
is not nil nor false). Returns the first expression otherwise.</p>

<h2>Examples</h2>

<pre><code>false || false       #=&gt; false
nil || true          #=&gt; true
false || 1           #=&gt; 1
true || error(:bad)  #=&gt; true
</code></pre>

<p>Notice that, differently from Erlang <code>or</code> operator,
this operator accepts any expression as arguments,
not only booleans, however it is not allowed in guards.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/kernel.ex#L2622" target="_blank" class="view_source">Source</a>
</div>
        </div>
      

      
    </div>
  </body>
</html>