docs/master/Enum.html

<!DOCTYPE html>
<html>
  <head>
    <title>Enum</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>
        Enum
        
      </h1>

      
        <div id="moduledoc" class="docstring">
          <p>Provides a set of algorithms that enumerate over collections according to the
<code>Enum.Iterator</code> protocol. Most of the functions in this module have two
flavours. If a given collection implements the mentioned protocol (like
list, for instance), you can do:</p>

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

<p>Depending on the type of the collection, the user-provided function will
accept a certain type of argument. For dicts, the argument is always a
<code>{ key, value }</code> tuple.</p>

        </div>
      

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

      

      

      
        <h2>Functions summary</h2>
        <ul class="summary">
          <li>
  <span class="summary_signature">
    <a href="#all?/2">all?/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#any?/2">any?/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#at!/2">at!/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#count/1">count/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#count/2">count/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#drop/2">drop/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#drop_while/2">drop_while/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#each/2">each/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#empty?/1">empty?/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#filter/2">filter/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#filter_map/3">filter_map/3</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#find/3">find/3</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#find_index/2">find_index/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#find_value/3">find_value/3</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#first/1">first/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#join/2">join/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#map/2">map/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#map_join/3">map_join/3</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#map_reduce/3">map_reduce/3</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#partition/2">partition/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#reduce/3">reduce/3</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#reverse/1">reverse/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#sort/1">sort/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#sort/2">sort/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#split/2">split/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#split_while/2">split_while/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#take/2">take/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#take_while/2">take_while/2</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#uniq/1">uniq/1</a>
  </span>
</li>
<li>
  <span class="summary_signature">
    <a href="#zip/2">zip/2</a>
  </span>
</li>

        </ul>
      

      

      

      
        <div id="functions_details" class="details_list">
          <h2>Functions</h2>
          <div class="detail">
  <p class="signature" id="all?/2">
    <strong>all?(collection, fun // fn x -&gt; x end)</strong>
  </p>
  <div class="docstring"><p>Invokes the given <code>fun</code> for each item in the <code>collection</code> and returns true if
each invocation returns true as well, otherwise it short-circuits and returns
false.</p>

<h2>Examples</h2>

<pre><code>Enum.all? [2,4,6], fn(x) -&gt; rem(x, 2) == 0 end
#=&gt; true

Enum.all? [2,3,4], fn(x) -&gt; rem(x, 2) == 0 end
#=&gt; false
</code></pre>

<p>If no function is given, it defaults to checking if
all items in the collection evaluate to true.</p>

<pre><code>Enum.all? [1,2,3]   #=&gt; true
Enum.all? [1,nil,3] #=&gt; false
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L97" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="any?/2">
    <strong>any?(collection, fun // fn x -&gt; x end)</strong>
  </p>
  <div class="docstring"><p>Invokes the given <code>fun</code> for each item in the <code>collection</code> and returns true if
at least one invocation returns true. Returns false otherwise.</p>

<h2>Examples</h2>

<pre><code>Enum.any? [2,4,6], fn(x) -&gt; rem(x, 2) == 1 end
#=&gt; false

Enum.any? [2,3,4], fn(x) -&gt; rem(x, 2) == 1 end
#=&gt; true
</code></pre>

<p>If no function is given, it defaults to checking if
at least one item in the collection evaluates to true.</p>

<pre><code>Enum.any? [false,false,false] #=&gt; false
Enum.any? [false,true,false]  #=&gt; true
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L134" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="at!/2">
    <strong>at!(collection, n)</strong>
  </p>
  <div class="docstring"><p>Finds the element at the given index (zero-based).
Raises out of bounds error in case the given position
is outside the range of the collection.</p>

<p>Expects an ordered collection.</p>

<p>## Examples</p>

<pre><code>  Enum.at! [2,4,6], 0 #=&gt; 2
  Enum.at! [2,4,6], 2 #=&gt; 6
  Enum.at! [2,4,6], 4 #=&gt; raises Enum.OutOfBoundsError
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L164" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="count/1">
    <strong>count(collection)</strong>
  </p>
  <div class="docstring"><p>Returns the collection size.</p>

<h2>Examples</h2>

<pre><code>Enum.count [1,2,3] #=&gt; 3
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L186" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="count/2">
    <strong>count(collection, fun)</strong>
  </p>
  <div class="docstring"><p>Counts for how many items the function returns true.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L194" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="drop/2">
    <strong>drop(collection, count)</strong>
  </p>
  <div class="docstring"><p>Drops the first <code>count</code> items from the collection.
Expects an ordered collection.</p>

<h2>Examples</h2>

<pre><code>Enum.drop [1,2,3], 2  #=&gt; [3]
Enum.drop [1,2,3], 10 #=&gt; []
Enum.drop [1,2,3], 0  #=&gt; [1,2,3]
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L219" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="drop_while/2">
    <strong>drop_while(collection, fun)</strong>
  </p>
  <div class="docstring"><p>Drops items at the beginning of <code>collection</code> while <code>fun</code> returns true.
Expects an ordered collection.</p>

<h2>Examples</h2>

<pre><code>Enum.drop_while [1,2,3,4,5], fn(x) -&gt; x &lt; 3 end
#=&gt; [3,4,5]
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L247" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="each/2">
    <strong>each(collection, fun)</strong>
  </p>
  <div class="docstring"><p>Invokes the given <code>fun</code> for each item in the <code>collection</code>.
Returns the <code>collection</code> itself.</p>

<h2>Examples</h2>

<pre><code>Enum.each [&#39;some&#39;, &#39;example&#39;], fn(x) -&gt; IO.puts x end
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L270" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="empty?/1">
    <strong>empty?(collection)</strong>
  </p>
  <div class="docstring"><p>Returns true if the collection is empty, otherwise false.</p>

<h2>Examples</h2>

<pre><code>Enum.empty? []      #=&gt; true
Enum.empty? [1,2,3] #=&gt; false
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L295" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="filter/2">
    <strong>filter(collection, fun)</strong>
  </p>
  <div class="docstring"><p>Filters the collection, i.e. returns only those elements
for which <code>fun</code> returns true.</p>

<h2>Examples</h2>

<pre><code>Enum.filter [1, 2, 3], fn(x) -&gt; rem(x, 2) == 0 end
#=&gt; [2]
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L317" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="filter_map/3">
    <strong>filter_map(collection, filter, mapper)</strong>
  </p>
  <div class="docstring"><p>Filters the collection and maps its values in one pass.</p>

<h2>Examples</h2>

<pre><code>Enum.filter_map [1, 2, 3], fn(x) -&gt; rem(x, 2) == 0 end, &amp;1 * 2
#=&gt; [4]
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L340" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="find/3">
    <strong>find(collection, ifnone // nil, fun)</strong>
  </p>
  <div class="docstring"><p>Returns the first item for which <code>fun</code> returns a truthy value. If no such
item is found, returns <code>ifnone</code>.</p>

<h2>Examples</h2>

<pre><code>Enum.find [2,4,6], fn(x) -&gt; rem(x, 2) == 1 end
#=&gt; nil

Enum.find [2,4,6], 0, fn(x) -&gt; rem(x, 2) == 1 end
#=&gt; 0

Enum.find [2,3,4], fn(x) -&gt; rem(x, 2) == 1 end
#=&gt; 3
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L372" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="find_index/2">
    <strong>find_index(collection, fun)</strong>
  </p>
  <div class="docstring"><p>Similar to find, but returns the index (count starts with 0)
of the item instead of the element itself.</p>

<p>Expects an ordered collection.</p>

<h2>Examples</h2>

<pre><code>Enum.find_index [2,4,6], fn(x) -&gt; rem(x, 2) == 1 end
#=&gt; nil

Enum.find_index [2,3,4], fn(x) -&gt; rem(x, 2) == 1 end
#=&gt; 2
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L434" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="find_value/3">
    <strong>find_value(collection, ifnone // nil, fun)</strong>
  </p>
  <div class="docstring"><p>Similar to find, but returns the value of the function
invocation instead of the element itself.</p>

<h2>Examples</h2>

<pre><code>Enum.find_value [2,4,6], fn(x) -&gt; rem(x, 2) == 1 end
#=&gt; nil

Enum.find_value [2,3,4], fn(x) -&gt; rem(x, 2) == 1 end
#=&gt; true
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L403" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="first/1">
    <strong>first(collection)</strong>
  </p>
  <div class="docstring"><p>Returns the first item in the collection or nil otherwise.</p>

<h2>Examples</h2>

<pre><code>Enum.first []      #=&gt; nil
Enum.first [1,2,3] #=&gt; 1
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L457" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="join/2">
    <strong>join(collection, joiner // &quot;&quot;)</strong>
  </p>
  <div class="docstring"><p>Joins the given <code>collection</code> according to <code>joiner</code>.
Joiner can be either a binary or a list and the
result will be of the same type as joiner. If
joiner is not passed at all, it defaults to an
empty binary.</p>

<p>All items in the collection must be convertible
to binary, otherwise an error is raised.</p>

<h2>Examples</h2>

<pre><code>Enum.join([1,2,3])        #=&gt; &quot;123&quot;
Enum.join([1,2,3], &quot; = &quot;) #=&gt; &quot;1 = 2 = 3&quot;
Enum.join([1,2,3], &#39; = &#39;) #=&gt; &#39;1 = 2 = 3&#39;
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L487" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="map/2">
    <strong>map(collection, fun)</strong>
  </p>
  <div class="docstring"><p>Returns a new collection, where each item is the result
of invoking <code>fun</code> on each corresponding item of <code>collection</code>.
For dicts, the function accepts a key-value tuple.</p>

<h2>Examples</h2>

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

Enum.map [a: 1, b: 2], fn({k, v}) -&gt; { k, -v } end
#=&gt; [a: -1, b: -2]
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L521" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="map_join/3">
    <strong>map_join(collection, joiner // &quot;&quot;, mapper)</strong>
  </p>
  <div class="docstring"><p>Maps and joins the given <code>collection</code> in one pass.
Joiner can be either a binary or a list and the
result will be of the same type as joiner. If
joiner is not passed at all, it defaults to an
empty binary.</p>

<p>All items in the collection must be convertible
to binary, otherwise an error is raised.</p>

<h2>Examples</h2>

<pre><code>Enum.map_join([1,2,3], &amp;1 * 2)        #=&gt; &quot;246&quot;
Enum.map_join([1,2,3], &quot; = &quot;, &amp;1 * 2) #=&gt; &quot;2 = 4 = 6&quot;
Enum.map_join([1,2,3], &#39; = &#39;, &amp;1 * 2) #=&gt; &#39;2 = 4 = 6&#39;
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L553" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="map_reduce/3">
    <strong>map_reduce(collection, acc, f)</strong>
  </p>
  <div class="docstring"><p>Invokes the given <code>fun</code> for each item in the <code>collection</code>
while also keeping an accumulator. Returns a tuple where
the first element is the mapped collection and the second
one is the final accumulator.</p>

<p>For dicts, the first tuple element has to be a { key, value }
tuple itself.</p>

<h2>Examples</h2>

<pre><code>Enum.map_reduce [1, 2, 3], 0, fn(x, acc) -&gt; { x * 2, x + acc } end
#=&gt; { [2, 4, 6], 6 }
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L588" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="partition/2">
    <strong>partition(collection, fun)</strong>
  </p>
  <div class="docstring"><p>Partitions <code>collection</code> into two where the first one contains elements
for which <code>fun</code> returns a truthy value, and the second one -- for which <code>fun</code>
returns false or nil.</p>

<h2>Examples</h2>

<pre><code>Enum.partition [1, 2, 3], fn(x) -&gt; rem(x, 2) == 0 end
#=&gt; { [2], [1,3] }
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L613" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="reduce/3">
    <strong>reduce(collection, acc, fun)</strong>
  </p>
  <div class="docstring"><p>Invokes <code>fun</code> for each element in the collection passing that element and the
accumulator <code>acc</code> as arguments. <code>fun</code>&#39;s return value is stored in <code>acc</code>.
Returns the accumulator.</p>

<h2>Examples</h2>

<pre><code>Enum.reduce [1, 2, 3], 0, fn(x, acc) -&gt; x + acc end
#=&gt; 6
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L638" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="reverse/1">
    <strong>reverse(collection)</strong>
  </p>
  <div class="docstring"><p>Reverses the collection.</p>

<h2>Examples</h2>

<pre><code>Enum.reverse [1, 2, 3]
#=&gt; [3, 2, 1]
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L661" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="sort/1">
    <strong>sort(collection)</strong>
  </p>
  <div class="docstring"><p>Sorts the collection using the merge sort algorithm.</p>

<h2>Examples</h2>

<pre><code>Enum.sort [3,2,1] #=&gt; [1,2,3]
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L698" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="sort/2">
    <strong>sort(collection, fun)</strong>
  </p>
  <div class="docstring"><p>Sorts the collection using the merge sort algorithm.</p>

<h2>Examples</h2>

<pre><code>Enum.sort [3,2,1], &amp;1 &gt; &amp;2 #=&gt; [1,2,3]
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L720" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="split/2">
    <strong>split(collection, count)</strong>
  </p>
  <div class="docstring"><p>Splits the enumerable into two collections, leaving <code>count</code>
elements in the first one. If <code>count</code> is a negative number,
it starts couting from the back to the beginning of the
collection.</p>

<p>Be aware that a negative <code>count</code> implies the collection
will be iterate twice. One to calculate the position and
another one to do the actual splitting.</p>

<h2>Examples</h2>

<pre><code>Enum.split [1,2,3], 2  #=&gt; { [1,2], [3] }
Enum.split [1,2,3], 10 #=&gt; { [1,2,3], [] }
Enum.split [1,2,3], 0  #=&gt; { [], [1,2,3] }
Enum.split [1,2,3], -1 #=&gt; { [1,2], [3] }
Enum.split [1,2,3], -5 #=&gt; { [], [1,2,3] }
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L753" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="split_while/2">
    <strong>split_while(collection, fun)</strong>
  </p>
  <div class="docstring"><p>Splits <code>collection</code> at the first element, for which <code>fun</code> returns true.
Expects an ordered collection.</p>

<h2>Examples</h2>

<pre><code>Enum.split_while [1,2,3,4], fn x -&gt; x == 2 end
#=&gt; { [1], [2, 3, 4] }
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L781" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="take/2">
    <strong>take(collection, count)</strong>
  </p>
  <div class="docstring"><p>Takes the first <code>count</code> items from the collection. Expects an ordered
collection.</p>

<h2>Examples</h2>

<pre><code>Enum.take [1,2,3], 2  #=&gt; [1,2]
Enum.take [1,2,3], 10 #=&gt; [1,2,3]
Enum.take [1,2,3], 0  #=&gt; []
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L806" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="take_while/2">
    <strong>take_while(collection, fun)</strong>
  </p>
  <div class="docstring"><p>Takes the items at the beginning of <code>collection</code> while <code>fun</code> returns true.
Expects an ordered collection.</p>

<h2>Examples</h2>

<pre><code>Enum.take_while [1,2,3], fn(x) -&gt; x &lt; 3 end
#=&gt; [1, 2]
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L835" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="uniq/1">
    <strong>uniq(collection)</strong>
  </p>
  <div class="docstring"><p>Iterates the enumerable removing all duplicated items.</p>

<h2>Examples</h2>

<pre><code>Enum.uniq [1,2,3,2,1]
#=&gt; [1, 2, 3]
</code></pre>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L858" target="_blank" class="view_source">Source</a>
</div><div class="detail">
  <p class="signature" id="zip/2">
    <strong>zip(coll1, coll2)</strong>
  </p>
  <div class="docstring"><p>Zips corresponding elements from two collections into one list
of tuples. The number of elements in the resulting list is
dictated by the first enum. In case the second list is shorter,
values are filled with nil.</p>
</div>
  <a href="https://github.com/elixir-lang/elixir/blob/master/lib/elixir/lib/enum.ex#L878" target="_blank" class="view_source">Source</a>
</div>
        </div>
      

      

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