Fresh docs!

modules/core/sequence.html

@@ -87,7 +87,7 @@ core <a href="../../control-flow.html#the-iterator-protocol">iterator protocol</
 <p>Iterates over the sequence, passing each element to the function <code>predicate</code>. 
 If it returns something <a href="../control-flow.html#truth">false</a>, stops iterating 
 and returns the value. Otherwise, returns <code>true</code>. </p>
-<div class="codehilite"><pre><span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span><span class="o">.</span><span class="n">all</span> <span class="p">{</span><span class="o">|</span><span class="err">n</span><span class="o">|</span> <span class="err">n</span> <span class="o">&gt;</span> <span class="mi">2</span><span class="p">})</span> <span class="output">false</span>
+<div class="codehilite"><pre><span></span><span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span><span class="o">.</span><span class="n">all</span> <span class="p">{</span><span class="o">|</span><span class="err">n</span><span class="o">|</span> <span class="err">n</span> <span class="o">&gt;</span> <span class="mi">2</span><span class="p">})</span> <span class="output">false</span>
 <span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span><span class="o">.</span><span class="n">all</span> <span class="p">{</span><span class="o">|</span><span class="err">n</span><span class="o">|</span> <span class="err">n</span> <span class="o">&lt;</span> <span class="mi">4</span><span class="p">})</span> <span class="output">true</span>
 </pre></div>
 
@@ -97,7 +97,7 @@ and returns the value. Otherwise, returns <code>true</code>. </p>
 <p>Iterates over the sequence, passing each element to the function <code>predicate</code>. 
 If it returns something <a href="../../control-flow.html#truth">true</a>, stops iterating and 
 returns that value. Otherwise, returns <code>false</code>. </p>
-<div class="codehilite"><pre><span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span><span class="o">.</span><span class="n">any</span> <span class="p">{</span><span class="o">|</span><span class="err">n</span><span class="o">|</span> <span class="err">n</span> <span class="o">&lt;</span> <span class="mi">1</span><span class="p">})</span> <span class="output">false</span>
+<div class="codehilite"><pre><span></span><span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span><span class="o">.</span><span class="n">any</span> <span class="p">{</span><span class="o">|</span><span class="err">n</span><span class="o">|</span> <span class="err">n</span> <span class="o">&lt;</span> <span class="mi">1</span><span class="p">})</span> <span class="output">false</span>
 <span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span><span class="o">.</span><span class="n">any</span> <span class="p">{</span><span class="o">|</span><span class="err">n</span><span class="o">|</span> <span class="err">n</span> <span class="o">&gt;</span> <span class="mi">2</span><span class="p">})</span> <span class="output">true</span>
 </pre></div>
 
@@ -112,14 +112,14 @@ sequence in order to determine how many elements it contains. </p>
 <p>Returns the number of elements in the sequence that pass the <code>predicate</code>. </p>
 <p>Iterates over the sequence, passing each element to the function <code>predicate</code> 
 and counting the number of times the returned value evaluates to <code>true</code>. </p>
-<div class="codehilite"><pre><span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span><span class="o">.</span><span class="n">count</span> <span class="p">{</span><span class="o">|</span><span class="err">n</span><span class="o">|</span> <span class="err">n</span> <span class="o">&gt;</span> <span class="mi">2</span><span class="p">})</span> <span class="output">1</span>
+<div class="codehilite"><pre><span></span><span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span><span class="o">.</span><span class="n">count</span> <span class="p">{</span><span class="o">|</span><span class="err">n</span><span class="o">|</span> <span class="err">n</span> <span class="o">&gt;</span> <span class="mi">2</span><span class="p">})</span> <span class="output">1</span>
 <span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span><span class="o">.</span><span class="n">count</span> <span class="p">{</span><span class="o">|</span><span class="err">n</span><span class="o">|</span> <span class="err">n</span> <span class="o">&lt;</span> <span class="mi">4</span><span class="p">})</span> <span class="output">3</span>
 </pre></div>
 
 
 <h3><strong>each</strong>(function) <a href="#each(function)" name="each(function)" class="header-anchor">#</a></h3>
 <p>Iterates over the sequence, passing each element to the given <code>function</code>. </p>
-<div class="codehilite"><pre><span class="p">[</span><span class="s">&quot;one&quot;</span><span class="p">,</span> <span class="s">&quot;two&quot;</span><span class="p">,</span> <span class="s">&quot;three&quot;</span><span class="p">]</span><span class="o">.</span><span class="n">each</span> <span class="p">{</span><span class="o">|</span><span class="n">word</span><span class="o">|</span> <span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">word</span><span class="p">)</span> <span class="p">}</span>
+<div class="codehilite"><pre><span></span><span class="p">[</span><span class="s">&quot;one&quot;</span><span class="p">,</span> <span class="s">&quot;two&quot;</span><span class="p">,</span> <span class="s">&quot;three&quot;</span><span class="p">]</span><span class="o">.</span><span class="n">each</span> <span class="p">{</span><span class="o">|</span><span class="n">word</span><span class="o">|</span> <span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">word</span><span class="p">)</span> <span class="p">}</span>
 </pre></div>
 
 
@@ -137,7 +137,7 @@ together into a single string. </p>
 <h3><strong>map</strong>(transformation) <a href="#map(transformation)" name="map(transformation)" class="header-anchor">#</a></h3>
 <p>Creates a new sequence that applies the <code>transformation</code> to each element in the 
 original sequence while it is iterated. </p>
-<div class="codehilite"><pre><span class="k">var</span> <span class="n">doubles</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span><span class="o">.</span><span class="n">map</span> <span class="p">{</span><span class="o">|</span><span class="err">n</span><span class="o">|</span> <span class="err">n</span> <span class="o">*</span> <span class="mi">2</span> <span class="p">}</span> 
+<div class="codehilite"><pre><span></span><span class="k">var</span> <span class="n">doubles</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span><span class="o">.</span><span class="n">map</span> <span class="p">{</span><span class="o">|</span><span class="err">n</span><span class="o">|</span> <span class="err">n</span> <span class="o">*</span> <span class="mi">2</span> <span class="p">}</span> 
 <span class="k">for</span> <span class="p">(</span><span class="err">n</span> <span class="k">in</span> <span class="n">doubles</span><span class="p">)</span> <span class="p">{</span> 
   <span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="err">n</span><span class="p">)</span> <span class="output">2</span>
                   <span class="output">4</span>
@@ -153,7 +153,7 @@ sequence. </p>
 that have side effects when you iterate over them. But it also means that 
 changes to the original sequence will be reflected in the mapped sequence. </p>
 <p>To force eager evaluation, just call <code>.toList</code> on the result. </p>
-<div class="codehilite"><pre><span class="k">var</span> <span class="n">numbers</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span> 
+<div class="codehilite"><pre><span></span><span class="k">var</span> <span class="n">numbers</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span> 
 <span class="k">var</span> <span class="n">doubles</span> <span class="o">=</span> <span class="n">numbers</span><span class="o">.</span><span class="n">map</span> <span class="p">{</span><span class="o">|</span><span class="err">n</span><span class="o">|</span> <span class="err">n</span> <span class="o">*</span> <span class="mi">2</span> <span class="p">}</span><span class="o">.</span><span class="n">toList</span> 
 <span class="n">numbers</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span> 
 <span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">doubles</span><span class="p">)</span> <span class="output">[2, 4, 6]</span>
@@ -170,9 +170,20 @@ iteratively updating the accumulator. </p>
 <h3><strong>reduce</strong>(seed, function) <a href="#reduce(seed,-function)" name="reduce(seed,-function)" class="header-anchor">#</a></h3>
 <p>Similar to above, but uses <code>seed</code> for the initial value of the accumulator. If 
 the sequence is empty, returns <code>seed</code>. </p>
+<h3><strong>skip</strong>(count) <a href="#skip(count)" name="skip(count)" class="header-anchor">#</a></h3>
+<p>Creates a new sequence that skips the first <code>count</code> elements of the original 
+sequence. </p>
+<p>The returned sequence is <em>lazy</em>. The first <code>count</code> elements are only skipped 
+once you start to iterate the returned sequence. Changes to the original 
+sequence will be reflected in the filtered sequence. </p>
+<h3><strong>take</strong>(count) <a href="#take(count)" name="take(count)" class="header-anchor">#</a></h3>
+<p>Creates a new sequence that iterates only the first <code>count</code> elements of the 
+original sequence. </p>
+<p>The returned sequence is <em>lazy</em>. Changes to the original sequence will be 
+reflected in the filtered sequence. </p>
 <h3><strong>toList</strong> <a href="#tolist" name="tolist" class="header-anchor">#</a></h3>
 <p>Creates a <a href="list.html">list</a> containing all the elements in the sequence. </p>
-<div class="codehilite"><pre><span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">((</span><span class="mi">1</span><span class="o">..</span><span class="mi">3</span><span class="p">)</span><span class="o">.</span><span class="n">toList</span><span class="p">)</span>  <span class="output">[1, 2, 3]</span>
+<div class="codehilite"><pre><span></span><span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">((</span><span class="mi">1</span><span class="o">..</span><span class="mi">3</span><span class="p">)</span><span class="o">.</span><span class="n">toList</span><span class="p">)</span>  <span class="output">[1, 2, 3]</span>
 </pre></div>
 
 
@@ -182,7 +193,7 @@ the sequence is empty, returns <code>seed</code>. </p>
 that pass the <code>predicate</code>. </p>
 <p>During iteration, each element in the original sequence is passed to the 
 function <code>predicate</code>. If it returns <code>false</code>, the element is skipped. </p>
-<div class="codehilite"><pre><span class="k">var</span> <span class="n">odds</span> <span class="o">=</span> <span class="p">(</span><span class="mi">1</span><span class="o">..</span><span class="mi">6</span><span class="p">)</span><span class="o">.</span><span class="n">where</span> <span class="p">{</span><span class="o">|</span><span class="err">n</span><span class="o">|</span> <span class="err">n</span> <span class="o">%</span> <span class="mi">2</span> <span class="o">==</span> <span class="mi">1</span> <span class="p">}</span> 
+<div class="codehilite"><pre><span></span><span class="k">var</span> <span class="n">odds</span> <span class="o">=</span> <span class="p">(</span><span class="mi">1</span><span class="o">..</span><span class="mi">6</span><span class="p">)</span><span class="o">.</span><span class="n">where</span> <span class="p">{</span><span class="o">|</span><span class="err">n</span><span class="o">|</span> <span class="err">n</span> <span class="o">%</span> <span class="mi">2</span> <span class="o">==</span> <span class="mi">1</span> <span class="p">}</span> 
 <span class="k">for</span> <span class="p">(</span><span class="err">n</span> <span class="k">in</span> <span class="n">odds</span><span class="p">)</span> <span class="p">{</span> 
     <span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="err">n</span><span class="p">)</span> <span class="output">1</span>
                     <span class="output">3</span>
@@ -199,7 +210,7 @@ sequences that have side effects when you iterate over them. But it also means
 that changes to the original sequence will be reflected in the filtered 
 sequence. </p>
 <p>To force eager evaluation, just call <code>.toList</code> on the result. </p>
-<div class="codehilite"><pre><span class="k">var</span> <span class="n">numbers</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">]</span> 
+<div class="codehilite"><pre><span></span><span class="k">var</span> <span class="n">numbers</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">]</span> 
 <span class="k">var</span> <span class="n">odds</span> <span class="o">=</span> <span class="n">numbers</span><span class="o">.</span><span class="n">where</span> <span class="p">{</span><span class="o">|</span><span class="err">n</span><span class="o">|</span> <span class="err">n</span> <span class="o">%</span> <span class="mi">2</span> <span class="o">==</span> <span class="mi">1</span> <span class="p">}</span><span class="o">.</span><span class="n">toList</span> 
 <span class="n">numbers</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="mi">7</span><span class="p">)</span> 
 <span class="vg">System</span><span class="o">.</span><span class="n">print</span><span class="p">(</span><span class="n">odds</span><span class="p">)</span> <span class="output">[1, 3, 5]</span>